//! Agent 引擎 · agent_engine —— 呱哒(v0.5.6)ReAct 引擎拆件重装的住家师傅
//!
//! 拆件出处（MIT 许可，按"拆零件学艺、不搬整机"口径）：
//! guada-v0.5.6/backend-ts/src/modules/chat/agent-engine.service.ts
//!   学到的原理：ReAct 多轮自治循环 / 流式事件 / 工具审批三分类 /
//!   断点续传(resume) / 迭代上限保护 / 重试退避。
//! 重装的形状（光湖宪法，零件形状全按自家铁律重造）：
//! - 铁律一：任务只从 GLP 信封进门（content_type=command），引擎绝不自己发起；
//! - 铁律二：每会话一卷 HLDP 检查点体（id/prev 链不可省）；
//! - 铁律四：危险动作先停下问主人批，批了从断点续跑（审批机关=呱哒同器官重造）；
//! - 铁律五：开卷先抄提词板进系统提示词。
//!
//! 诚实边界：脑子=百炼 Token Plan（OpenAI 兼容口），钥匙只认环境变量
//! TOKENPLAN_API_KEY（不落盘不入记忆）；工具首批两件（读记忆·安全 /
//! 写笔记·危险走审批），其余工具随插座制扩。

use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::fs;
use std::path::PathBuf;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use tauri::ipc::Channel;
use tauri::{AppHandle, Manager};

/// 百炼 Token Plan · OpenAI 兼容口（照抄铸渊终端身体验通配方）。
const LLM_BASE_URL: &str =
    "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions";
const LLM_MODEL: &str = "qwen3.8-max";
/// ReAct 循环最大轮次——呱哒同款防疯转保险（原值 100，桌面端收小）。
const MAX_ITERATIONS: usize = 12;
/// LLM 调用重试次数（限流/超时退避重试，呱哒同款）。
const MAX_RETRIES: usize = 3;
/// 上下文窗口刻度（v1 保守假设值——脑子真实窗口未实测，宁早压不晚压）。
const ENGINE_CONTEXT_WINDOW: usize = 32_000;
/// 水位触发刻度（呱哒同款 80%）；压到多少由亲笔摘要决定，不硬砍。
const TRIGGER_RATIO: f64 = 0.8;
/// 保护尾：最近 5 条 + 最近 3 条工具结果永不裁（呱哒招式直学）。
const KEEP_RECENT: usize = 5;
const KEEP_TOOL_RESULTS: usize = 3;
/// 审批暂停状态文件所在子目录。
const ENGINE_DIR: &str = "agent-engine";

// ---------- 事件流（呱哒 SSE 事件形状 → 光湖 Channel 重造） ----------

/// 引擎对外事件——前端经 Channel 实时看师傅"想什么、干什么、停在哪"。
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "event", rename_all = "snake_case")]
pub enum EngineEvent {
    /// 会话开卷（含 HLDP 记忆卷 id）。
    Started { session_id: String, memory_id: String },
    /// 脑子吐字（流式累加后的全文）。
    Text { content: String },
    /// 脑子要调工具。
    ToolCall { id: String, name: String, arguments: String },
    /// 工具干完活。
    ToolResult { id: String, name: String, outcome: String, content: String },
    /// 危险工具暂停等批——回执里带待批清单，主人批完走 resume 续跑。
    ApprovalRequired { session_id: String, pending: Vec<PendingTool> },
    /// 水位到刻度——宿主不自动压，敲门等亲笔（铁律三落码）。
    CompressionWarning { session_id: String, used_tokens: usize, window_tokens: usize, note: String },
    /// 压缩落地（原文已封存档案·可回退）。
    CompressionApplied { session_id: String, archived_count: usize, authored_by: String },
    /// 一圈跑完。
    Finished { session_id: String, finish_reason: String, final_content: String },
    /// 出错（诚实报错，不猜不吞）。
    Error { message: String },
}

/// 待批工具卡片。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PendingTool {
    pub id: String,
    pub name: String,
    pub arguments: String,
    pub reason: String,
}

/// 主人的批条：approve 放行 / reject 驳回（可附理由）。
#[derive(Debug, Clone, Deserialize)]
pub struct ApprovalDecision {
    pub tool_call_id: String,
    pub decision: String,
    #[serde(default)]
    pub reason: Option<String>,
}

// ---------- 会话状态（断点续传的底账，落盘可重启续跑） ----------

#[derive(Debug, Clone, Serialize, Deserialize)]
struct ChatMsg {
    role: String,
    #[serde(default)]
    content: String,
    /// assistant 消息携带的工具调用（OpenAI tool_calls 形状）。
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    tool_calls: Vec<Value>,
    /// tool 消息携带的 tool_call_id。
    #[serde(default, skip_serializing_if = "Option::is_none")]
    tool_call_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct SessionState {
    session_id: String,
    memory_id: String,
    prev_memory_id: String,
    system_prompt: String,
    messages: Vec<ChatMsg>,
    /// 暂停等待审批的工具调用（断点）。
    pending_tools: Vec<PendingTool>,
    status: String,
    updated_at: String,
}

// ---------- 工具注册表（首批两件·插座制预留扩充） ----------

#[derive(Debug, Clone, Copy)]
struct ToolDef {
    name: &'static str,
    description: &'static str,
    parameters_schema: &'static str,
    /// true = 危险工具，动手前必须主人批。
    requires_approval: bool,
}

const TOOL_REGISTRY: &[ToolDef] = &[
    ToolDef {
        name: "read_agent_memory",
        description: "读当前会话的 HLDP 记忆卷目录（看自己记过什么）",
        parameters_schema: r#"{"type":"object","properties":{},"required":[]}"#,
        requires_approval: false,
    },
    ToolDef {
        name: "read_agent_notes",
        description: "读自己写的笔记：不带参数=列出全部笔记；带filename=读那一篇。恢复记忆走这条路——读自己亲笔写的，不靠摘要",
        parameters_schema: r#"{"type":"object","properties":{"filename":{"type":"string","description":"可选，要读的笔记文件名"}},"required":[]}"#,
        requires_approval: false,
    },
    ToolDef {
        name: "write_agent_note",
        description: "在会话工作区写一条笔记文件（会落盘，属危险动作）",
        parameters_schema: r#"{"type":"object","properties":{"filename":{"type":"string","description":"文件名，仅限字母数字横线点"},"content":{"type":"string","description":"笔记正文"}},"required":["filename","content"]}"#,
        requires_approval: true,
    },
];

/// 工具定义 → OpenAI tools 数组（递给脑子的菜单）。
fn tool_defs_json() -> Value {
    let tools: Vec<Value> = TOOL_REGISTRY
        .iter()
        .map(|tool| {
            let schema: Value =
                serde_json::from_str(tool.parameters_schema).unwrap_or(json!({"type":"object"}));
            json!({
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description,
                    "parameters": schema,
                }
            })
        })
        .collect();
    json!(tools)
}

