#[cfg(unix)]
use std::process::Command;
#[cfg(unix)]
use std::env;
#[cfg(unix)]
use std::io::{BufRead, BufReader};
#[cfg(unix)]
use std::os::unix::net::UnixStream;
#[cfg(unix)]
use std::path::PathBuf;
use crate::config::ScytheConfig;
pub type VrecConfig = ScytheConfig;

pub fn is_hyprland() -> bool {
    #[cfg(unix)]
    {
        env::var("HYPRLAND_INSTANCE_SIGNATURE").is_ok()
            || env::var("XDG_CURRENT_DESKTOP")
                .map(|d| d.to_lowercase().contains("hyprland"))
                .unwrap_or(false)
    }
    #[cfg(not(unix))]
    {
        false
    }
}

/// Convert standard hotkey format (e.g. "Ctrl+Shift+R") to Hyprland bind format ("CONTROL_SHIFT, R")
pub fn hotkey_to_hyprland(hotkey: &str) -> Option<(String, String)> {
    let parts: Vec<&str> = hotkey.split('+').map(|s| s.trim()).collect();
    if parts.is_empty() {
        return None;
    }

    let mut mods = Vec::new();
    let mut key = "";

    for (i, &part) in parts.iter().enumerate() {
        if i == parts.len() - 1 {
            key = part;
        } else {
            let m = match part.to_lowercase().as_str() {
                "ctrl" | "control" => "CONTROL",
                "shift" => "SHIFT",
                "alt" => "ALT",
                "super" | "win" | "meta" => "SUPER",
                _ => continue,
            };
            mods.push(m);
        }
    }

    if key.is_empty() {
        return None;
    }

    let mod_str = if mods.is_empty() {
        "".to_string()
    } else {
        mods.join("_")
    };

    Some((mod_str, key.to_string()))
}

pub fn hotkey_to_hyprland_lua(hotkey: &str) -> Option<String> {
    let parts: Vec<&str> = hotkey.split('+').map(|s| s.trim()).collect();
    if parts.is_empty() {
        return None;
    }

    let mut mods = Vec::new();
    let mut key = "";

    for (i, &part) in parts.iter().enumerate() {
        if i == parts.len() - 1 {
            key = part;
        } else {
            let m = match part.to_lowercase().as_str() {
                "ctrl" | "control" => "CONTROL",
                "shift" => "SHIFT",
                "alt" => "ALT",
                "super" | "win" | "meta" => "SUPER",
                _ => continue,
            };
            mods.push(m);
        }
    }

    if key.is_empty() {
        return None;
    }

    if mods.is_empty() {
        Some(key.to_string())
    } else {
        Some(format!("{} + {}", mods.join(" + "), key))
    }
}

#[cfg(unix)]
static RULES_INITIALIZED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);

