use crate::bar::{BlockCommand, BlockConfig};
use crate::errors::ConfigError;
use crate::keyboard::handlers::{KeyBinding, KeyPress};
use crate::keyboard::keysyms::{self, Keysym};
use crate::keyboard::{Arg, KeyAction};
use crate::{ColorScheme, LayoutSymbolOverride};
use mlua::{Lua, Table, Value};
use x11rb::protocol::xproto::KeyButMask;

use super::lua_api;

pub fn parse_lua_config(
    input: &str,
    config_dir: Option<&std::path::Path>,
) -> Result<crate::Config, ConfigError> {
    let lua = Lua::new();

    if let Some(dir) = config_dir {
        if let Some(dir_str) = dir.to_str() {
            let setup_code = format!("package.path = '{}/?.lua;' .. package.path", dir_str);
            lua.load(&setup_code)
                .exec()
                .map_err(|e| ConfigError::LuaError(format!("Failed to set package.path: {}", e)))?;
        }
    }

    let builder = lua_api::register_api(&lua)?;

    lua.load(input)
        .exec()
        .map_err(|e| ConfigError::LuaError(format!("{}", e)))?;

    let builder_data = builder.borrow().clone();

    return Ok(crate::Config {
        border_width: builder_data.border_width,
        border_focused: builder_data.border_focused,
        border_unfocused: builder_data.border_unfocused,
        font: builder_data.font,
        gaps_enabled: builder_data.gaps_enabled,
        gap_inner_horizontal: builder_data.gap_inner_horizontal,
        gap_inner_vertical: builder_data.gap_inner_vertical,
        gap_outer_horizontal: builder_data.gap_outer_horizontal,
        gap_outer_vertical: builder_data.gap_outer_vertical,
        terminal: builder_data.terminal,
        modkey: builder_data.modkey,
        tags: builder_data.tags,
        layout_symbols: builder_data.layout_symbols,
        keybindings: builder_data.keybindings,
        status_blocks: builder_data.status_blocks,
        scheme_normal: builder_data.scheme_normal,
        scheme_occupied: builder_data.scheme_occupied,
        scheme_selected: builder_data.scheme_selected,
        autostart: builder_data.autostart,
    });

    #[allow(unreachable_code)]
    {
    let config: Table = lua
        .load(input)
        .eval()
        .map_err(|e| ConfigError::LuaError(format!("{}", e)))?;
    let border_width: u32 = get_table_field(&config, "border_width")?;
    let border_focused: u32 = parse_color(&config, "border_focused")?;
    let border_unfocused: u32 = parse_color(&config, "border_unfocused")?;
    let font: String = get_table_field(&config, "font")?;

    let gaps_enabled: bool = get_table_field(&config, "gaps_enabled")?;
    let gap_inner_horizontal: u32 = get_table_field(&config, "gap_inner_horizontal")?;
    let gap_inner_vertical: u32 = get_table_field(&config, "gap_inner_vertical")?;
    let gap_outer_horizontal: u32 = get_table_field(&config, "gap_outer_horizontal")?;
    let gap_outer_vertical: u32 = get_table_field(&config, "gap_outer_vertical")?;

    let terminal: String = get_table_field(&config, "terminal")?;
    let modkey = parse_modkey(&config)?;

    let tags = parse_tags(&config)?;
    let layout_symbols = parse_layout_symbols(&config)?;
    let keybindings = parse_keybindings(&config, modkey)?;
    let status_blocks = parse_status_blocks(&config)?;

    let scheme_normal = parse_color_scheme(&config, "scheme_normal")?;
    let scheme_occupied = parse_color_scheme(&config, "scheme_occupied")?;
    let scheme_selected = parse_color_scheme(&config, "scheme_selected")?;

    let autostart = parse_autostart(&config)?;

    Ok(crate::Config {
        border_width,
        border_focused,
        border_unfocused,
        font,
        gaps_enabled,
        gap_inner_horizontal,
        gap_inner_vertical,
        gap_outer_horizontal,
        gap_outer_vertical,
        terminal,
        modkey,
        tags,
        layout_symbols,
        keybindings,
        status_blocks,
        scheme_normal,
        scheme_occupied,
        scheme_selected,
        autostart,
    })
    }
}