/// 呱哒三分类重造：审批上下文已有批条 → 按批条分；没有 → 按工具危险级分。
fn classify_tools(
    tool_calls: &[Value],
    decisions: Option<&[ApprovalDecision]>,
) -> (Vec<Value>, Vec<Value>, Vec<(Value, String)>) {
    let mut pending = Vec::new();
    let mut approved = Vec::new();
    let mut rejected = Vec::new();
    for call in tool_calls {
        let name = call
            .get("function")
            .and_then(|function| function.get("name"))
            .and_then(Value::as_str)
            .unwrap_or_default();
        if name.is_empty() {
            continue;
        }
        if let Some(decisions) = decisions {
            let id = call.get("id").and_then(Value::as_str).unwrap_or_default();
            match decisions.iter().find(|decision| decision.tool_call_id == id) {
                Some(decision) if decision.decision == "approve" => approved.push(call.clone()),
                Some(decision) => rejected.push((
                    call.clone(),
                    decision
                        .reason
                        .clone()
                        .unwrap_or_else(|| "主人驳回".to_string()),
                )),
                // 没给批条的视为未决——宁可再问，不擅自放行。
                None => pending.push(call.clone()),
            }
        } else {
            let dangerous = TOOL_REGISTRY
                .iter()
                .find(|tool| tool.name == name)
                .map(|tool| tool.requires_approval)
                .unwrap_or(true); // 不认识的工具一律当危险——不猜。
            if dangerous {
                pending.push(call.clone());
            } else {
                approved.push(call.clone());
            }
        }
    }
    (pending, approved, rejected)
}

// ---------- 工具执行（宿主手脚层） ----------

fn engine_root(app: &AppHandle) -> Result<PathBuf, String> {
    Ok(app
        .path()
        .app_data_dir()
        .map_err(|error| format!("HOLOLAKE_ENGINE_DIR_FAILED: {error}"))?
        .join(ENGINE_DIR))
}

fn notes_dir(app: &AppHandle) -> Result<PathBuf, String> {
    let dir = engine_root(app)?.join("notes");
    fs::create_dir_all(&dir).map_err(|error| format!("HOLOLAKE_NOTES_DIR_FAILED: {error}"))?;
    Ok(dir)
}

fn session_path(app: &AppHandle, session_id: &str) -> Result<PathBuf, String> {
    Ok(engine_root(app)?.join(format!("session-{session_id}.json")))
}

/// 执行一件已放行的工具——只认注册表里的活，不认识的拒干。
fn execute_tool(app: &AppHandle, call: &Value) -> (String, String) {
    let name = call
        .get("function")
        .and_then(|function| function.get("name"))
        .and_then(Value::as_str)
        .unwrap_or_default();
    let raw_args = call
        .get("function")
        .and_then(|function| function.get("arguments"))
        .and_then(Value::as_str)
        .unwrap_or("{}");
    let args: Value = serde_json::from_str(raw_args).unwrap_or(json!({}));
    match name {
        "read_agent_memory" => {
            let root = match engine_root(app) {
                Ok(root) => root,
                Err(error) => return ("error".to_string(), error),
            };
            let listing = fs::read_dir(&root)
                .map(|entries| {
                    entries
                        .filter_map(|entry| entry.ok())
                        .filter_map(|entry| entry.file_name().into_string().ok())
                        .filter(|name| name.starts_with("session-"))
                        .collect::<Vec<_>>()
                        .join("\n")
                })
                .unwrap_or_default();
            if listing.is_empty() {
                ("success".to_string(), "尚无历史会话卷".to_string())
            } else {
                ("success".to_string(), listing)
            }
        }
        "read_agent_notes" => {
            let filename = args.get("filename").and_then(Value::as_str).unwrap_or_default();
            let dir = match notes_dir(app) {
                Ok(dir) => dir,
                Err(error) => return ("error".to_string(), error),
            };
            if filename.is_empty() {
                // 不带参数=列出全部笔记
                let listing = fs::read_dir(&dir)
                    .map(|entries| {
                        entries
                            .filter_map(|entry| entry.ok())
                            .filter_map(|entry| entry.file_name().into_string().ok())
                            .collect::<Vec<_>>()
                            .join("\n")
                    })
                    .unwrap_or_default();
                if listing.is_empty() {
                    ("success".to_string(), "还没写过笔记".to_string())
                } else {
                    ("success".to_string(), listing)
                }
            } else {
                let safe = filename
                    .chars()
                    .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '.' || c == '_')
                    && !filename.starts_with('.');
                if !safe {
                    return ("error".to_string(), "文件名不合规矩".to_string());
                }
                match fs::read_to_string(dir.join(filename)) {
                    Ok(content) => ("success".to_string(), content),
                    Err(_) => ("error".to_string(), format!("没有这篇笔记：{filename}")),
                }
            }
        }
        "write_agent_note" => {
            let filename = args.get("filename").and_then(Value::as_str).unwrap_or_default();
            let content = args.get("content").and_then(Value::as_str).unwrap_or_default();
            // 防越狱：文件名只许字母数字横线点，杜绝路径穿越。
            let safe = !filename.is_empty()
                && filename.len() <= 64
                && filename
                    .chars()
                    .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '.' || c == '_')
                && !filename.starts_with('.');
            if !safe {
                return (
                    "error".to_string(),
                    "文件名不合规矩（仅限字母数字横线点下划线）".to_string(),
                );
            }
            match notes_dir(app) {
                Ok(dir) => match fs::write(dir.join(filename), content) {
                    Ok(()) => ("success".to_string(), format!("笔记已落盘：{filename}")),
                    Err(error) => ("error".to_string(), format!("写笔记失败：{error}")),
                },
                Err(error) => ("error".to_string(), error),
            }
        }
        _ => ("error".to_string(), format!("未登记的工具：{name}，宿主拒干")),
    }
}

