//! 取词：智能路径（UIA 直读）优先，兼容路径（模拟 Ctrl+C）兜底。
//!
//! 整个流程在**调用方的阻塞线程**上执行（最长约 1s）。**严禁在主线程调用**：
//! 全局快捷键回调与 UI 线程都不该被这段等待卡住。命令层用 `spawn_blocking` 包装，
//! 快捷键回调自行 `std::thread::spawn`。

use std::time::{Duration, Instant};

use serde::Serialize;
use specta::Type;
use tauri::{AppHandle, Manager};

use crate::clipboard::reader::{read_clipboard, write_dib, write_files, write_text, ClipData};
use crate::clipboard::ClipboardManager;
use crate::translate::engines::{ErrorKind, TranslateError};
use windows_sys::Win32::Foundation::CloseHandle;
use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber;
use windows_sys::Win32::System::Threading::{
    OpenProcess, QueryFullProcessImageNameW, PROCESS_QUERY_LIMITED_INFORMATION,
};
use windows_sys::Win32::UI::Input::KeyboardAndMouse::{
    GetAsyncKeyState, SendInput, INPUT, INPUT_KEYBOARD, KEYBDINPUT, KEYEVENTF_KEYUP, VK_CONTROL,
};
use windows_sys::Win32::UI::WindowsAndMessaging::{
    GetForegroundWindow, GetWindowThreadProcessId,
};

/// 模拟按键后等待剪贴板更新的上限。
///
/// 300ms 偏短：浏览器、Electron 应用、带插件的编辑器在复制前还要走一遍自己的
/// 命令分发，慢一点的直接超时。放宽到 600ms 后失败率明显下降，而用户感知的
/// 「按下到弹出」延迟仍在可接受范围（取词是主动行为，不是输入反馈）。
const PASTE_WAIT: Duration = Duration::from_millis(600);
/// 轮询间隔
const POLL_INTERVAL: Duration = Duration::from_millis(10);
/// 等用户自然松开修饰键的时间（见 [`neutralise_modifiers`]）
const MOD_RELEASE_WAIT: Duration = Duration::from_millis(400);

const VK_C: u16 = 0x43;
const VK_V: u16 = 0x56;
const VK_INSERT: u16 = 0x2D;
const VK_MENU: u16 = 0x12; // Alt
const VK_SHIFT: u16 = 0x10;
const VK_LWIN: u16 = 0x5B;
const VK_RWIN: u16 = 0x5C;

/// 会「污染」Ctrl+C 的修饰键：按下时目标应用看到的是 Alt+Ctrl+C 之类，
/// 没有任何应用把它当复制。Alt 与 Shift 会被强制松开（见 [`neutralise_modifiers`]）。
const BLOCKING_MODIFIERS: [u16; 2] = [VK_MENU, VK_SHIFT];
/// 参与「等自然松开」但不强制合成的键：合成 Win 抬起会触发开始菜单，代价太大。
const WAIT_ONLY_MODIFIERS: [u16; 2] = [VK_LWIN, VK_RWIN];

/// 取词参数（来自设置）
#[derive(Debug, Clone)]
pub struct CaptureRequest {
    /// 文本字符数上限，超出直接拒绝而不是发一个巨大的请求
    pub max_chars: usize,
    /// 取词后是否还原剪贴板
    pub restore_clipboard: bool,
    /// 跳过取词的进程名黑名单（终端类）
    pub blacklist: Vec<String>,
    /// 取词方式："smart"（UIA 直读优先，失败退回模拟按键）| "compat"（只用模拟按键）
    pub mode: String,
}

/// 取词结果
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CaptureOutcome {
    pub text: String,
    /// 取词来源："clipboard"（模拟 Ctrl+C）
    pub source: String,
    /// 取词时的前台窗口句柄（P3 回填替换选区时要用，事后无法补齐）
    pub source_hwnd: i64,
    /// 前台窗口所属进程名（用于提示与黑名单判定）
    pub source_process: String,
    /// 剪贴板是否被成功还原。false 有两种情况：备份时剪贴板是**不支持的格式**
    /// （如仅含 HTML/RTF，无法原样写回），或还原本身失败——此时选区文本会留在剪贴板上。
    pub restored_clipboard: bool,
}

