//! Input simulation module.
//!
//! Receives HUD commands from the Butterfly server (forwarded from browser viewers)
//! and executes them as real mouse/keyboard events on the local machine. This is
//! the core of the remote control functionality — a viewer in the browser can
//! move the mouse, click, type, and scroll on the remote machine in real time.
//!
//! Uses the `enigo` crate for cross-platform input injection:
//! - Windows: SendInput Win32 API
//! - macOS: CoreGraphics CGEvent
//! - Linux: X11 XTest extension

use anyhow::Result;
use enigo::{Button, Direction, Enigo, Key, Settings, Coordinate};
use log::{info, warn};

/// Manages input simulation on the local machine.
pub struct InputHandler {
    enigo: Enigo,
    screen_width: u32,
    screen_height: u32,
}

impl InputHandler {
    /// Create a new input handler.
    ///
    /// `screen_width` and `screen_height` are the dimensions of the captured
    /// display. Mouse coordinates from viewers are in this coordinate space.
    pub fn new(screen_width: u32, screen_height: u32) -> Result<Self> {
        let enigo = Enigo::new(&Settings::default())
            .map_err(|e| anyhow::anyhow!("failed to initialize input handler: {}", e))?;

        info!(
            "input handler initialized (screen {}x{})",
            screen_width, screen_height
        );

        Ok(Self {
            enigo,
            screen_width,
            screen_height,
        })
    }

    /// Execute a HUD command received from a viewer.
    ///
    /// Commands:
    /// - `mouse_move` — Move the cursor to (x, y).
    /// - `mouse_down` — Press a mouse button (left/middle/right).
    /// - `mouse_up` — Release a mouse button.
    /// - `mouse_click` — Click a mouse button (press + release).
    /// - `mouse_dblclick` — Double-click a mouse button.
    /// - `scroll` — Scroll vertically/horizontally.
    /// - `key_down` — Press a key.
    /// - `key_up` — Release a key.
    /// - `key_click` — Type a key (press + release).
    /// - `key_type` — Type a string of characters.
    pub fn execute(&mut self, command: &str, params: &serde_json::Value) -> Result<()> {
        match command {
            "mouse_move" => self.mouse_move(params),
            "mouse_down" => self.mouse_down(params),
            "mouse_up" => self.mouse_up(params),
            "mouse_click" => self.mouse_click(params),
            "mouse_dblclick" => self.mouse_double_click(params),
            "scroll" => self.scroll(params),
            "key_down" => self.key_down(params),
            "key_up" => self.key_up(params),
            "key_click" => self.key_click(params),
            "key_type" => self.key_type(params),
            _ => {
                warn!("unknown HUD command: {}", command);
                Ok(())
            }
        }
    }

    // ── Mouse commands ─────────────────────────────────────────────────────

    /// Move the mouse cursor to the specified position.
    ///
    /// Params: `{ "x": number, "y": number }`
    fn mouse_move(&mut self, params: &serde_json::Value) -> Result<()> {
        let x = params["x"].as_i64().unwrap_or(0) as i32;
        let y = params["y"].as_i64().unwrap_or(0) as i32;

        // Clamp to screen bounds.
        let x = x.clamp(0, self.screen_width as i32 - 1);
        let y = y.clamp(0, self.screen_height as i32 - 1);

        self.enigo
            .move_mouse(x, y, Coordinate::Abs)
            .map_err(|e| anyhow::anyhow!("mouse_move failed: {}", e))?;

        Ok(())
    }

    /// Press a mouse button down.
    ///
    /// Params: `{ "button": number }` — 0=left, 1=middle, 2=right
    fn mouse_down(&mut self, params: &serde_json::Value) -> Result<()> {
        let button = json_to_button(params["button"].as_i64().unwrap_or(0));
        self.enigo
            .button(button, Direction::Press)
            .map_err(|e| anyhow::anyhow!("mouse_down failed: {}", e))?;
        Ok(())
    }

    /// Release a mouse button.
    fn mouse_up(&mut self, params: &serde_json::Value) -> Result<()> {
        let button = json_to_button(params["button"].as_i64().unwrap_or(0));
        self.enigo
            .button(button, Direction::Release)
            .map_err(|e| anyhow::anyhow!("mouse_up failed: {}", e))?;
        Ok(())
    }

    /// Click a mouse button (press + release).
    fn mouse_click(&mut self, params: &serde_json::Value) -> Result<()> {
        let button = json_to_button(params["button"].as_i64().unwrap_or(0));
        self.enigo
            .button(button, Direction::Click)
            .map_err(|e| anyhow::anyhow!("mouse_click failed: {}", e))?;
        Ok(())
    }