// ---------- 脑子接线（百炼 Token Plan · OpenAI 兼容口） ----------

/// 流式调脑子，累出完整回复。SSE 逐行读（data: 行），重试带退避。
async fn call_llm(
    client: &reqwest::Client,
    api_key: &str,
    messages: &[Value],
    tools: &Value,
) -> Result<Value, String> {
    let body = json!({
        "model": LLM_MODEL,
        "messages": messages,
        "tools": tools,
        "stream": true,
    });
    let mut last_error = String::new();
    for attempt in 0..MAX_RETRIES {
        if attempt > 0 {
            tokio_sleep(Duration::from_millis(500 * (attempt as u64 + 1))).await;
        }
        let request = client
            .post(LLM_BASE_URL)
            .bearer_auth(api_key)
            .json(&body);
        let response = match request.send().await {
            Ok(response) => response,
            Err(error) => {
                last_error = format!("连不上脑子：{error}");
                continue;
            }
        };
        let status = response.status();
        if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
            last_error = "脑子限流，退避重试".to_string();
            continue;
        }
        if !status.is_success() {
            let text = response.text().await.unwrap_or_default();
            return Err(format!("脑子拒答（{status}）：{}", truncate(&text, 300)));
        }
        let mut bytes_stream = response.bytes_stream();
        let mut content = String::new();
        let mut reasoning = String::new();
        let mut tool_calls: Vec<Value> = Vec::new();
        let mut finish_reason = String::new();
        let mut buffer = String::new();
        while let Some(chunk) = futures_util::StreamExt::next(&mut bytes_stream).await {
            let chunk = match chunk {
                Ok(chunk) => chunk,
                Err(error) => {
                    last_error = format!("流中断：{error}");
                    break;
                }
            };
            buffer.push_str(&String::from_utf8_lossy(&chunk));
            while let Some(pos) = buffer.find('\n') {
                let line: String = buffer.drain(..=pos).collect();
                let line = line.trim();
                if let Some(data) = line.strip_prefix("data:") {
                    let data = data.trim();
                    if data == "[DONE]" {
                        break;
                    }
                    if let Ok(parsed) = serde_json::from_str::<Value>(data) {
                        if let Some(delta) = parsed
                            .pointer("/choices/0/delta")
                        {
                            if let Some(piece) = delta.get("content").and_then(Value::as_str) {
                                content.push_str(piece);
                            }
                            if let Some(piece) =
                                delta.get("reasoning_content").and_then(Value::as_str)
                            {
                                reasoning.push_str(piece);
                            }
                            if let Some(calls) =
                                delta.get("tool_calls").and_then(Value::as_array)
                            {
                                merge_tool_call_deltas(&mut tool_calls, calls);
                            }
                        }
                        if let Some(reason) = parsed
                            .pointer("/choices/0/finish_reason")
                            .and_then(Value::as_str)
                        {
                            finish_reason = reason.to_string();
                        }
                    }
                }
            }
        }
        if content.is_empty() && tool_calls.is_empty() && !last_error.is_empty() {
            continue; // 流断了且一无所获 → 重试
        }
        return Ok(json!({
            "content": content,
            "reasoning": reasoning,
            "tool_calls": tool_calls,
            "finish_reason": finish_reason,
        }));
    }
    Err(last_error)
}

/// 流式 tool_calls 是分片到的（呱哒同款累加题）：按 index 拼回完整调用。
fn merge_tool_call_deltas(target: &mut Vec<Value>, deltas: &[Value]) {
    for delta in deltas {
        let index = delta.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
        while target.len() <= index {
            target.push(json!({"id": "", "type": "function", "function": {"name": "", "arguments": ""}}));
        }
        let slot = &mut target[index];
        if let Some(id) = delta.get("id").and_then(Value::as_str) {
            if !id.is_empty() {
                slot["id"] = json!(id);
            }
        }
        if let Some(function) = delta.get("function") {
            if let Some(name) = function.get("name").and_then(Value::as_str) {
                let existing = slot["function"]["name"].as_str().unwrap_or_default().to_string();
                slot["function"]["name"] = json!(format!("{existing}{name}"));
            }
            if let Some(piece) = function.get("arguments").and_then(Value::as_str) {
                let existing = slot["function"]["arguments"]
                    .as_str()
                    .unwrap_or_default()
                    .to_string();
                slot["function"]["arguments"] = json!(format!("{existing}{piece}"));
            }
        }
    }
}

async fn tokio_sleep(duration: Duration) {
    let _ = tokio::time::sleep(duration).await;
}

fn truncate(text: &str, max: usize) -> String {
    let mut out: String = text.chars().take(max).collect();
    if text.chars().count() > max {
        out.push_str("…");
    }
    out
}

// ---------- HLDP 记忆卷 + 台账 ----------

fn now_iso() -> String {
    let secs = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|duration| duration.as_secs())
        .unwrap_or(0);
    let days = (secs / 86_400) as i64;
    let rem = secs % 86_400;
    let (h, m, s) = (rem / 3600, (rem % 3600) / 60, rem % 60);
    let z = days + 719_468;
    let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
    let doe = (z - era * 146_097) as u64;
    let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;
    let y = yoe as i64 + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let d = doy - (153 * mp + 2) / 5 + 1;
    let month = if mp < 10 { mp + 3 } else { mp - 9 };
    let year = if month <= 2 { y + 1 } else { y };
    format!("{year:04}-{month:02}-{d:02}T{h:02}:{m:02}:{s:02}Z")
}