fn get_table_field<T>(table: &Table, field: &str) -> Result<T, ConfigError>
where
    T: mlua::FromLua,
{
    table
        .get::<T>(field)
        .map_err(|e| ConfigError::LuaError(format!("Failed to get field '{}': {}", field, e)))
}

fn parse_color(table: &Table, field: &str) -> Result<u32, ConfigError> {
    let value: Value = table.get(field).map_err(|e| {
        ConfigError::LuaError(format!("Failed to get color field '{}': {}", field, e))
    })?;

    match value {
        Value::String(s) => {
            let s = s.to_str().map_err(|e| {
                ConfigError::LuaError(format!("Invalid UTF-8 in color string: {}", e))
            })?;
            parse_color_string(&s)
        }
        Value::Integer(i) => Ok(i as u32),
        Value::Number(n) => Ok(n as u32),
        _ => Err(ConfigError::LuaError(format!(
            "Color field '{}' must be a string or number",
            field
        ))),
    }
}

fn parse_color_string(s: &str) -> Result<u32, ConfigError> {
    let s = s.trim();
    if s.starts_with('#') {
        u32::from_str_radix(&s[1..], 16)
            .map_err(|e| ConfigError::LuaError(format!("Invalid hex color '{}': {}", s, e)))
    } else if s.starts_with("0x") {
        u32::from_str_radix(&s[2..], 16)
            .map_err(|e| ConfigError::LuaError(format!("Invalid hex color '{}': {}", s, e)))
    } else {
        s.parse::<u32>()
            .map_err(|e| ConfigError::LuaError(format!("Invalid color '{}': {}", s, e)))
    }
}

fn parse_modkey(config: &Table) -> Result<KeyButMask, ConfigError> {
    let modkey_str: String = get_table_field(config, "modkey")?;
    parse_modkey_string(&modkey_str)
}

fn parse_modkey_string(s: &str) -> Result<KeyButMask, ConfigError> {
    match s {
        "Mod1" => Ok(KeyButMask::MOD1),
        "Mod2" => Ok(KeyButMask::MOD2),
        "Mod3" => Ok(KeyButMask::MOD3),
        "Mod4" => Ok(KeyButMask::MOD4),
        "Mod5" => Ok(KeyButMask::MOD5),
        "Shift" => Ok(KeyButMask::SHIFT),
        "Control" => Ok(KeyButMask::CONTROL),
        _ => Err(ConfigError::InvalidModkey(s.to_string())),
    }
}

fn parse_tags(config: &Table) -> Result<Vec<String>, ConfigError> {
    let tags_table: Table = get_table_field(config, "tags")?;
    let mut tags = Vec::new();

    for i in 1..=tags_table
        .len()
        .map_err(|e| ConfigError::LuaError(format!("Failed to get tags length: {}", e)))?
    {
        let tag: String = tags_table.get(i).map_err(|e| {
            ConfigError::LuaError(format!("Failed to get tag at index {}: {}", i, e))
        })?;
        tags.push(tag);
    }

    Ok(tags)
}

fn parse_layout_symbols(config: &Table) -> Result<Vec<LayoutSymbolOverride>, ConfigError> {
    let layout_symbols_result: Result<Table, _> = config.get("layout_symbols");

    match layout_symbols_result {
        Ok(layout_symbols_table) => {
            let mut layout_symbols = Vec::new();

            for i in 1..=layout_symbols_table.len().map_err(|e| {
                ConfigError::LuaError(format!("Failed to get layout_symbols length: {}", e))
            })? {
                let entry: Table = layout_symbols_table.get(i).map_err(|e| {
                    ConfigError::LuaError(format!(
                        "Failed to get layout_symbol at index {}: {}",
                        i, e
                    ))
                })?;

                let name: String = get_table_field(&entry, "name")?;
                let symbol: String = get_table_field(&entry, "symbol")?;

                layout_symbols.push(LayoutSymbolOverride { name, symbol });
            }

            Ok(layout_symbols)
        }
        Err(_) => Ok(Vec::new()),
    }
}