#[cfg(unix)]
/// Dynamically inject binds and window rules into running Hyprland without touching hyprland.conf
pub fn register_hyprland_binds(config: &ScytheConfig) {
    if !is_hyprland() {
        return;
    }

    if !RULES_INITIALIZED.swap(true, std::sync::atomic::Ordering::SeqCst) {
        // Register modern Hyprland (0.55+) layer rules for genuine frosted glass blur & floating window rules
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.layer_rule({ match = { namespace = "scythe-overlay" }, blur = true, ignore_alpha = 0.1 })"#])
            .output();
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.layer_rule({ match = { namespace = "scythe-notification" }, blur = true, ignore_alpha = 0.1 })"#])
            .output();
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.window_rule({ match = { class = "^(scythe-overlay)$" }, float = true, pin = true, move = {"0", "0"}, size = {"100%", "100%"}, no_anim = true, border = false, shadow = false, rounding = 0 })"#])
            .output();
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.window_rule({ match = { class = "^(scythe-toast)$" }, float = true, pin = true, move = {"(monitor_w-340)", "16"}, no_anim = true, border = false, shadow = false, rounding = 0 })"#])
            .output();
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.window_rule({ match = { title = "Select Recordings Directory" }, float = true, pin = true, stay_focused = true, center = true })"#])
            .output();
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.window_rule({ match = { class = "kdialog" }, float = true, pin = true, stay_focused = true, center = true })"#])
            .output();
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.window_rule({ match = { class = "org.kde.kdialog" }, float = true, pin = true, stay_focused = true, center = true })"#])
            .output();
        let _ = Command::new("hyprctl")
            .args(["eval", r#"hl.layer_rule({ match = { namespace = "vrec-overlay" }, blur = true, ignore_alpha = 0.1 })"#])
            .output();

    // Also register legacy window rules for backward compatibility with older Hyprland versions
    let legacy_rules = [
        "float, class:^(scythe-overlay)$",
        "move 0 0, class:^(scythe-overlay)$",
        "size 100% 100%, class:^(scythe-overlay)$",
        "pin, class:^(scythe-overlay)$",
        "noborder, class:^(scythe-overlay)$",
        "noshadow, class:^(scythe-overlay)$",
        "rounding 0, class:^(scythe-overlay)$",
        "stayfocused, class:^(scythe-overlay)$",
        "float, title:^(Select Recordings Directory)$",
        "pin, title:^(Select Recordings Directory)$",
        "stayfocused, title:^(Select Recordings Directory)$",
        "center, title:^(Select Recordings Directory)$",
        "float, class:^(kdialog)$",
        "pin, class:^(kdialog)$",
        "stayfocused, class:^(kdialog)$",
        "center, class:^(kdialog)$",
        "float, class:^(org.kde.kdialog)$",
        "pin, class:^(org.kde.kdialog)$",
        "stayfocused, class:^(org.kde.kdialog)$",
        "center, class:^(org.kde.kdialog)$",
        "float, class:^(scythe-hud)$",
        "move 0 0, class:^(scythe-hud)$",
        "size 100% 100%, class:^(scythe-hud)$",
        "pin, class:^(scythe-hud)$",
        "float, class:^(scythe-toast)$",
        "pin, class:^(scythe-toast)$",
        "noborder, class:^(scythe-toast)$",
        "move 100%-w 16, class:^(scythe-toast)$",
        "float, class:^(vrec-overlay)$",
        "move 0 0, class:^(vrec-overlay)$",
        "size 100% 100%, class:^(vrec-overlay)$",
        "pin, class:^(vrec-overlay)$",
        "noborder, class:^(vrec-overlay)$",
    ];
        for rule in legacy_rules {
            let _ = Command::new("hyprctl")
                .args(["keyword", "windowrulev2", rule])
                .output();
        }
    }

    let binds = [
        (&config.menu_hotkey, "scythe-ui --menu"),
        (&config.save_hotkey, "scythe-ui --save"),
        (&config.record_hotkey, "scythe-ui --record"),
        (&config.pause_hotkey, "scythe-ui --pause"),
        (&config.cursor_hotkey, "scythe-ui --cursor"),
        (&config.screenshot_hotkey, "scythe-ui --screenshot"),
        (&config.mute_mic_hotkey, "scythe-ui --mute-mic"),
        (&config.mute_sys_hotkey, "scythe-ui --mute-sys"),
    ];

    for (hotkey, cmd) in binds {
        unbind_hotkey(hotkey);

        // Try modern Hyprland Lua eval first
        if let Some(lua_combo) = hotkey_to_hyprland_lua(hotkey) {
            let lua_script = format!(r#"hl.bind("{}", hl.dsp.exec_cmd("{}"))"#, lua_combo, cmd);
            if let Ok(out) = Command::new("hyprctl").args(["eval", &lua_script]).output()
                && out.status.success() && String::from_utf8_lossy(&out.stdout).contains("ok") {
                    println!("Hyprland dynamic bind active (Lua): {}", lua_combo);
                    continue;
            }
        }

        // Fallback to legacy keyword bind
        if let Some((mods, key)) = hotkey_to_hyprland(hotkey) {
            let bind_arg = if mods.is_empty() {
                format!("{}, exec, {}", key, cmd)
            } else {
                format!("{}, {}, exec, {}", mods, key, cmd)
            };
            let res = Command::new("hyprctl")
                .args(["keyword", "bind", &bind_arg])
                .output();
            if let Ok(out) = res && out.status.success() {
                println!("Hyprland dynamic bind active (legacy): {}", bind_arg);
            }
        }
    }
}

#[cfg(unix)]
pub fn register_hyprland_binds_async(config: &ScytheConfig) {
    let cfg = config.clone();
    std::thread::spawn(move || {
        register_hyprland_binds(&cfg);
    });
}

#[cfg(unix)]
pub fn unbind_hotkey_async(hotkey: &str) {
    let hk = hotkey.to_string();
    std::thread::spawn(move || {
        unbind_hotkey(&hk);
    });
}

#[cfg(not(unix))]
pub fn register_hyprland_binds(_config: &ScytheConfig) {}
#[cfg(not(unix))]
pub fn register_hyprland_binds_async(_config: &ScytheConfig) {}
#[cfg(not(unix))]
pub fn unbind_hotkey_async(_hotkey: &str) {}

#[cfg(unix)]
/// Unbind a specific hotkey combo from running Hyprland
pub fn unbind_hotkey(hotkey: &str) {
    if !is_hyprland() {
        return;
    }

    if let Some(lua_combo) = hotkey_to_hyprland_lua(hotkey) {
        let lua_script = format!(
            r#"for i = 1, 10 do pcall(function() hl.unbind("{}") end) end"#,
            lua_combo
        );
        let _ = Command::new("hyprctl")
            .args(["eval", &lua_script])
            .output();
    }
    if let Some((mods, key)) = hotkey_to_hyprland(hotkey) {
        let unbind_arg = if mods.is_empty() {
            key
        } else {
            format!("{}, {}", mods, key)
        };
        let _ = Command::new("hyprctl")
            .args(["keyword", "unbind", &unbind_arg])
            .output();
    }
}

#[cfg(not(unix))]
pub fn unbind_hotkey(_hotkey: &str) {}

#[cfg(unix)]
/// Dynamically remove binds from running Hyprland
pub fn unregister_hyprland_binds(config: &ScytheConfig) {
    if !is_hyprland() {
        return;
    }

    let hotkeys = [
        &config.menu_hotkey,
        &config.save_hotkey,
        &config.record_hotkey,
        &config.cursor_hotkey,
    ];

    for hotkey in hotkeys {
        unbind_hotkey(hotkey);
    }
}

#[cfg(not(unix))]
pub fn unregister_hyprland_binds(_config: &ScytheConfig) {}

#[cfg(unix)]
/// Find Hyprland socket2 for live event listening
fn get_hyprland_socket2() -> Option<PathBuf> {
    let sig = env::var("HYPRLAND_INSTANCE_SIGNATURE").ok()?;
    let xdg_runtime = env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/run/user/1000".to_string());
    
    let path = PathBuf::from(format!("{}/hypr/{}/.socket2.sock", xdg_runtime, sig));
    if path.exists() {
        return Some(path);
    }
    let fallback = PathBuf::from(format!("/tmp/hypr/{}/.socket2.sock", sig));
    if fallback.exists() {
        return Some(fallback);
    }
    None
}

#[cfg(unix)]
/// Background watcher for Hyprland config reloads so dynamic binds are never lost
pub fn spawn_hyprland_reload_watcher() {
    if !is_hyprland() {
        return;
    }

    std::thread::spawn(|| {
        loop {
            if let Some(sock_path) = get_hyprland_socket2()
                && let Ok(stream) = UnixStream::connect(&sock_path) {
                    let reader = BufReader::new(stream);
                    for line in reader.lines().map_while(Result::ok) {
                        if line.starts_with("configreloaded") {
                            println!("Hyprland config reload detected! Re-registering scythe dynamic binds...");
                            let config = ScytheConfig::load();
                            register_hyprland_binds(&config);
                        }
                    }
            }
            std::thread::sleep(std::time::Duration::from_secs(3));
        }
    });
}

#[cfg(not(unix))]
pub fn spawn_hyprland_reload_watcher() {}

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

    #[test]
    fn test_hotkey_to_hyprland_conversion() {
        assert_eq!(
            hotkey_to_hyprland("Ctrl+Shift+R"),
            Some(("CONTROL_SHIFT".to_string(), "R".to_string()))
        );
        assert_eq!(
            hotkey_to_hyprland("Alt+Z"),
            Some(("ALT".to_string(), "Z".to_string()))
        );
        assert_eq!(
            hotkey_to_hyprland("Ctrl+Shift+F9"),
            Some(("CONTROL_SHIFT".to_string(), "F9".to_string()))
        );
        assert_eq!(
            hotkey_to_hyprland("F12"),
            Some(("".to_string(), "F12".to_string()))
        );
        assert_eq!(
            hotkey_to_hyprland("Super+Alt+S"),
            Some(("SUPER_ALT".to_string(), "S".to_string()))
        );
    }

    #[test]
    fn test_hotkey_to_hyprland_lua_conversion() {
        assert_eq!(
            hotkey_to_hyprland_lua("Ctrl+Shift+R"),
            Some("CONTROL + SHIFT + R".to_string())
        );
        assert_eq!(
            hotkey_to_hyprland_lua("Alt+Z"),
            Some("ALT + Z".to_string())
        );
        assert_eq!(
            hotkey_to_hyprland_lua("F12"),
            Some("F12".to_string())
        );
        assert_eq!(
            hotkey_to_hyprland_lua("Super+Alt+S"),
            Some("SUPER + ALT + S".to_string())
        );
    }
}