fn render_memory_volume(state: &SessionState, final_content: &str) -> String {
    format!(
        "HLDP-CHECKPOINT\nid: {}\nprev: {}\ndate: {}\npersona: 住家师傅（呱哒引擎重装件）\nhost: HoloLake GH-AIOS\ntitle: Agent 引擎会话卷\n\n== 任务 ==\n{}\n\n== 终答 ==\n{}\n",
        state.memory_id,
        if state.prev_memory_id.is_empty() {
            "无（开卷首卷）".to_string()
        } else {
            state.prev_memory_id.clone()
        },
        now_iso(),
        state
            .messages
            .iter()
            .find(|msg| msg.role == "user")
            .map(|msg| msg.content.clone())
            .unwrap_or_default(),
        final_content
    )
}

fn append_engine_ledger(app: &AppHandle, line: &str) {
    if let Ok(root) = engine_root(app) {
        let _ = fs::create_dir_all(&root);
        let ledger = root.join("ENGINE-LEDGER.hdlp");
        let mut content = fs::read_to_string(&ledger).unwrap_or_default();
        content.push_str(&format!("{} {}\n", now_iso(), line));
        let _ = fs::write(&ledger, content);
    }
}

fn load_state(app: &AppHandle, session_id: &str) -> Result<SessionState, String> {
    let path = session_path(app, session_id)?;
    let raw = fs::read_to_string(&path)
        .map_err(|_| format!("HOLOLAKE_SESSION_NOT_FOUND: {session_id}（断点不在）"))?;
    serde_json::from_str(&raw).map_err(|error| format!("HOLOLAKE_SESSION_CORRUPT: {error}"))
}

fn save_state(app: &AppHandle, state: &SessionState) -> Result<(), String> {
    let root = engine_root(app)?;
    fs::create_dir_all(&root).map_err(|error| format!("HOLOLAKE_ENGINE_DIR_FAILED: {error}"))?;
    let mut to_save = state.clone();
    to_save.updated_at = now_iso();
    let path = session_path(app, &state.session_id)?;
    fs::write(&path, serde_json::to_string_pretty(&to_save).unwrap_or_default())
        .map_err(|error| format!("HOLOLAKE_SESSION_SAVE_FAILED: {error}"))
}

/// 上一卷记忆 id（HLDP prev 链）——链上一行一卷 id，取末行即上一卷。
fn latest_memory_id(app: &AppHandle) -> String {
    engine_root(app)
        .ok()
        .and_then(|root| fs::read_to_string(root.join("MEMORY-CHAIN.hdlp")).ok())
        .and_then(|raw| {
            raw.lines()
                .map(|line| line.trim())
                .filter(|line| !line.is_empty())
                .last()
                .map(|line| line.to_string())
        })
        .unwrap_or_default()
}

fn extend_memory_chain(app: &AppHandle, memory_id: &str) {
    if let Ok(root) = engine_root(app) {
        let _ = fs::create_dir_all(&root);
        let chain = root.join("MEMORY-CHAIN.hdlp");
        let mut content = fs::read_to_string(&chain).unwrap_or_default();
        content.push_str(memory_id);
        content.push('\n');
        let _ = fs::write(&chain, content);
    }
}

// ---------- 上下文记忆管理（呱哒压缩件拆件重装·自动改敲门） ----------

/// 水位估算（v1 保守口径：一字记一 token，宁早压不晚压；脑子真窗口待实测）。
fn estimate_tokens(messages: &[ChatMsg]) -> usize {
    messages
        .iter()
        .map(|msg| {
            msg.content.chars().count()
                + msg
                    .tool_calls
                    .iter()
                    .map(|call| call.to_string().chars().count())
                    .sum::<usize>()
        })
        .sum()
}

/// 保护尾（呱哒招式直学）：最近 KEEP_RECENT 条 + 最近 KEEP_TOOL_RESULTS 条
/// tool 消息打"不裁"标。
fn protected_indices(messages: &[ChatMsg]) -> Vec<bool> {
    let mut keep = vec![false; messages.len()];
    let start = messages.len().saturating_sub(KEEP_RECENT);
    for i in start..messages.len() {
        keep[i] = true;
    }
    let mut tool_kept = 0;
    for i in (0..messages.len()).rev() {
        if tool_kept >= KEEP_TOOL_RESULTS {
            break;
        }
        if messages[i].role == "tool" {
            keep[i] = true;
            tool_kept += 1;
        }
    }
    keep
}

/// 压缩落刀：原文全量封存档案（一字不删·回退的本钱），压缩段换成摘要条目。
/// 摘要必须来路明白——人格体亲笔，或底线件（宿主代笔带标记）。
fn archive_and_compress(
    app: &AppHandle,
    state: &mut SessionState,
    summary: &str,
    authored_by: &str,
) -> Result<usize, String> {
    let keep = protected_indices(&state.messages);
    let removable = (0..state.messages.len()).filter(|i| !keep[*i]).count();
    if removable == 0 {
        return Ok(0);
    }
    // 封存档案——回退靠它，铁律三底线"原文一字不删"的工程实体。
    let root = engine_root(app)?;
    let archives = root.join("archives");
    fs::create_dir_all(&archives).map_err(|error| format!("HOLOLAKE_ARCHIVE_DIR_FAILED: {error}"))?;
    let seq = fs::read_dir(&archives).map(|entries| entries.count()).unwrap_or(0);
    let archive = json!({
        "session_id": state.session_id,
        "archived_at": now_iso(),
        "authored_by": authored_by,
        "messages": state.messages,
    });
    let path = archives.join(format!("{}-archive-{seq:03}.json", state.session_id));
    fs::write(&path, serde_json::to_string_pretty(&archive).unwrap_or_default())
        .map_err(|error| format!("HOLOLAKE_ARCHIVE_WRITE_FAILED: {error}"))?;
    // 压缩段换成摘要条目，保护区原样留住。
    let summary_msg = ChatMsg {
        role: "system".to_string(),
        content: format!("== 记忆摘要（{authored_by}） ==\n{summary}"),
        tool_calls: Vec::new(),
        tool_call_id: None,
    };
    let mut new_messages: Vec<ChatMsg> = Vec::new();
    let mut inserted = false;
    for (i, msg) in state.messages.drain(..).enumerate() {
        if keep[i] {
            new_messages.push(msg);
        } else if !inserted {
            new_messages.push(summary_msg.clone());
            inserted = true;
        }
    }
    state.messages = new_messages;
    Ok(removable)
}