    /// Double-click a mouse button.
    fn mouse_double_click(&mut self, params: &serde_json::Value) -> Result<()> {
        let button = json_to_button(params["button"].as_i64().unwrap_or(0));
        // Double-click = two rapid clicks.
        self.enigo
            .button(button, Direction::Click)
            .map_err(|e| anyhow::anyhow!("mouse_dblclick (1st) failed: {}", e))?;
        std::thread::sleep(std::time::Duration::from_millis(30));
        self.enigo
            .button(button, Direction::Click)
            .map_err(|e| anyhow::anyhow!("mouse_dblclick (2nd) failed: {}", e))?;
        Ok(())
    }

    /// Scroll the mouse wheel.
    ///
    /// Params: `{ "deltaX": number, "deltaY": number }`
    /// Positive deltaY = scroll down, negative = scroll up.
    fn scroll(&mut self, params: &serde_json::Value) -> Result<()> {
        let delta_y = params["deltaY"].as_i64().unwrap_or(0) as i32;
        let delta_x = params["deltaX"].as_i64().unwrap_or(0) as i32;

        // Vertical scroll.
        if delta_y != 0 {
            let direction = if delta_y > 0 {
                Direction::ScrollDown
            } else {
                Direction::ScrollUp
            };
            let amount = delta_y.abs().min(50); // Clamp to prevent crazy scrolling.
            for _ in 0..amount {
                self.enigo
                    .scroll_y(1, direction)
                    .map_err(|e| anyhow::anyhow!("scroll_y failed: {}", e))?;
            }
        }

        // Horizontal scroll.
        if delta_x != 0 {
            let direction = if delta_x > 0 {
                Direction::ScrollRight
            } else {
                Direction::ScrollLeft
            };
            let amount = delta_x.abs().min(50);
            for _ in 0..amount {
                self.enigo
                    .scroll_x(1, direction)
                    .map_err(|e| anyhow::anyhow!("scroll_x failed: {}", e))?;
            }
        }

        Ok(())
    }

    // ── Keyboard commands ──────────────────────────────────────────────────

    /// Press a key down.
    ///
    /// Params: `{ "key": string, "code": string, "ctrl": bool, "shift": bool, "alt": bool, "meta": bool }`
    fn key_down(&mut self, params: &serde_json::Value) -> Result<()> {
        let key = map_key(
            params["code"].as_str().unwrap_or(""),
            params["key"].as_str().unwrap_or(""),
        );

        // Hold modifiers first (order matters for some combinations).
        if params["ctrl"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Control, Direction::Press);
        }
        if params["shift"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Shift, Direction::Press);
        }
        if params["alt"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Alt, Direction::Press);
        }
        if params["meta"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Meta, Direction::Press);
        }

        self.enigo
            .key(key, Direction::Press)
            .map_err(|e| anyhow::anyhow!("key_down failed: {}", e))?;

        Ok(())
    }

    /// Release a key.
    fn key_up(&mut self, params: &serde_json::Value) -> Result<()> {
        let key = map_key(
            params["code"].as_str().unwrap_or(""),
            params["key"].as_str().unwrap_or(""),
        );

        // Release the main key first.
        let _ = self.enigo.key(key, Direction::Release);

        // Release modifiers in reverse order.
        if params["meta"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Meta, Direction::Release);
        }
        if params["alt"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Alt, Direction::Release);
        }
        if params["shift"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Shift, Direction::Release);
        }
        if params["ctrl"].as_bool().unwrap_or(false) {
            let _ = self.enigo.key(Key::Control, Direction::Release);
        }

        Ok(())
    }

    /// Type a single key (press + release).
    fn key_click(&mut self, params: &serde_json::Value) -> Result<()> {
        let key = map_key(
            params["code"].as_str().unwrap_or(""),
            params["key"].as_str().unwrap_or(""),
        );

        self.enigo
            .key(key, Direction::Click)
            .map_err(|e| anyhow::anyhow!("key_click failed: {}", e))?;

        Ok(())
    }

    /// Type a string of characters.
    ///
    /// Params: `{ "text": string }`
    fn key_type(&mut self, params: &serde_json::Value) -> Result<()> {
        let text = params["text"].as_str().unwrap_or("");
        for ch in text.chars() {
            // Skip control characters.
            if ch.is_control() {
                continue;
            }
            if let Err(e) = self.enigo.key(Key::Unicode(ch), Direction::Click) {
                warn!("key_type failed for '{}': {}", ch, e);
            }
        }
        Ok(())
    }
}

// ── Helper functions ──────────────────────────────────────────────────────────

/// Convert a numeric button index to an `enigo::Button`.
///
/// 0 = Left, 1 = Middle, 2 = Right, 3 = Back, 4 = Forward
fn json_to_button(idx: i64) -> Button {
    match idx {
        1 => Button::Middle,
        2 => Button::Right,
        3 => Button::Back,
        4 => Button::Forward,
        _ => Button::Left,
    }
}

