use lumiere_domain::video::error::VideoError;
use lumiere_domain::video::model::library_item::{LibraryItem, LibraryItemType, LibraryRawItem};
use lumiere_domain::video::model::video::Video;
use lumiere_domain::video::port::VideoPort;
use uuid::Uuid;
use std::env;
use std::fs;
use std::fs::DirEntry;

#[derive(Clone)]
pub struct VideoAdapter {

}

impl VideoAdapter {
    pub fn new() -> Self {
        Self {}
    }

    fn get_root_folder_read_library_items(&self) -> Result<Vec<LibraryRawItem>, VideoError> {
        let root_folder = env::var("ROOT_FOLDER").map_err(|_| VideoError::FolderBrowsingTechnicalIssue)?;

        let root_folder_files = fs::read_dir(root_folder)
            .map_err(|_| VideoError::FolderBrowsingTechnicalIssue)?;

        root_folder_files.into_iter()
            .map(|file_entry|
                file_entry.map_err(|_| VideoError::FolderBrowsingTechnicalIssue)
                    .and_then(Self::map_file_into_library_raw_item)
            )
            .collect()
    }

    fn map_file_into_library_raw_item(file: DirEntry) -> Result<LibraryRawItem, VideoError> {
        let item_type = if file.path().is_dir() {
            LibraryItemType::FOLDER
        } else {
            LibraryItemType::VIDEO
        };

        let library_raw_item = LibraryRawItem::new(None, file.file_name().to_string_lossy().into_owned(), item_type);
        Ok(library_raw_item)
    }

    fn get_all_library_items_from_db(&self) -> Result<Vec<LibraryRawItem>, VideoError> {
        Ok(vec!())
    }

    fn merge_item_lists(file_system_items: Vec<LibraryRawItem>, db_items: Vec<LibraryRawItem>) -> Vec<LibraryRawItem> {
        let file_system_items_which_are_not_in_database: Vec<LibraryRawItem> = file_system_items.into_iter()
            .filter(|file_system_item| !Self::does_item_belong_to_db_items(&db_items, &file_system_item))
            .collect();

        db_items.into_iter().chain(file_system_items_which_are_not_in_database).collect()
    }

    fn does_item_belong_to_db_items(database_items: &Vec<LibraryRawItem>, file_system_item: &LibraryRawItem) -> bool {
        database_items.iter()
            .any(|database_item| database_item.id == file_system_item.id)
    }
}

impl VideoPort for VideoAdapter {
    fn list_root_folder(&self) -> Result<Vec<LibraryRawItem>, VideoError> {
        let file_system_items = self.get_root_folder_read_library_items()?;
        let db_items = self.get_all_library_items_from_db()?;

        let merged = Self::merge_item_lists(file_system_items, db_items);

        Ok(merged)
    }

    fn list_folder(&self, folder_id: Uuid) -> Result<Vec<LibraryRawItem>, VideoError> {
        todo!()
    }

    fn get_video_stream(&self, video_id: Uuid) -> Result<Video, VideoError> {
        todo!()
    }

    fn save(&self, library_item: &LibraryItem) -> Result<(), VideoError> {
        todo!()
    }

    fn save_all(&self, library_items: &Vec<LibraryItem>) -> Result<(), VideoError> {
        Ok(())
    }

    fn clone_box(&self) -> Box<dyn VideoPort> {
        Box::new(self.clone())
    }
}