/// 执行一次取词。**阻塞**，见模块头注释。
///
/// 并发互斥：连按快捷键（以为没反应再按一次是常见操作）会让两套
/// 「备份 → Ctrl+C → 轮询 → 还原」并发执行，互相覆盖剪贴板状态。
/// 在途时后来者直接放弃，静默返回。
pub fn capture_selection(
    app: &AppHandle,
    req: &CaptureRequest,
) -> Result<CaptureOutcome, TranslateError> {
    use std::sync::atomic::{AtomicBool, Ordering};

    static IN_FLIGHT: AtomicBool = AtomicBool::new(false);
    if IN_FLIGHT.swap(true, Ordering::SeqCst) {
        return Err(TranslateError::new(
            ErrorKind::Empty,
            "上一次取词仍在进行中",
        ));
    }
    let result = capture_selection_inner(app, req);
    IN_FLIGHT.store(false, Ordering::SeqCst);
    result
}

fn capture_selection_inner(
    app: &AppHandle,
    req: &CaptureRequest,
) -> Result<CaptureOutcome, TranslateError> {
    let (hwnd, process) = foreground_window_process();
    let process_name = process.clone().unwrap_or_default();

    if !process_name.is_empty()
        && req
            .blacklist
            .iter()
            .any(|b| b.trim().eq_ignore_ascii_case(&process_name))
    {
        return Err(TranslateError::unsupported(format!(
            "「{process_name}」中 Ctrl+C 是中断信号，无法用于取词。\
             请选中文字后复制，再用「翻译剪贴板」快捷键。"
        )));
    }

    // ===== 智能路径：UIA 直读（不动键盘、不碰剪贴板）=====
    // 命中即返回：既避免了修饰键残留 / 提权窗口 / 剪贴板占用这三类兼容路径问题，
    // 也快得多（一次跨进程 COM 调用 vs 一次 600ms 的剪贴板等待）。
    if req.mode.trim() != "compat" {
        if let Some(text) = uia_selection() {
            crate::logger::log_info(
                "translate",
                &format!(
                    "取词：UIA 直读命中（{} 字符），前台进程 {:?}",
                    text.chars().count(),
                    process_name
                ),
            );
            return finish_text(req, text, hwnd, &process_name, true);
        }
    }

    // 屏蔽窗口覆盖「Ctrl+C 覆盖剪贴板 → 读走 → 还原」的全过程。
    // 守卫析构时自动解除，提前 return 也不会漏。
    let suppress = app.try_state::<ClipboardManager>().map(|m| m.suppress());
    let _guard = suppress.as_ref().map(|s| s.burst());

    let backup = read_clipboard();
    let before = clipboard_seq();

    // 关键：先让修饰键回到「都没按」的状态，再发 Ctrl+C。
    // 全局快捷键是在**按下**的瞬间触发的，此刻 Alt 必然还被物理按住；
    // 直接补发 Ctrl+C，目标应用收到的是 Alt+Ctrl+C —— 复制不会发生，
    // 于是必然走到下面的「取词超时」。这是兼容路径取不到词最主要的原因。
    let forced = neutralise_modifiers();

    send_ctrl_c();
    let mut updated = wait_clipboard_change(before, PASTE_WAIT);
    // 重试一次：部分应用首次按键被自身的输入法/菜单状态吃掉，第二次才真正复制。
    // 复制是幂等的，多按一次没有副作用，比直接判定失败划算。
    if !updated {
        send_ctrl_c();
        updated = wait_clipboard_change(before, PASTE_WAIT / 2);
    }
    // Ctrl+Insert 兜底：个别应用对合成的 Ctrl+C 不响应，但认经典的复制和弦
    // （控制台/部分老程序对 Ctrl+Insert 的处理路径也与 Ctrl+C 不同）。
    // 无选区时该组合键无副作用，与「复制是幂等的」同理。
    if !updated {
        crate::logger::log_info(
            "translate",
            &format!("取词：Ctrl+C 未更新剪贴板（前台进程 {process_name:?}），改试 Ctrl+Insert"),
        );
        send_ctrl_insert();
        updated = wait_clipboard_change(before, PASTE_WAIT / 2);
    }
    let clip = if updated { read_clipboard() } else { None };
    // 键盘状态尽早复原：越早把 Alt 按回去，越不容易让目标应用进入菜单栏模式
    restore_modifiers(&forced);

    if !updated {
        return Err(TranslateError::new(
            ErrorKind::Empty,
            "取词失败：模拟 Ctrl+C 后剪贴板没有更新。\
             常见原因是目标窗口以管理员权限运行（系统会丢弃来自普通权限程序的模拟按键），\
             或该应用不支持复制选区。可改用「翻译剪贴板」：先复制，再按对应快捷键。"
                .to_string(),
        ));
    }

    // 剪贴板已被目标应用覆盖为选区内容。**先还原再做一切判定**：
    // 还原必须覆盖所有后续路径（非文本 / 空文本 / 超限 / 成功），
    // 否则「取词失败」的代价是用户剪贴板被悄悄换掉，与 restore_clipboard 设置矛盾。
    let restored = if req.restore_clipboard {
        restore_clipboard(backup)
    } else {
        false
    };
    // 还原本身也改了剪贴板。虽然还在屏蔽窗口内，但窗口解除后监听可能才轮到这一次变化，
    // 于是额外精确记账一次，把边界情况的漏网也堵上。
    if restored {
        if let Some(s) = suppress.as_ref() {
            s.mark_seq(clipboard_seq());
        }
    }

    let text = match clip {
        Some(ClipData::Text(t)) => t,
        Some(_) => {
            return Err(TranslateError::new(
                ErrorKind::Empty,
                "取到的内容不是文本（选区可能是图片或文件）",
            ))
        }
        None => {
            return Err(TranslateError::new(
                ErrorKind::Empty,
                "未获取到选中文本：目标窗口可能不允许复制，或当前没有选中任何文字",
            ))
        }
    };

    finish_text(
        req,
        text,
        hwnd,
        &process_name,
        // UIA 路径：剪贴板从头到尾没被碰过
        restored,
    )
}

