use std::{collections::{HashMap, HashSet}, sync::{Arc, Mutex}};
use egui::{ViewportBuilder, ViewportId};
use crate::GuiState;

#[cfg(debug_assertions)]
mod debug;
mod error;
mod settings;

lazy_static::lazy_static!(
    static ref WINDOWS: Arc<Mutex<HashMap<WindowId, Box<dyn Window>>>> = Arc::new(Mutex::new(HashMap::new()));
    static ref OPEN_WINDOWS: Arc<Mutex<HashSet<WindowId>>> = Arc::new(Mutex::new(HashSet::new()));

);

pub trait Window: std::fmt::Debug + Send {
    fn draw(&mut self, ui: &mut egui::Ui, state: &mut GuiState) -> crate::Result<()>;
}

#[derive(Debug, Clone, Hash, PartialEq, PartialOrd, Ord, Eq)]
pub enum WindowId {
    Settings,
    Error,
    #[cfg(debug_assertions)]
    Debug
}

#[derive(Debug, Clone)]
pub struct Windows {
    windows: HashMap<WindowId, (ViewportId, ViewportBuilder)>,
}

impl Windows {
    pub fn new() -> Self {
        let mut  s = Self {
            windows: HashMap::new(),
        };
        s.add_all_windows();
        s
    }

    pub fn add_all_windows(&mut self) {
        self.add_new_window(WindowId::Error, "Error!", Box::<error::ErrorW>::default());
        self.add_new_window(WindowId::Settings, "Settings", Box::<settings::SettingsW>::default());
        #[cfg(debug_assertions)]
        self.add_new_window(WindowId::Debug, "Debug", Box::<debug::DebugW>::default());
    }

    pub fn add_new_window(&mut self, id: WindowId, title: &str, cb: Box<dyn Window>) {
        let builder = ViewportBuilder::default()
            .with_window_type(egui::X11WindowType::Dialog)
            .with_title(title);
        self.windows.insert(id.clone(), (ViewportId::from_hash_of(id.clone()), builder));
        WINDOWS.lock().unwrap().insert(id, cb);
    }

    pub fn draw_all(&mut self, ctx: &egui::Context, state: &mut GuiState) {
        let theme = handle_error_ui!(xmpd_settings::Settings::get()).theme.clone();
        for (win_id, (vp_id, builder)) in &self.windows {
            if self.is_open(&win_id) {
                ctx.show_viewport_immediate(vp_id.clone(), builder.clone(), |ctx, _vp_class| {        
                    ctx.input(|inp| {
                        self.toggle(win_id, !inp.viewport().close_requested());
                    });
                    egui::CentralPanel::default()
                        .frame(
                            egui::Frame::none()
                                .fill(theme.primary_bg_color)
                                .stroke(egui::Stroke::new(
                                    1.0,
                                    theme.secondary_bg_color,
                                )),
                        )
                        .show(ctx, |ui| {
                            ui.style_mut().visuals.override_text_color = Some(theme.text_color);
                            WINDOWS.lock().unwrap().get_mut(&win_id).unwrap().draw(ui, state)
                    }) 
                });
            }
        }
    }

    pub fn toggle(&self, id: &WindowId, status: bool) {
        if status {
            OPEN_WINDOWS.lock().unwrap().insert(id.clone());
        } else {
            OPEN_WINDOWS.lock().unwrap().remove(id);
        }
    }

    pub fn is_open(&self, id: &WindowId) -> bool {
        OPEN_WINDOWS.lock().unwrap().contains(&id)
    }
}