use itertools::join;

use crate::{
    echo_to_term_frame, lua_engine::LuaState, parsing::parse_commands, GlobalMemoCell, TermFrame,
};

pub fn debrace(inp: &str) -> &str {
    let v = inp.trim();
    if v.starts_with("{") && v.ends_with("}") {
        &v[1..(v.len() - 1)]
    } else {
        v
    }
}

fn reentrant_command_handler(
    lua_state: &mut LuaState,
    globals: &GlobalMemoCell,
    term_frame: &TermFrame,
    command_in: &str,
) {
    echo_to_term_frame(globals, term_frame, "\r").unwrap_or(());
    lua_state.set_current_frame(term_frame);
    for command in parse_commands(command_in).commands {
        match command.split_out_command() {
            None => (),
            Some((cmd, rest)) => {
                if let ("#", command_rest) = cmd.split_at(1) {
                    if cmd == "##" {
                        match lua_state.execute(debrace(&join(rest.arguments.iter(), " "))) {
                            Ok(()) => (),
                            Err(msg) => {
                                echo_to_term_frame(globals, term_frame, &format!("{}\r\n", msg))
                                    .unwrap_or(())
                            }
                        }
                    } else if let Ok(repeat_count) = command_rest.parse::<u16>() {
                        for _ in 0..repeat_count {
                            reentrant_command_handler(
                                lua_state,
                                globals,
                                term_frame,
                                &join(rest.arguments.iter(), " "),
                            );
                        }
                    } else {
                        match lua_state.execute_command(command_rest, &rest.arguments) {
                            Ok(()) => (),
                            Err(msg) => {
                                echo_to_term_frame(globals, term_frame, &format!("{}\r\n", msg))
                                    .unwrap_or(())
                            }
                        }
                    }
                }
            }
        }
    }
}

pub fn command_handler(globals: &GlobalMemoCell, term_frame: &TermFrame, command_in: &str) {
    match globals.lua_engine.try_borrow_mut() {
        Err(_) => echo_to_term_frame(
            globals,
            term_frame,
            "Attempt to re-enter command handler during processing.\r\n",
        )
        .unwrap_or(()), // Ignore error handling error.
        Ok(mut lua_state_m) => {
            reentrant_command_handler(&mut lua_state_m, globals, term_frame, command_in)
        }
    }
}