/// 取到文本后的公共收尾：裁剪 → 空判定 → 字数上限 → 组装结果。
///
/// 两条取词路径（UIA 直读 / 模拟 Ctrl+C）都必须过这套校验，否则「字数上限」
/// 只对其中一条生效——那正是配置里写「上限」却仍被绕过的原因。
fn finish_text(
    req: &CaptureRequest,
    text: String,
    hwnd: i64,
    process_name: &str,
    clip_intact: bool,
) -> Result<CaptureOutcome, TranslateError> {
    let trimmed = text.trim();
    if trimmed.is_empty() {
        return Err(TranslateError::new(
            ErrorKind::Empty,
            "未获取到选中文本（取到的内容为空）",
        ));
    }
    let char_count = trimmed.chars().count();
    if req.max_chars > 0 && char_count > req.max_chars {
        return Err(TranslateError::unsupported(format!(
            "选中内容 {char_count} 字符，超过取词上限（{}）。\
             请在「翻译 → 设置 → 划词翻译」中调高上限，或改用主面板翻译。",
            req.max_chars
        )));
    }

    Ok(CaptureOutcome {
        text: trimmed.to_string(),
        source: "selection".to_string(),
        source_hwnd: hwnd,
        source_process: process_name.to_string(),
        restored_clipboard: clip_intact,
    })
}

fn clipboard_seq() -> u32 {
    unsafe { GetClipboardSequenceNumber() }
}

/// UIA 直读选区（智能路径）。`windows` crate 只在 Windows 目标上参与构建，
/// 因此非 Windows 目标这里直接返回 None（等价于「读不到」→ 走兼容路径）。
#[cfg(windows)]
fn uia_selection() -> Option<String> {
    super::uia_capture::read_selection()
}

#[cfg(not(windows))]
fn uia_selection() -> Option<String> {
    None
}