/// Map a browser keyboard event to an `enigo::Key`.
///
/// `code` is the physical key position (e.g., "KeyA", "ShiftLeft", "Digit1").
/// `key` is the logical key value (e.g., "a", "Shift", "1").
///
/// Strategy:
/// 1. If `key` is a single printable character, use `Key::Unicode(char)`.
/// 2. Otherwise, map `code` to the corresponding `Key` variant.
fn map_key(code: &str, key: &str) -> Key {
    // Printable single character — use Unicode for international keyboard support.
    if key.chars().count() == 1 {
        let ch = key.chars().next().unwrap();
        if !ch.is_control() {
            return Key::Unicode(ch);
        }
    }

    // Map physical key codes to enigo Key variants.
    match code {
        // ── Modifier keys ──────────────────────────────────────────────
        "ShiftLeft" | "ShiftRight" => Key::Shift,
        "ControlLeft" | "ControlRight" => Key::Control,
        "AltLeft" | "AltRight" => Key::Alt,
        "MetaLeft" | "MetaRight" => Key::Meta,

        // ── Whitespace / editing ────────────────────────────────────────
        "Backspace" => Key::Backspace,
        "Tab" => Key::Tab,
        "Enter" => Key::Return,
        "Space" => Key::Space,
        "Escape" => Key::Escape,

        // ── Arrow keys ──────────────────────────────────────────────────
        "ArrowUp" => Key::Up,
        "ArrowDown" => Key::Down,
        "ArrowLeft" => Key::Left,
        "ArrowRight" => Key::Right,

        // ── Function keys ───────────────────────────────────────────────
        "F1" => Key::F1,
        "F2" => Key::F2,
        "F3" => Key::F3,
        "F4" => Key::F4,
        "F5" => Key::F5,
        "F6" => Key::F6,
        "F7" => Key::F7,
        "F8" => Key::F8,
        "F9" => Key::F9,
        "F10" => Key::F10,
        "F11" => Key::F11,
        "F12" => Key::F12,
        "F13" => Key::F13,
        "F14" => Key::F14,
        "F15" => Key::F15,
        "F16" => Key::F16,
        "F17" => Key::F17,
        "F18" => Key::F18,
        "F19" => Key::F19,
        "F20" => Key::F20,

        // ── Lock keys ───────────────────────────────────────────────────
        "CapsLock" => Key::CapsLock,
        "NumLock" => Key::NumLock,
        "ScrollLock" => Key::ScrollLock,

        // ── Navigation / editing cluster ────────────────────────────────
        "Insert" => Key::Insert,
        "Delete" => Key::Delete,
        "Home" => Key::Home,
        "End" => Key::End,
        "PageUp" => Key::PageUp,
        "PageDown" => Key::PageDown,
        "PrintScreen" => Key::PrintScreen,
        "Pause" => Key::Pause,

        // ── Numpad ──────────────────────────────────────────────────────
        "Numpad0" => Key::Numpad0,
        "Numpad1" => Key::Numpad1,
        "Numpad2" => Key::Numpad2,
        "Numpad3" => Key::Numpad3,
        "Numpad4" => Key::Numpad4,
        "Numpad5" => Key::Numpad5,
        "Numpad6" => Key::Numpad6,
        "Numpad7" => Key::Numpad7,
        "Numpad8" => Key::Numpad8,
        "Numpad9" => Key::Numpad9,
        "NumpadAdd" => Key::NumpadAdd,
        "NumpadSubtract" => Key::NumpadSubtract,
        "NumpadMultiply" => Key::NumpadMultiply,
        "NumpadDivide" => Key::NumpadDivide,
        "NumpadDecimal" => Key::NumpadDecimal,
        "NumpadEnter" => Key::NumpadEnter,
        "NumLock" => Key::NumLock,

        // ── Punctuation / symbols ───────────────────────────────────────
        // These are handled as Unicode characters when sent via `key` field.
        // If only `code` is available, fall back to Unicode mapping.
        "BracketLeft" => Key::Unicode('['),
        "BracketRight" => Key::Unicode(']'),
        "Semicolon" => Key::Unicode(';'),
        "Quote" => Key::Unicode('\''),
        "Backquote" => Key::Unicode('`'),
        "Backslash" => Key::Unicode('\\'),
        "Slash" => Key::Unicode('/'),
        "Comma" => Key::Unicode(','),
        "Period" => Key::Unicode('.'),
        "Minus" => Key::Unicode('-'),
        "Equal" => Key::Unicode('='),

        // ── Fallback: try to use the key value as Unicode ───────────────
        _ => {
            if !key.is_empty() && key.chars().count() == 1 {
                Key::Unicode(key.chars().next().unwrap())
            } else {
                warn!("unmapped key code '{}', key '{}'", code, key);
                Key::Unicode('\0') // No-op key
            }
        }
    }
}