fn parse_keybindings(config: &Table, modkey: KeyButMask) -> Result<Vec<KeyBinding>, ConfigError> {
    let keybindings_table: Table = get_table_field(config, "keybindings")?;
    let mut keybindings = Vec::new();

    for i in 1..=keybindings_table
        .len()
        .map_err(|e| ConfigError::LuaError(format!("Failed to get keybindings length: {}", e)))?
    {
        let kb_table: Table = keybindings_table.get(i).map_err(|e| {
            ConfigError::LuaError(format!("Failed to get keybinding at index {}: {}", i, e))
        })?;

        let keys = parse_keypress_list(&kb_table, modkey)?;
        let action = parse_key_action(&kb_table)?;
        let arg = parse_arg(&kb_table)?;

        keybindings.push(KeyBinding::new(keys, action, arg));
    }

    Ok(keybindings)
}

fn parse_keypress_list(kb_table: &Table, modkey: KeyButMask) -> Result<Vec<KeyPress>, ConfigError> {
    let keys_result: Result<Table, _> = kb_table.get("keys");

    if let Ok(keys_table) = keys_result {
        let mut keys = Vec::new();
        for i in 1..=keys_table
            .len()
            .map_err(|e| ConfigError::LuaError(format!("Failed to get keys length: {}", e)))?
        {
            let key_entry: Table = keys_table.get(i).map_err(|e| {
                ConfigError::LuaError(format!("Failed to get key at index {}: {}", i, e))
            })?;

            let modifiers = parse_modifiers(&key_entry, "modifiers", modkey)?;
            let keysym = parse_keysym(&key_entry, "key")?;

            keys.push(KeyPress { modifiers, keysym });
        }
        Ok(keys)
    } else {
        let modifiers = parse_modifiers(kb_table, "modifiers", modkey)?;
        let keysym = parse_keysym(kb_table, "key")?;

        Ok(vec![KeyPress { modifiers, keysym }])
    }
}

fn parse_modifiers(
    table: &Table,
    field: &str,
    modkey: KeyButMask,
) -> Result<Vec<KeyButMask>, ConfigError> {
    let mods_table: Table = get_table_field(table, field)?;
    let mut modifiers = Vec::new();

    for i in 1..=mods_table
        .len()
        .map_err(|e| ConfigError::LuaError(format!("Failed to get modifiers length: {}", e)))?
    {
        let mod_str: String = mods_table.get(i).map_err(|e| {
            ConfigError::LuaError(format!("Failed to get modifier at index {}: {}", i, e))
        })?;

        let modifier = if mod_str == "Mod" {
            modkey
        } else {
            parse_modkey_string(&mod_str)?
        };

        modifiers.push(modifier);
    }

    Ok(modifiers)
}

fn parse_keysym(table: &Table, field: &str) -> Result<Keysym, ConfigError> {
    let key_str: String = get_table_field(table, field)?;
    string_to_keysym(&key_str)
}

