use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};

use mlua::{UserData, UserDataFields};

use self::log::LogState;

pub mod editor;
pub mod log;
pub mod view;
pub mod window;

#[derive(Debug, Default)]
pub struct GlobalState {
    pub sheetview: view::SheetViewState,
    pub editor: editor::EditorState,
    pub active_window: window::Window,
    pub log: log::LogState,
}

static GLOBAL_STATE: RwLock<GlobalState> = RwLock::new(GlobalState::new());
const DUMMY_STATE: GlobalState = GlobalState::new();

impl GlobalState {
    const fn new() -> Self {
        Self {
            sheetview: view::SheetViewState::new(),
            editor: editor::EditorState::new(),
            log: LogState::new(),
            active_window: window::Window::View,
        }
    }

    pub fn instance() -> RwLockReadGuard<'static, Self> {
        GLOBAL_STATE.read().unwrap()
    }

    pub fn instance_mut() -> RwLockWriteGuard<'static, Self> {
        GLOBAL_STATE.write().unwrap()
    }

    pub fn set_focus(&mut self, win: window::Window) {
        self.active_window = win;

        match win {
            window::Window::Editor => self.editor.visible = true,
            window::Window::Log => self.log.visible = true,
            _ => {}
        }
    }
}

impl UserData for GlobalState {
    fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
        fields.add_field_function_get("view", |_, _| Ok(DUMMY_STATE.sheetview));
        fields.add_field_function_get("editor", |_, _| Ok(DUMMY_STATE.editor));
        fields.add_field_function_get("active_window", |_, _| {
            Ok(GlobalState::instance().active_window)
        });
        fields.add_field_function_set("active_window", |_, _, win: window::Window| {
            GlobalState::instance_mut().set_focus(win);
            Ok(())
        });
    }
}