use std::time::{SystemTime, UNIX_EPOCH};

use mlua::prelude::*;

use crate::sheet::{cell::CellRef, register::Register};

pub mod iobuffer;

fn print(_: &Lua, args: LuaMultiValue) -> LuaResult<()> {
    let mut writer = iobuffer::iobuffer().write().unwrap();

    for (i, arg) in args.iter().enumerate() {
        if let Some(ud) = arg.as_userdata() {
            if ud.is::<CellRef>() {
                writer.write(ud.borrow::<CellRef>().unwrap().value().to_string());
            } else {
                writer.write(format!("{:#?}", ud));
            }
        } else {
            writer.write(format!("{:#?}", arg));
        }

        if i < args.len() - 1 {
            writer.write(", ");
        }
    }
    writer.writeln("");
    Ok(())
}

pub fn new_instance() -> LuaResult<Lua> {
    let lua = Lua::new();

    let print_binding = lua.create_function(print)?;
    lua.globals().set("print", print_binding)?;

    {
        let math = lua.globals().get::<_, LuaTable>("math");
        let randomseed = math.unwrap().get::<_, LuaFunction>("randomseed").unwrap();

        let seed = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis();
        randomseed.call::<_, ()>(seed).unwrap();
    }

    let neosheet = lua.create_table()?;

    let register = Register;
    neosheet.set("sheets", register)?;

    lua.globals().set("neosheet", neosheet)?;

    Ok(lua)
}

#[cfg(test)]
mod test {
    use mlua::Function;

    use super::new_instance;

    #[test]
    fn function_eval() {
        let lua = new_instance().unwrap();
        let func: Function = lua
            .load(
                r#"
            function(a, b, c)
                return a + b * c
            end
            "#,
            )
            .eval()
            .unwrap();
        eprintln!("{}", func.call::<_, String>((1, 2, 3, 4)).unwrap());
        assert!(false);
    }
}