/// 等剪贴板序号变化（即目标应用完成了复制）。
fn wait_clipboard_change(before: u32, timeout: Duration) -> bool {
    let deadline = Instant::now() + timeout;
    while Instant::now() < deadline {
        if clipboard_seq() != before {
            return true;
        }
        std::thread::sleep(POLL_INTERVAL);
    }
    false
}

fn key_down(vk: u16) -> bool {
    (unsafe { GetAsyncKeyState(vk as i32) } as u16 & 0x8000) != 0
}

/// 发送单个按键事件（`up` 为真表示抬起）。
fn send_key(vk: u16, up: bool) {
    let mut input: INPUT = unsafe { std::mem::zeroed() };
    input.r#type = INPUT_KEYBOARD;
    input.Anonymous.ki = KEYBDINPUT {
        wVk: vk,
        wScan: 0,
        dwFlags: if up { KEYEVENTF_KEYUP } else { 0 },
        time: 0,
        dwExtraInfo: 0,
    };
    unsafe {
        SendInput(1, &input, std::mem::size_of::<INPUT>() as i32);
    }
}

/// 让修饰键回到「都没按」的状态，返回被**强制**松开的键（调用方负责按回去）。
///
/// 两步走，顺序很重要：
/// 1. **先等用户自然松开**。全局快捷键在按键**按下**的瞬间触发，此刻 Alt 一定还按着；
///    绝大多数情况用户几十毫秒内就松手了，等一下既解决了问题，又完全不用合成按键
///    （合成 Alt 抬起有让目标应用进入菜单栏模式的风险）。
/// 2. 超时仍未松开（长按、卡键）才合成抬起事件。只处理 Alt/Shift：合成 Win 抬起
///    会触发开始菜单，代价远大于收益——Win 参与的组合键本就罕见。
fn neutralise_modifiers() -> Vec<u16> {
    let deadline = Instant::now() + MOD_RELEASE_WAIT;
    let all: Vec<u16> = BLOCKING_MODIFIERS
        .iter()
        .chain(WAIT_ONLY_MODIFIERS.iter())
        .copied()
        .collect();
    while Instant::now() < deadline {
        if !all.iter().copied().any(key_down) {
            break;
        }
        std::thread::sleep(Duration::from_millis(8));
    }

    let mut forced = Vec::new();
    for vk in BLOCKING_MODIFIERS {
        if key_down(vk) {
            send_key(vk, true);
            forced.push(vk);
        }
    }
    if !forced.is_empty() {
        // 给目标应用一点时间处理抬起事件，避免紧接着的 Ctrl+C 被合并成 Alt+Ctrl+C
        std::thread::sleep(Duration::from_millis(10));
    }
    forced
}

/// 把 [`neutralise_modifiers`] 强制松开的键按回去，让用户自己松手时状态一致。
///
/// **只还原仍然物理按住的键**：用户可能在等待期间就松手了，此时再合成一个 keydown
/// 会把 Alt 留在「按下」状态——他下一次敲任意键都会变成 Alt+某键，比不还原糟糕得多。
fn restore_modifiers(keys: &[u16]) {
    for vk in keys {
        if key_down(*vk) {
            send_key(*vk, false);
        }
    }
}

/// 把备份内容原样写回。仅支持文本 / 图片 / 文件三种格式——其余格式（HTML/RTF 等）
/// 在备份阶段就读不出来，因此无法还原，返回 false 而不是假装成功。
fn restore_clipboard(backup: Option<ClipData>) -> bool {
    match backup {
        Some(ClipData::Text(t)) => write_text(&t),
        Some(ClipData::Image { dib, .. }) => write_dib(&dib),
        Some(ClipData::Files(files)) => write_files(&files),
        None => false,
    }
}