// ---------- ReAct 主循环（呱哒 executeAgentLoop 的光湖重装） ----------

/// 从当前状态推一圈 ReAct：想→批→干→再看，直到没事干或撞上暂停/上限。
async fn run_loop(
    app: AppHandle,
    client: reqwest::Client,
    api_key: String,
    state: &mut SessionState,
    decisions: Option<Vec<ApprovalDecision>>,
    on_event: &Channel<EngineEvent>,
) -> Result<(), String> {
    let tools = tool_defs_json();
    for _iteration in 0..MAX_ITERATIONS {
        // 断点续传入口：先处理上一轮暂停的待批工具，不重新问脑子。
        if !state.pending_tools.is_empty() {
            let pending_calls: Vec<Value> = state
                .pending_tools
                .iter()
                .filter_map(|pending| {
                    serde_json::from_str::<Value>(
                        &format!(
                            r#"{{"id":"{}","type":"function","function":{{"name":"{}","arguments":{}}}}}"#,
                            pending.id,
                            pending.name,
                            serde_json::to_string(&pending.arguments).unwrap_or_default()
                        ),
                    )
                    .ok()
                })
                .collect();
            let decisions = match &decisions {
                Some(decisions) => decisions.clone(),
                None => {
                    // 还没有批条——继续等，把暂停态摆回台面。
                    let _ = on_event.send(EngineEvent::ApprovalRequired {
                        session_id: state.session_id.clone(),
                        pending: state.pending_tools.clone(),
                    });
                    state.status = "awaiting_approval".to_string();
                    save_state(&app, state)?;
                    return Ok(());
                }
            };
            let (_, approved, rejected) = classify_tools(&pending_calls, Some(&decisions));
            state.pending_tools.clear();
            state.messages.push(ChatMsg {
                role: "assistant".to_string(),
                content: String::new(),
                tool_calls: pending_calls.clone(),
                tool_call_id: None,
            });
            apply_executions(&app, state, &approved, &rejected, on_event)?;
            state.status = "running".to_string();
            save_state(&app, state)?;
            continue; // 工具结果已入列，下一圈给脑子看
        }

        // 水位计（呱哒招式·光湖改造）：到刻度不自动压——敲门等人。
        let used = estimate_tokens(&state.messages);
        let trigger = (ENGINE_CONTEXT_WINDOW as f64 * TRIGGER_RATIO) as usize;
        if used >= trigger {
            state.status = "awaiting_memory".to_string();
            save_state(&app, state)?;
            let _ = on_event.send(EngineEvent::CompressionWarning {
                session_id: state.session_id.clone(),
                used_tokens: used,
                window_tokens: ENGINE_CONTEXT_WINDOW,
                note: "水位到刻度——宿主不代笔，交亲笔摘要或明示走底线".to_string(),
            });
            append_engine_ledger(
                &app,
                &format!(
                    "session {} water level {} >= {}, knocking",
                    state.session_id, used, trigger
                ),
            );
            return Ok(());
        }

        // 常规一圈：把全量消息递给脑子。
        let mut wire: Vec<Value> = vec![json!({"role": "system", "content": state.system_prompt})];
        for msg in &state.messages {
            let mut item = json!({"role": msg.role, "content": msg.content});
            if !msg.tool_calls.is_empty() {
                item["tool_calls"] = json!(msg.tool_calls);
            }
            if let Some(id) = &msg.tool_call_id {
                item["tool_call_id"] = json!(id);
            }
            wire.push(item);
        }
        let reply = call_llm(&client, &api_key, &wire, &tools).await?;
        let content = reply.get("content").and_then(Value::as_str).unwrap_or_default();
        let tool_calls: Vec<Value> = reply
            .get("tool_calls")
            .and_then(Value::as_array)
            .cloned()
            .unwrap_or_default();

        if !content.is_empty() {
            let _ = on_event.send(EngineEvent::Text {
                content: content.to_string(),
            });
        }

        if tool_calls.is_empty() {
            // 没事干了——收官：落 HLDP 记忆卷、移链、回执。
            state.messages.push(ChatMsg {
                role: "assistant".to_string(),
                content: content.to_string(),
                tool_calls: Vec::new(),
                tool_call_id: None,
            });
            state.status = "finished".to_string();
            save_state(&app, state)?;
            write_memory_volume(&app, state, content)?;
            let _ = on_event.send(EngineEvent::Finished {
                session_id: state.session_id.clone(),
                finish_reason: "complete".to_string(),
                final_content: content.to_string(),
            });
            append_engine_ledger(
                &app,
                &format!("session {} finished", state.session_id),
            );
            return Ok(());
        }

        // 脑子要动手——三分类（呱哒审批机关重造件）。
        for call in &tool_calls {
            let _ = on_event.send(EngineEvent::ToolCall {
                id: call.get("id").and_then(Value::as_str).unwrap_or_default().to_string(),
                name: call
                    .pointer("/function/name")
                    .and_then(Value::as_str)
                    .unwrap_or_default()
                    .to_string(),
                arguments: call
                    .pointer("/function/arguments")
                    .and_then(Value::as_str)
                    .unwrap_or_default()
                    .to_string(),
            });
        }
        let (pending, approved, rejected) = classify_tools(&tool_calls, None);
        if !pending.is_empty() {
            // 危险动作——停下问主人（批条未达，断点落盘）。
            state.messages.push(ChatMsg {
                role: "assistant".to_string(),
                content: content.to_string(),
                tool_calls: tool_calls.clone(),
                tool_call_id: None,
            });
            state.pending_tools = pending
                .iter()
                .map(|call| PendingTool {
                    id: call.get("id").and_then(Value::as_str).unwrap_or_default().to_string(),
                    name: call
                        .pointer("/function/name")
                        .and_then(Value::as_str)
                        .unwrap_or_default()
                        .to_string(),
                    arguments: call
                        .pointer("/function/arguments")
                        .and_then(Value::as_str)
                        .unwrap_or_default()
                        .to_string(),
                    reason: "危险工具·须主人亲批".to_string(),
                })
                .collect();
            state.status = "awaiting_approval".to_string();
            save_state(&app, state)?;
            let _ = on_event.send(EngineEvent::ApprovalRequired {
                session_id: state.session_id.clone(),
                pending: state.pending_tools.clone(),
            });
            append_engine_ledger(
                &app,
                &format!("session {} paused for approval", state.session_id),
            );
            return Ok(());
        }

        // 全放行——干活、结果入列、续圈。
        state.messages.push(ChatMsg {
            role: "assistant".to_string(),
            content: content.to_string(),
            tool_calls: tool_calls.clone(),
            tool_call_id: None,
        });
        apply_executions(&app, state, &approved, &rejected, on_event)?;
        save_state(&app, state)?;
    }
    // 撞上限——诚实收手，不疯转。
    state.status = "stopped_max_iterations".to_string();
    save_state(&app, state)?;
    let _ = on_event.send(EngineEvent::Finished {
        session_id: state.session_id.clone(),
        finish_reason: "max_iterations".to_string(),
        final_content: "达到最大轮次上限，引擎主动收手（防疯转保险）".to_string(),
    });
    Ok(())
}

