use futures::{stream::FuturesUnordered, StreamExt};
use once_cell::sync::OnceCell;
use paris::{info, warn};
use scrap::Display;
use std::{borrow::Borrow, sync::Arc};
use tokio::{sync::Mutex, task};

use crate::picker::{config, screen::Screen};

use super::{
    config::DisplayConfig,
    display_picker::DisplayPicker,
    manager::Picker,
    screenshot::{Screenshot, ScreenshotDto},
};

pub struct PreviewPicker {
    pub pickers: Arc<Mutex<Vec<Arc<Mutex<DisplayPicker>>>>>,
    pub screenshots: Arc<Mutex<Vec<Screenshot>>>,
}

impl PreviewPicker {
    pub fn global() -> &'static PreviewPicker {
        static SCREEN_COLOR_PREVIEW_PICKER: OnceCell<PreviewPicker> = OnceCell::new();

        SCREEN_COLOR_PREVIEW_PICKER.get_or_init(|| PreviewPicker {
            pickers: Arc::new(Mutex::new(vec![])),
            screenshots: Arc::new(Mutex::new(vec![])),
        })
    }

    pub async fn list_displays(&self) {
        let mut pickers = self.pickers.lock().await;
        let displays = Display::all()
            .map_err(|error| anyhow::anyhow!("Can not get all of displays. {}", error))?;

        let mut configs = vec![];
        let mut futs = FuturesUnordered::new();

        for (index, display) in displays.iter().enumerate() {
            let height = display.height();
            let width = display.width();
            let config = DisplayConfig::default(index, width, height);
            configs.push(config);
        }

        for config in configs.iter() {
            let picker = DisplayPicker::from_config(*config);
            match picker {
                Ok(picker) => {
                    pickers.push(Arc::new(Mutex::new(picker)));
                }
                Err(_) => {
                    warn!(
                        "can not create DisplayPicker from config. config: {:?}",
                        config
                    );
                }
            }
        }
    }

    pub async fn get_screenshot_by_config(
        &self,
        config: DisplayConfig,
    ) -> anyhow::Result<ScreenshotDto> {
        let start = time::Instant::now();
        let mut picker = DisplayPicker::from_config(config)?;
        let screenshot = picker.take_screenshot()?;
        info!("Take Screenshot Spend: {}", start.elapsed());

        anyhow::Ok(screenshot.to_dto().await)
    }

    pub async fn preview_display_by_config(config: DisplayConfig) -> anyhow::Result<ScreenshotDto> {
        let start = time::Instant::now();
        let mut picker = DisplayPicker::from_config(config)?;
        let screenshot = picker.take_screenshot()?;
        info!("Take Screenshot Spend: {}", start.elapsed());

        anyhow::Ok(screenshot.to_dto().await)
    }
}