fn string_to_keysym(s: &str) -> Result<Keysym, ConfigError> {
    let keysym = match s {
        "Return" => keysyms::XK_RETURN,
        "Q" => keysyms::XK_Q,
        "Escape" => keysyms::XK_ESCAPE,
        "Space" => keysyms::XK_SPACE,
        "Tab" => keysyms::XK_TAB,
        "Backspace" => keysyms::XK_BACKSPACE,
        "Delete" => keysyms::XK_DELETE,
        "F1" => keysyms::XK_F1,
        "F2" => keysyms::XK_F2,
        "F3" => keysyms::XK_F3,
        "F4" => keysyms::XK_F4,
        "F5" => keysyms::XK_F5,
        "F6" => keysyms::XK_F6,
        "F7" => keysyms::XK_F7,
        "F8" => keysyms::XK_F8,
        "F9" => keysyms::XK_F9,
        "F10" => keysyms::XK_F10,
        "F11" => keysyms::XK_F11,
        "F12" => keysyms::XK_F12,
        "A" => keysyms::XK_A,
        "B" => keysyms::XK_B,
        "C" => keysyms::XK_C,
        "D" => keysyms::XK_D,
        "E" => keysyms::XK_E,
        "F" => keysyms::XK_F,
        "G" => keysyms::XK_G,
        "H" => keysyms::XK_H,
        "I" => keysyms::XK_I,
        "J" => keysyms::XK_J,
        "K" => keysyms::XK_K,
        "L" => keysyms::XK_L,
        "M" => keysyms::XK_M,
        "N" => keysyms::XK_N,
        "O" => keysyms::XK_O,
        "P" => keysyms::XK_P,
        "R" => keysyms::XK_R,
        "S" => keysyms::XK_S,
        "T" => keysyms::XK_T,
        "U" => keysyms::XK_U,
        "V" => keysyms::XK_V,
        "W" => keysyms::XK_W,
        "X" => keysyms::XK_X,
        "Y" => keysyms::XK_Y,
        "Z" => keysyms::XK_Z,
        "0" => keysyms::XK_0,
        "1" => keysyms::XK_1,
        "2" => keysyms::XK_2,
        "3" => keysyms::XK_3,
        "4" => keysyms::XK_4,
        "5" => keysyms::XK_5,
        "6" => keysyms::XK_6,
        "7" => keysyms::XK_7,
        "8" => keysyms::XK_8,
        "9" => keysyms::XK_9,
        "Left" => keysyms::XK_LEFT,
        "Right" => keysyms::XK_RIGHT,
        "Up" => keysyms::XK_UP,
        "Down" => keysyms::XK_DOWN,
        "Home" => keysyms::XK_HOME,
        "End" => keysyms::XK_END,
        "PageUp" => keysyms::XK_PAGE_UP,
        "PageDown" => keysyms::XK_PAGE_DOWN,
        "Insert" => keysyms::XK_INSERT,
        "Minus" => keysyms::XK_MINUS,
        "Equal" => keysyms::XK_EQUAL,
        "BracketLeft" => keysyms::XK_LEFT_BRACKET,
        "BracketRight" => keysyms::XK_RIGHT_BRACKET,
        "Semicolon" => keysyms::XK_SEMICOLON,
        "Apostrophe" => keysyms::XK_APOSTROPHE,
        "Grave" => keysyms::XK_GRAVE,
        "Backslash" => keysyms::XK_BACKSLASH,
        "Comma" => keysyms::XK_COMMA,
        "Period" => keysyms::XK_PERIOD,
        "Slash" => keysyms::XK_SLASH,
        "AudioRaiseVolume" => keysyms::XF86_AUDIO_RAISE_VOLUME,
        "AudioLowerVolume" => keysyms::XF86_AUDIO_LOWER_VOLUME,
        "AudioMute" => keysyms::XF86_AUDIO_MUTE,
        "MonBrightnessUp" => keysyms::XF86_MON_BRIGHTNESS_UP,
        "MonBrightnessDown" => keysyms::XF86_MON_BRIGHTNESS_DOWN,
        _ => return Err(ConfigError::UnknownKey(s.to_string())),
    };

    Ok(keysym)
}

fn parse_key_action(kb_table: &Table) -> Result<KeyAction, ConfigError> {
    let action_str: String = get_table_field(kb_table, "action")?;
    string_to_key_action(&action_str)
}