/// 模拟 Ctrl+V（译文回填替换选区用）。
///
/// 与 [`send_ctrl_c`] 相同的修饰键处理：若用户仍按着 Ctrl，只补发 V 键，
/// 避免把用户的修饰键一并释放。
pub fn send_ctrl_v() {
    let ctrl_held = (unsafe { GetAsyncKeyState(VK_CONTROL as i32) } as u16 & 0x8000) != 0;

    let mut inputs: Vec<INPUT> = Vec::with_capacity(4);
    let mut push = |vk: u16, up: bool| {
        let mut input: INPUT = unsafe { std::mem::zeroed() };
        input.r#type = INPUT_KEYBOARD;
        input.Anonymous.ki = KEYBDINPUT {
            wVk: vk,
            wScan: 0,
            dwFlags: if up { KEYEVENTF_KEYUP } else { 0 },
            time: 0,
            dwExtraInfo: 0,
        };
        inputs.push(input);
    };

    // 取词悬浮窗是非激活的，前台窗口仍是原应用：Ctrl+V 会落在原选区上
    let own_ctrl = !ctrl_held;
    if own_ctrl {
        push(VK_CONTROL, false);
    }
    push(VK_V, false);
    push(VK_V, true);
    if own_ctrl {
        push(VK_CONTROL, true);
    }

    unsafe {
        SendInput(
            inputs.len() as u32,
            inputs.as_ptr(),
            std::mem::size_of::<INPUT>() as i32,
        );
    }
}

/// 取前台窗口句柄与所属进程名。
fn foreground_window_process() -> (i64, Option<String>) {
    unsafe {
        let hwnd = GetForegroundWindow();
        if hwnd == 0 {
            return (0, None);
        }
        let mut pid: u32 = 0;
        GetWindowThreadProcessId(hwnd, &mut pid);
        let hwnd_i64 = hwnd as i64;
        if pid == 0 {
            return (hwnd_i64, None);
        }
        let handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
        if handle == 0 {
            // 目标进程权限更高时连句柄都拿不到——这本身就是一个有效信号，
            // 但不必在这里下结论，让后续「取词超时」去提示
            return (hwnd_i64, None);
        }
        let mut buf = [0u16; 512];
        let mut size = buf.len() as u32;
        let ok = QueryFullProcessImageNameW(handle, 0, buf.as_mut_ptr(), &mut size);
        CloseHandle(handle);
        if ok == 0 {
            return (hwnd_i64, None);
        }
        let path = String::from_utf16_lossy(&buf[..size as usize]);
        let name = path
            .rsplit(['\\', '/'])
            .next()
            .unwrap_or(path.as_str())
            .to_string();
        (hwnd_i64, if name.is_empty() { None } else { Some(name) })
    }
}

/// 模拟「Ctrl + 某键」。
///
/// 关键细节：若用户此刻**正按着 Ctrl**（例如取词快捷键本身带 Ctrl），
/// 我们发出的 Ctrl 抬起会把用户的修饰键一并释放，造成「按一次快捷键后
/// Ctrl 行为异常」。因此先探测 Ctrl 的物理状态，只补发缺失的那一段。
fn send_ctrl_chord(vk: u16) {
    // 高位为 1 表示当前处于按下状态
    let ctrl_held = (unsafe { GetAsyncKeyState(VK_CONTROL as i32) } as u16 & 0x8000) != 0;

    let mut inputs: Vec<INPUT> = Vec::with_capacity(4);
    let mut push = |vk: u16, up: bool| {
        let mut input: INPUT = unsafe { std::mem::zeroed() };
        input.r#type = INPUT_KEYBOARD;
        input.Anonymous.ki = KEYBDINPUT {
            wVk: vk,
            wScan: 0,
            dwFlags: if up { KEYEVENTF_KEYUP } else { 0 },
            time: 0,
            dwExtraInfo: 0,
        };
        inputs.push(input);
    };

    let own_ctrl = !ctrl_held;
    if own_ctrl {
        push(VK_CONTROL, false);
    }
    push(vk, false);
    push(vk, true);
    if own_ctrl {
        push(VK_CONTROL, true);
    }

    unsafe {
        SendInput(
            inputs.len() as u32,
            inputs.as_ptr(),
            std::mem::size_of::<INPUT>() as i32,
        );
    }
}

/// 模拟 Ctrl+C。
fn send_ctrl_c() {
    send_ctrl_chord(VK_C);
}

/// 模拟 Ctrl+Insert：部分应用对合成的 Ctrl+C 不响应，但认这条经典复制和弦。
fn send_ctrl_insert() {
    send_ctrl_chord(VK_INSERT);
}