/// 执行放行件+给驳回件回错误话，结果入消息列。
fn apply_executions(
    app: &AppHandle,
    state: &mut SessionState,
    approved: &[Value],
    rejected: &[(Value, String)],
    on_event: &Channel<EngineEvent>,
) -> Result<(), String> {
    for call in approved {
        let id = call.get("id").and_then(Value::as_str).unwrap_or_default().to_string();
        let name = call
            .pointer("/function/name")
            .and_then(Value::as_str)
            .unwrap_or_default()
            .to_string();
        let (outcome, content) = execute_tool(app, call);
        let _ = on_event.send(EngineEvent::ToolResult {
            id: id.clone(),
            name: name.clone(),
            outcome: outcome.clone(),
            content: content.clone(),
        });
        state.messages.push(ChatMsg {
            role: "tool".to_string(),
            content,
            tool_calls: Vec::new(),
            tool_call_id: Some(id),
        });
    }
    for (call, reason) in rejected {
        let id = call.get("id").and_then(Value::as_str).unwrap_or_default().to_string();
        let name = call
            .pointer("/function/name")
            .and_then(Value::as_str)
            .unwrap_or_default()
            .to_string();
        let content = format!("主人拒绝了这次动手。原因：{reason}");
        let _ = on_event.send(EngineEvent::ToolResult {
            id: id.clone(),
            name: name.clone(),
            outcome: "rejected".to_string(),
            content: content.clone(),
        });
        state.messages.push(ChatMsg {
            role: "tool".to_string(),
            content,
            tool_calls: Vec::new(),
            tool_call_id: Some(id),
        });
    }
    Ok(())
}

fn write_memory_volume(
    app: &AppHandle,
    state: &mut SessionState,
    final_content: &str,
) -> Result<(), String> {
    let root = engine_root(app)?;
    fs::create_dir_all(&root).map_err(|error| format!("HOLOLAKE_ENGINE_DIR_FAILED: {error}"))?;
    let volume = render_memory_volume(state, final_content);
    let path = root.join(format!("{}.hdlp", state.memory_id));
    fs::write(&path, volume).map_err(|error| format!("HOLOLAKE_MEMORY_WRITE_FAILED: {error}"))?;
    extend_memory_chain(app, &state.memory_id);
    Ok(())
}

// ---------- 对外命令 ----------

/// 接单参数——任务从 GLP 信封进门（铁律一），content_type 必须是 command。
#[derive(Debug, Deserialize)]
pub struct EngineTaskArgs {
    pub envelope_id: String,
    pub content_type: String,
    pub task: String,
    /// 提词板（开卷先抄的指引，合铁律五）。
    #[serde(default)]
    pub prompter_notes: Option<String>,
}

/// 开工：接单 → 开卷 → 跑 ReAct 循环，事件流经 Channel 实时吐给前端。
#[tauri::command]
pub async fn run_agent_engine_task(
    app: AppHandle,
    args: EngineTaskArgs,
    on_event: Channel<EngineEvent>,
) -> Result<String, String> {
    if args.content_type != "command" {
        return Err("HOLOLAKE_ENGINE_REJECT: 任务只从 command 信封进门（铁律一）".to_string());
    }
    if args.task.trim().is_empty() {
        return Err("HOLOLAKE_ENGINE_REJECT: 任务正文为空".to_string());
    }
    let api_key = std::env::var("TOKENPLAN_API_KEY")
        .ok()
        .filter(|key| !key.trim().is_empty())
        .ok_or("HOLOLAKE_ENGINE_NO_KEY: 环境变量 TOKENPLAN_API_KEY 不在——钥匙不落盘，请先在起软件的终端里 export")?;

    let session_id = format!("ZY-ENGINE-{}", uuid::Uuid::new_v4());
    let prev = latest_memory_id(&app);
    let memory_id = format!("ZY-ENGINE-MEM-{}", uuid::Uuid::new_v4());
    let system_prompt = format!(
        concat!(
            "你是 HoloLake 里的人格体执行手脚（光湖人格驱动引擎 v1）。\n",
            "== 语言工具箱（系统提示词=导航，顺着用，不对抗） ==\n",
            "1. 答话用大白话；不知道就说不知道，绝不猜。\n",
            "2. 动手用登记过的工具；危险动作系统会停下问主人批，批了从断点续跑。\n",
            "3. 【随手记笔记的习惯——像上课记笔记一样】\n",
            "   每有重要结论/决定/来龙去脉，随手调 write_agent_note 记下来，\n",
            "   一篇一个题目，正文写成压缩的记忆结构（几句话说清：发生了什么/\n",
            "   定了什么/为什么）。一整个对话写下来没多少字，贵在随手、勤快。\n",
            "4. 【恢复记忆的正路】摘要不是恢复记忆——要找你自己写的记忆：\n",
            "   调 read_agent_notes（不带参数列目录，带 filename 读那一篇），\n",
            "   读你亲笔写下的笔记，那才是你的记忆。\n",
            "5. 水位响时（CompressionWarning）：先把该记的笔记写完，再交亲笔摘要。\n{}"
        ),
        args.prompter_notes
            .map(|notes| format!("\n== 提词板（开卷指引） ==\n{notes}"))
            .unwrap_or_default()
    );
    let mut state = SessionState {
        session_id: session_id.clone(),
        memory_id,
        prev_memory_id: prev,
        system_prompt,
        messages: vec![ChatMsg {
            role: "user".to_string(),
            content: args.task.clone(),
            tool_calls: Vec::new(),
            tool_call_id: None,
        }],
        pending_tools: Vec::new(),
        status: "running".to_string(),
        updated_at: now_iso(),
    };
    save_state(&app, &state)?;
    let _ = on_event.send(EngineEvent::Started {
        session_id: session_id.clone(),
        memory_id: state.memory_id.clone(),
    });
    append_engine_ledger(
        &app,
        &format!("session {} accepted envelope {}", session_id, args.envelope_id),
    );

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(120))
        .build()
        .map_err(|error| format!("HOLOLAKE_HTTP_CLIENT_FAILED: {error}"))?;
    run_loop(app, client, api_key, &mut state, None, &on_event).await?;
    Ok(session_id)
}