fn string_to_key_action(s: &str) -> Result<KeyAction, ConfigError> {
    let action = match s {
        "Spawn" => KeyAction::Spawn,
        "SpawnTerminal" => KeyAction::SpawnTerminal,
        "KillClient" => KeyAction::KillClient,
        "FocusStack" => KeyAction::FocusStack,
        "FocusDirection" => KeyAction::FocusDirection,
        "SwapDirection" => KeyAction::SwapDirection,
        "Quit" => KeyAction::Quit,
        "Restart" => KeyAction::Restart,
        "Recompile" => KeyAction::Recompile,
        "ViewTag" => KeyAction::ViewTag,
        "ToggleGaps" => KeyAction::ToggleGaps,
        "ToggleFullScreen" => KeyAction::ToggleFullScreen,
        "ToggleFloating" => KeyAction::ToggleFloating,
        "ChangeLayout" => KeyAction::ChangeLayout,
        "CycleLayout" => KeyAction::CycleLayout,
        "MoveToTag" => KeyAction::MoveToTag,
        "FocusMonitor" => KeyAction::FocusMonitor,
        "SmartMoveWin" => KeyAction::SmartMoveWin,
        "ExchangeClient" => KeyAction::ExchangeClient,
        "ShowKeybindOverlay" => KeyAction::ShowKeybindOverlay,
        "None" => KeyAction::None,
        _ => return Err(ConfigError::UnknownAction(s.to_string())),
    };

    Ok(action)
}

fn parse_arg(kb_table: &Table) -> Result<Arg, ConfigError> {
    let arg_result: Result<Value, _> = kb_table.get("arg");

    match arg_result {
        Ok(Value::Nil) | Err(_) => Ok(Arg::None),
        Ok(Value::String(s)) => {
            let s = s
                .to_str()
                .map_err(|e| ConfigError::LuaError(format!("Invalid UTF-8 in arg: {}", e)))?;
            Ok(Arg::Str(s.to_string()))
        }
        Ok(Value::Integer(i)) => Ok(Arg::Int(i as i32)),
        Ok(Value::Number(n)) => Ok(Arg::Int(n as i32)),
        Ok(Value::Table(t)) => {
            let mut arr = Vec::new();
            for i in 1..=t.len().map_err(|e| {
                ConfigError::LuaError(format!("Failed to get arg array length: {}", e))
            })? {
                let item: String = t.get(i).map_err(|e| {
                    ConfigError::LuaError(format!(
                        "Failed to get arg array item at index {}: {}",
                        i, e
                    ))
                })?;
                arr.push(item);
            }
            Ok(Arg::Array(arr))
        }
        Ok(_) => Err(ConfigError::LuaError(
            "Arg must be nil, string, number, or array".to_string(),
        )),
    }
}

fn parse_status_blocks(config: &Table) -> Result<Vec<BlockConfig>, ConfigError> {
    let blocks_table: Table = get_table_field(config, "status_blocks")?;
    let mut blocks = Vec::new();

    for i in 1..=blocks_table
        .len()
        .map_err(|e| ConfigError::LuaError(format!("Failed to get status_blocks length: {}", e)))?
    {
        let block_table: Table = blocks_table.get(i).map_err(|e| {
            ConfigError::LuaError(format!("Failed to get status_block at index {}: {}", i, e))
        })?;

        let format: String = get_table_field(&block_table, "format")?;
        let command_str: String = get_table_field(&block_table, "command")?;

        let interval_secs: u64 = {
            let value: Value = block_table.get("interval_secs").map_err(|e| {
                ConfigError::LuaError(format!("Failed to get interval_secs: {}", e))
            })?;
            match value {
                Value::Integer(i) => i as u64,
                Value::Number(n) => n as u64,
                _ => {
                    return Err(ConfigError::LuaError(
                        "interval_secs must be a number".to_string(),
                    ));
                }
            }
        };

        let color: u32 = parse_color(&block_table, "color")?;
        let underline: bool = get_table_field(&block_table, "underline")?;

        let command = match command_str.as_str() {
            "DateTime" => {
                let fmt: String = get_table_field(&block_table, "command_arg")?;
                BlockCommand::DateTime(fmt)
            }
            "Shell" => {
                let cmd: String = get_table_field(&block_table, "command_arg")?;
                BlockCommand::Shell(cmd)
            }
            "Ram" => BlockCommand::Ram,
            "Static" => {
                let text_result: Result<String, _> = block_table.get("command_arg");
                let text = text_result.unwrap_or_default();
                BlockCommand::Static(text)
            }
            "Battery" => {
                let formats_table: Table = get_table_field(&block_table, "battery_formats")?;
                let format_charging: String = get_table_field(&formats_table, "charging")?;
                let format_discharging: String = get_table_field(&formats_table, "discharging")?;
                let format_full: String = get_table_field(&formats_table, "full")?;

                BlockCommand::Battery {
                    format_charging,
                    format_discharging,
                    format_full,
                }
            }
            _ => return Err(ConfigError::UnknownBlockCommand(command_str)),
        };

        blocks.push(BlockConfig {
            format,
            command,
            interval_secs,
            color,
            underline,
        });
    }

    Ok(blocks)
}

