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;
mod bar;

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

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

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

    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.view));
        fields.add_field_function_get("editor", |_, _| Ok(DUMMY_STATE.editor));
        fields.add_field_function_get("log", |_, _| Ok(DUMMY_STATE.log));
        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(())
        });
    }

    fn add_methods<'lua, M: mlua::prelude::LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_function("quit", |_,  _: ()| {
            GlobalState::instance_mut().exit = true;
            Ok(())
        })
    }
}