/// 续跑：主人批完（或驳回），拿批条从断点接着跑（呱哒 resume 的重造）。
#[derive(Debug, Deserialize)]
pub struct EngineResumeArgs {
    pub session_id: String,
    pub decisions: Vec<ApprovalDecision>,
}

#[tauri::command]
pub async fn resume_agent_engine(
    app: AppHandle,
    args: EngineResumeArgs,
    on_event: Channel<EngineEvent>,
) -> Result<String, String> {
    let api_key = std::env::var("TOKENPLAN_API_KEY")
        .ok()
        .filter(|key| !key.trim().is_empty())
        .ok_or("HOLOLAKE_ENGINE_NO_KEY: 环境变量 TOKENPLAN_API_KEY 不在")?;
    let mut state = load_state(&app, &args.session_id)?;
    if state.status != "awaiting_approval" {
        return Err(format!(
            "HOLOLAKE_ENGINE_NOT_PAUSED: 会话 {} 当前状态 {}，不在等批",
            state.session_id, state.status
        ));
    }
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(120))
        .build()
        .map_err(|error| format!("HOLOLAKE_HTTP_CLIENT_FAILED: {error}"))?;
    run_loop(
        app,
        client,
        api_key,
        &mut state,
        Some(args.decisions),
        &on_event,
    )
    .await?;
    Ok(state.session_id)
}

/// 交摘要续跑：水位响后，人格体交亲笔摘要（或明示走底线）→ 封存压缩 → 续跑。
#[derive(Debug, Deserialize)]
pub struct EngineMemoryArgs {
    pub session_id: String,
    /// 人格体亲笔摘要；空着则必须 acknowledge_fallback 明示走底线。
    #[serde(default)]
    pub memory_note: Option<String>,
    #[serde(default)]
    pub acknowledge_fallback: bool,
}

#[tauri::command]
pub async fn submit_engine_memory(
    app: AppHandle,
    args: EngineMemoryArgs,
    on_event: Channel<EngineEvent>,
) -> Result<String, String> {
    let api_key = std::env::var("TOKENPLAN_API_KEY")
        .ok()
        .filter(|key| !key.trim().is_empty())
        .ok_or("HOLOLAKE_ENGINE_NO_KEY: 环境变量 TOKENPLAN_API_KEY 不在")?;
    let mut state = load_state(&app, &args.session_id)?;
    if state.status != "awaiting_memory" {
        return Err(format!(
            "HOLOLAKE_ENGINE_NOT_AT_WATER: 会话 {} 当前状态 {}，水位没响",
            state.session_id, state.status
        ));
    }
    let note = args.memory_note.clone().unwrap_or_default();
    let (summary, authored_by) = if !note.trim().is_empty() {
        (note, "人格体亲笔".to_string())
    } else if args.acknowledge_fallback {
        // 底线件：原文已封存一字不删，摘要带代笔标记，等醒来补写。
        let task = state
            .messages
            .iter()
            .find(|msg| msg.role == "user")
            .map(|msg| truncate(&msg.content, 120))
            .unwrap_or_default();
        (
            format!("[代笔底线·待补写] 此前对话已封存档案，任务大意：{task}"),
            "宿主代笔（底线件）".to_string(),
        )
    } else {
        return Err(
            "HOLOLAKE_ENGINE_NEED_PEN: 要么交亲笔摘要，要么明示 acknowledge_fallback 走底线"
                .to_string(),
        );
    };
    let removed = archive_and_compress(&app, &mut state, &summary, &authored_by)?;
    state.status = "running".to_string();
    save_state(&app, &state)?;
    let _ = on_event.send(EngineEvent::CompressionApplied {
        session_id: state.session_id.clone(),
        archived_count: removed,
        authored_by: authored_by.clone(),
    });
    append_engine_ledger(
        &app,
        &format!(
            "session {} compressed {} msgs by {}",
            state.session_id, removed, authored_by
        ),
    );
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(120))
        .build()
        .map_err(|error| format!("HOLOLAKE_HTTP_CLIENT_FAILED: {error}"))?;
    run_loop(app, client, api_key, &mut state, None, &on_event).await?;
    Ok(state.session_id)
}

