use std::{
    collections::HashMap,
    sync::{Arc, Mutex, MutexGuard},
};

use element_bridge::TextureBridge;

pub type AllBuffers = Arc<Mutex<HashMap<usize, Arc<tokio::sync::Mutex<Vec<u8>>>>>>;

#[derive(Eq, Hash, PartialEq, Debug)]
pub struct WindowId {
    id: u64,
    name: String,
}
#[derive(Default)]
pub struct WindowsManager {
    inner: HashMap<WindowId, Arc<Mutex<TextureBridge>>>,

    all_bridges: Vec<(usize, Arc<Mutex<TextureBridge>>)>,

    all_revelant_buffers: Arc<Mutex<HashMap<usize, Arc<tokio::sync::Mutex<Vec<u8>>>>>>,
}

impl WindowsManager {
    pub fn new() -> Self {
        Self {
            inner: HashMap::new(),
            all_bridges: Vec::new(),
            all_revelant_buffers: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    pub fn edit_window<F>(&mut self, id: WindowId, f: F) -> (usize, Arc<Mutex<TextureBridge>>)
    where
        F: FnOnce(&mut TextureBridge),
    {
        let bridge = self.inner.get(&id).unwrap();
        let mut _bridge = bridge.lock().unwrap();
        f(&mut _bridge);
        (0, bridge.clone())
    }

    pub fn add_window(
        &mut self,
        id: WindowId,
        bridge: TextureBridge,
    ) -> (usize, Arc<Mutex<TextureBridge>>) {
        let bridge = Arc::new(Mutex::new(bridge));
        // New window
        self.inner
            .entry(id)
            .and_modify(|e| *e = bridge.clone())
            .or_insert(bridge.clone());

        let new_id = self.all_bridges.len();
        self.all_bridges.push((new_id, bridge.clone()));

        let buffer = {
            let bridge = bridge.lock().unwrap();
            bridge.buffer()
        };
        self.all_revelant_buffers
            .lock()
            .unwrap()
            .insert(new_id, buffer);

        (new_id, bridge)
    }

    pub fn get_bridge(&self, id: usize) -> Option<Arc<Mutex<TextureBridge>>> {
        self.all_bridges.get(id).map(|(_, bridge)| bridge.clone())
    }

    pub fn buffer(&self) -> AllBuffers {
        self.all_revelant_buffers.clone()
    }
}

impl WindowId {
    pub fn new<S: Into<String>>(name: S) -> Self {
        Self {
            id: 0,
            name: name.into(),
        }
    }
}

#[derive(Clone, Default)]
pub struct WM(Arc<std::sync::Mutex<WindowsManager>>);

impl WM {
    pub fn new() -> Self {
        Self(Arc::new(std::sync::Mutex::new(WindowsManager::new())))
    }

    pub fn windows_manager(&self) -> Arc<std::sync::Mutex<WindowsManager>> {
        self.0.clone()
    }

    pub fn wm(&self) -> MutexGuard<'_, WindowsManager> {
        self.0.lock().unwrap()
    }
}