fn parse_color_scheme(config: &Table, field: &str) -> Result<ColorScheme, ConfigError> {
    let scheme_table: Table = get_table_field(config, field)?;

    let foreground = parse_color(&scheme_table, "foreground")?;
    let background = parse_color(&scheme_table, "background")?;
    let underline = parse_color(&scheme_table, "underline")?;

    Ok(ColorScheme {
        foreground,
        background,
        underline,
    })
}

fn parse_autostart(config: &Table) -> Result<Vec<String>, ConfigError> {
    let autostart_result: Result<Table, _> = config.get("autostart");

    match autostart_result {
        Ok(autostart_table) => {
            let mut autostart = Vec::new();

            for i in 1..=autostart_table.len().map_err(|e| {
                ConfigError::LuaError(format!("Failed to get autostart length: {}", e))
            })? {
                let cmd: String = autostart_table.get(i).map_err(|e| {
                    ConfigError::LuaError(format!(
                        "Failed to get autostart command at index {}: {}",
                        i, e
                    ))
                })?;
                autostart.push(cmd);
            }

            Ok(autostart)
        }
        Err(_) => Ok(Vec::new()),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_minimal_lua_config() {
        let config_str = r#"
return {
    border_width = 2,
    border_focused = 0x6dade3,
    border_unfocused = 0xbbbbbb,
    font = "monospace:style=Bold:size=10",

    gaps_enabled = true,
    gap_inner_horizontal = 5,
    gap_inner_vertical = 5,
    gap_outer_horizontal = 5,
    gap_outer_vertical = 5,

    modkey = "Mod4",
    terminal = "st",

    tags = {"1", "2", "3"},

    keybindings = {
        {modifiers = {"Mod4"}, key = "Return", action = "Spawn", arg = "st"},
        {modifiers = {"Mod4"}, key = "Q", action = "KillClient"},
    },

    status_blocks = {
        {format = "{}", command = "DateTime", command_arg = "%H:%M", interval_secs = 1, color = 0xffffff, underline = true},
    },

    scheme_normal = {foreground = 0xffffff, background = 0x000000, underline = 0x444444},
    scheme_occupied = {foreground = 0xffffff, background = 0x000000, underline = 0x444444},
    scheme_selected = {foreground = 0xffffff, background = 0x000000, underline = 0x444444},

    autostart = {},
}
"#;

        let config = parse_lua_config(config_str, None).expect("Failed to parse config");

        assert_eq!(config.border_width, 2);
        assert_eq!(config.border_focused, 0x6dade3);
        assert_eq!(config.terminal, "st");
        assert_eq!(config.tags.len(), 3);
        assert_eq!(config.keybindings.len(), 2);
        assert_eq!(config.status_blocks.len(), 1);
        assert!(config.gaps_enabled);
    }
}