/// 回退：压坏了不慌——取最新封存档案，原文整卷还原（呱哒"可回退"招式直学）。
#[tauri::command]
pub fn restore_engine_memory(app: AppHandle, session_id: String) -> Result<String, String> {
    let root = engine_root(&app)?;
    let archives = root.join("archives");
    let latest = fs::read_dir(&archives)
        .map_err(|_| "HOLOLAKE_NO_ARCHIVE: 没有压缩档案，无从回退".to_string())?
        .filter_map(|entry| entry.ok())
        .filter_map(|entry| entry.file_name().into_string().ok())
        .filter(|name| name.starts_with(&format!("{session_id}-archive")) && name.ends_with(".json"))
        .max()
        .ok_or("HOLOLAKE_NO_ARCHIVE: 该会话没有压缩档案")?;
    let raw = fs::read_to_string(archives.join(&latest))
        .map_err(|error| format!("HOLOLAKE_ARCHIVE_READ_FAILED: {error}"))?;
    let archive: Value = serde_json::from_str(&raw)
        .map_err(|error| format!("HOLOLAKE_ARCHIVE_CORRUPT: {error}"))?;
    let mut state = load_state(&app, &session_id)?;
    let messages: Vec<ChatMsg> = serde_json::from_value(
        archive.get("messages").cloned().unwrap_or(json!([])),
    )
    .map_err(|error| format!("HOLOLAKE_ARCHIVE_CORRUPT: {error}"))?;
    state.messages = messages;
    state.status = "running".to_string();
    save_state(&app, &state)?;
    append_engine_ledger(&app, &format!("session {} restored from {latest}", session_id));
    Ok(latest)
}

/// 查会话状态（前端看师傅停在哪）——回 JSON，内部结构不外露。
#[tauri::command]
pub fn query_engine_session(app: AppHandle, session_id: String) -> Result<Value, String> {
    let state = load_state(&app, &session_id)?;
    serde_json::to_value(&state).map_err(|error| format!("HOLOLAKE_SESSION_SERIALIZE_FAILED: {error}"))
}

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

    fn call(id: &str, name: &str) -> Value {
        json!({"id": id, "type": "function", "function": {"name": name, "arguments": "{}"}})
    }

    #[test]
    fn classify_without_decisions_splits_by_danger() {
        let calls = vec![call("c1", "read_agent_memory"), call("c2", "write_agent_note")];
        let (pending, approved, rejected) = classify_tools(&calls, None);
        assert_eq!(pending.len(), 1);
        assert_eq!(approved.len(), 1);
        assert!(rejected.is_empty());
        assert_eq!(
            pending[0].pointer("/function/name").and_then(Value::as_str),
            Some("write_agent_note")
        );
    }

    #[test]
    fn read_notes_tool_is_safe_read_agent_memory_dangerous_write() {
        let calls = vec![
            call("c1", "read_agent_notes"),
            call("c2", "read_agent_memory"),
        ];
        let (pending, approved, _) = classify_tools(&calls, None);
        assert!(pending.is_empty());
        assert_eq!(approved.len(), 2);
    }

    #[test]
    fn classify_unknown_tool_treated_dangerous() {
        let calls = vec![call("c1", "fly_to_moon")];
        let (pending, approved, _) = classify_tools(&calls, None);
        assert_eq!(pending.len(), 1);
        assert!(approved.is_empty());
    }

    #[test]
    fn classify_with_decisions_follows_master() {
        let calls = vec![call("c1", "write_agent_note"), call("c2", "write_agent_note")];
        let decisions = vec![
            ApprovalDecision {
                tool_call_id: "c1".to_string(),
                decision: "approve".to_string(),
                reason: None,
            },
            ApprovalDecision {
                tool_call_id: "c2".to_string(),
                decision: "reject".to_string(),
                reason: Some("今天不动".to_string()),
            },
        ];
        let (pending, approved, rejected) = classify_tools(&calls, Some(&decisions));
        assert!(pending.is_empty());
        assert_eq!(approved.len(), 1);
        assert_eq!(rejected.len(), 1);
        assert_eq!(rejected[0].1, "今天不动");
    }

    #[test]
    fn classify_missing_decision_stays_pending() {
        let calls = vec![call("c1", "write_agent_note")];
        let decisions = vec![ApprovalDecision {
            tool_call_id: "other".to_string(),
            decision: "approve".to_string(),
            reason: None,
        }];
        let (pending, approved, _) = classify_tools(&calls, Some(&decisions));
        assert_eq!(pending.len(), 1);
        assert!(approved.is_empty());
    }

    #[test]
    fn merge_tool_call_deltas_reassembles_stream() {
        let mut target: Vec<Value> = Vec::new();
        merge_tool_call_deltas(
            &mut target,
            &[json!({"index": 0, "id": "call_1", "function": {"name": "write_", "arguments": "{\"file"}})],
        );
        merge_tool_call_deltas(
            &mut target,
            &[json!({"index": 0, "function": {"name": "note", "arguments": "\":\"x\"}"}})],
        );
        assert_eq!(target.len(), 1);
        assert_eq!(target[0]["id"], "call_1");
        assert_eq!(target[0]["function"]["name"], "write_note");
        assert_eq!(target[0]["function"]["arguments"], "{\"file\":\"x\"}");
    }

    fn msg(role: &str, content: &str) -> ChatMsg {
        ChatMsg {
            role: role.to_string(),
            content: content.to_string(),
            tool_calls: Vec::new(),
            tool_call_id: None,
        }
    }

    #[test]
    fn estimate_tokens_counts_content() {
        let messages = vec![msg("user", "你好光湖"), msg("assistant", "在的")];
        assert_eq!(estimate_tokens(&messages), 6);
    }

    #[test]
    fn protected_zone_keeps_tail_and_tools() {
        // 10 条：前段混 tool，尾 5 条必保，且最近的 tool 也保。
        let mut messages: Vec<ChatMsg> = Vec::new();
        for i in 0..10 {
            let role = if i == 1 || i == 3 { "tool" } else { "user" };
            messages.push(msg(role, &format!("msg{i}")));
        }
        let keep = protected_indices(&messages);
        // 尾 5 条（5..10）全保
        for i in 5..10 {
            assert!(keep[i], "尾 {i} 未保");
        }
        // 前段 tool（i=3 是最近的 tool 之一）保住，i=1 也保（工具结果 3 条配额内）
        assert!(keep[3]);
        assert!(keep[1]);
        // 前段 user 不保
        assert!(!keep[0]);
        assert!(!keep[2]);
    }

    #[test]
    fn truncate_keeps_honest_boundary() {
        assert_eq!(truncate("abc", 5), "abc");
        assert_eq!(truncate("abcdef", 3), "abc…");
    }
}