"""PAM 部署 Agent 的常驻式交互 CLI 会话。"""

from __future__ import annotations

import time
import json
import shlex
import builtins
import logging
import os
from dataclasses import asdict
from pathlib import Path
from typing import Any, Callable

from .agent import PamDeployAgent
from .checkpoint_store import load_agent_state, redact_mapping
from .langgraph_runtime import LangGraphDeploymentRuntime, LangGraphRunResult
from .llm import build_llm_client
from .llm.rule_based import RuleBasedLlmClient
from .logging_utils import configure_logging, json_for_log, redact_for_log
from .mcp_factory import build_mcp_runner_from_config
from .models import AgentState, ExecutionStrategy
from .params_loader import load_params_file

InputFunc = Callable[[str], str]
OutputFunc = Callable[[str], None]
logger = logging.getLogger(__name__)

COMMAND_HELP = """可用命令：
  help                 显示帮助
  preview              查看当前参数和执行策略
  analyze <需求>       只做理解和计划，不执行
  params               脱敏展示当前会话参数
  events [数量]        查看最近 action 事件，默认 10 条
  set KEY=VALUE        修改当前会话参数
  llm config KEY=VALUE 配置真实 LLM，支持 base_url/api_key/model/action_analysis_prompt_file
  llm test [文本]       测试当前 LLM client 是否可正常调用
  llm fallback         切回本地规则 fallback
  llm action-analysis on|off  开关 action 审核详情写入 events
  mcp config <路径>    加载 MCP client JSON 配置
  run                  创建部署任务并执行
  status               查看当前运行状态
  resume               从当前 checkpoint 续跑
  rollback [IP]        显式回滚指定 IP；不传 IP 时回滚当前失败 IP
  list checkpoints     列出 checkpoint 目录下的 JSON 文件
  load params <路径>   加载并热更新参数文件
  load checkpoint <路径> 加载指定 checkpoint
  checkpoint           显示 checkpoint 路径
  exit                 退出

也可以直接输入自然语言需求，Agent 会先分析并更新会话参数；执行仍需输入 run。
执行中可按 Ctrl+C 中断，保存 checkpoint 后再用 resume 继续。
"""


class InteractiveCliSession:
    """维护一次交互式 CLI 会话的参数、状态和命令处理逻辑。"""

    def __init__(
        self,
        *,
        agent: PamDeployAgent,
        params: dict[str, Any],
        strategy: ExecutionStrategy = "hybrid_node_mcp",
        checkpoint_path: str | None = None,
        target_ips: list[str] | None = None,
        input_func: InputFunc = input,
        output_func: OutputFunc = print,
    ) -> None:
        """初始化会话上下文和输入输出函数。"""
        self.agent = agent
        self.params = dict(params)
        self.strategy = strategy
        self.checkpoint_path = checkpoint_path or _default_checkpoint_path()
        self.target_ips = list(target_ips or [])
        self.input = _build_prompt_input(input_func)
        self.output = _build_output_func(output_func)
        self.state: AgentState | None = None
        self.last_analysis: dict[str, Any] | None = None
        self.llm_config: dict[str, str] = {}
        self.mcp_config_path: str = ""
        self.graph_runtime: LangGraphDeploymentRuntime | None = None
        self.agent.progress_callback = self._on_progress
        self.log_path = configure_logging()
        logger.info(
            "chat 会话已初始化 strategy=%s checkpoint=%s target_ips=%s llm_client=%s log_path=%s params=%s",
            self.strategy,
            self.checkpoint_path,
            self.target_ips,
            type(self.agent.llm_client).__name__,
            self.log_path,
            json_for_log(self.params),
        )

    def run(self) -> None:
        """启动 REPL 循环，直到用户 exit 或输入流结束。"""
        logger.info("chat REPL 启动 checkpoint=%s", self.checkpoint_path)
        self.output("PAM 部署 Agent 交互式会话")
        self.output("输入 help 查看命令，输入 exit 退出。")
        self._load_existing_checkpoint_if_any()
        while True:
            try:
                line = self.input("pam-deploy-agent> ")
            except KeyboardInterrupt:
                logger.info("chat 输入被用户中断")
                self.output("已取消当前输入。输入 exit 退出，或继续输入命令。")
                continue
            except EOFError:
                logger.info("chat 输入流结束")
                self.output("bye")
                return
            if not self.handle_line(line):
                return

    def handle_line(self, line: str) -> bool:
        """处理用户输入的一行命令；返回 False 表示退出会话。"""
        text = line.strip()
        if not text:
            return True

        command, _, rest = text.partition(" ")
        normalized = command.lower()
        logger.info(
            "chat 收到输入 command=%s text=%s",
            normalized,
            redact_for_log(text, max_text_len=500),
        )

        if normalized in ("exit", "quit", "q"):
            logger.info("chat 会话退出")
            self.output("bye")
            return False
        if normalized in ("help", "?"):
            self.output(COMMAND_HELP.rstrip())
            return True
        if normalized == "preview":
            self.output(self.agent.preview(self.params, self.strategy))
            return True
        if normalized == "params":
            self._show_params()
            return True
        if normalized == "events":
            self._show_events(rest.strip())
            return True
        if normalized == "analyze":
            self._analyze(rest.strip())
            return True
        if normalized == "set":
            self._set_param(rest.strip())
            return True
        if normalized == "llm":
            self._configure_llm(rest.strip())
            return True
        if normalized == "mcp":
            self._configure_mcp(rest.strip())
            return True
        if normalized in ("run", "deploy", "execute"):
            self._run_deploy()
            return True
        if normalized == "resume":
            self._resume()
            return True
        if normalized == "rollback":
            self._rollback(rest.strip())
            return True
        if normalized == "status":
            self._status()
            return True
        if normalized == "approve":
            self._confirm(approved=True, note=rest.strip())
            return True
        if normalized == "reject":
            self._confirm(approved=False, note=rest.strip())
            return True
        if normalized == "checkpoint":
            self.output(f"checkpoint: {self.checkpoint_path}")
            return True
        if normalized == "list" and rest.strip().lower() == "checkpoints":
            self._list_checkpoints()
            return True
        if normalized == "load" and rest.strip().lower().startswith("params"):
            self._load_params(rest.strip()[len("params") :].strip())
            return True
        if normalized == "load" and rest.strip().lower().startswith("checkpoint"):
            self._load_checkpoint(rest.strip()[len("checkpoint") :].strip())
            return True

        if _is_small_talk(text):
            logger.info("chat 输入识别为寒暄，跳过结构化分析")
            self.output("你好。可以输入 help 查看命令，或直接描述部署需求；执行前仍需输入 run 并确认。")
            return True
        if not _looks_like_deploy_request(text):
            logger.info("chat 输入未命中部署需求粗筛，跳过结构化分析")
            self.output("我没有识别到明确的部署需求。可以输入 help 查看命令，或用 analyze <需求> 明确触发需求分析。")
            return True

        self.output("正在分析需求...")
        self._analyze(text)
        return True

    def _analyze(self, text: str) -> None:
        """分析自然语言需求，并更新会话中的参数、策略和目标 IP。"""
        if not text:
            self.output("请输入要分析的自然语言需求，例如：analyze 请用 MCP 预演部署 HET。")
            return

        try:
            logger.info("chat 开始需求分析 text_len=%s base_params=%s", len(text), json_for_log(self.params))
            result = self.agent.analyze_request(text, self.params)
        except Exception as exc:
            logger.exception("chat 需求分析失败 text=%s", redact_for_log(text, max_text_len=500))
            self.output(f"需求分析失败: {exc}")
            return
        self.last_analysis = result
        param_result = result["params"]
        intent_result = result["intent"]
        plan = result["plan"]
        self.params = dict(param_result.extracted_params)
        self.strategy = _choose_strategy(intent_result.strategy_preference, self.strategy)

        user_ips = param_result.extracted_control.get("user_specified_ips")
        if isinstance(user_ips, list):
            self.target_ips = [str(item) for item in user_ips]
        self._sync_params_to_state()

        safe_payload = redact_mapping({key: asdict(value) for key, value in result.items()})
        self.output("已生成结构化理解：")
        self.output(f"- intent: {intent_result.intent}")
        self.output(f"- strategy: {self.strategy}")
        self.output(f"- summary: {plan.summary}")
        if param_result.missing_required_params:
            self.output("- missing: " + ", ".join(param_result.missing_required_params))
        if self.target_ips:
            self.output("- target_ips: " + ", ".join(self.target_ips))
        self.output("执行请输 run；查看完整 JSON 可用一次性 analyze 命令。")
        self.output(_format_redacted_params(safe_payload["params"]["extracted_params"]))
        logger.info(
            "chat 需求分析完成 intent=%s strategy=%s target_ips=%s result=%s",
            intent_result.intent,
            self.strategy,
            self.target_ips,
            json_for_log(safe_payload),
        )

    def _set_param(self, assignment: str) -> None:
        """处理 `set KEY=VALUE` 命令，更新当前会话参数。"""
        if "=" not in assignment:
            self.output("格式：set KEY=VALUE")
            return
        key, value = assignment.split("=", 1)
        key = key.strip()
        if not key:
            self.output("参数名不能为空。")
            return
        self.params[key] = value.strip()
        self._sync_params_to_state()
        self.output(f"已设置 {key}")
        logger.info("chat 参数已设置 key=%s params=%s", key, json_for_log(self.params))

    def _show_params(self) -> None:
        """脱敏展示当前会话参数。"""
        self.output(_format_redacted_params(redact_mapping(self.params)))

    def _show_events(self, count_text: str) -> None:
        """展示最近若干条事件。"""
        if self.state is None or not self.state.events:
            self.output("当前没有事件。")
            return
        try:
            count = int(count_text) if count_text else 10
        except ValueError:
            self.output("格式：events [数量]")
            return
        events = self.state.events[-max(count, 1) :]
        self.output(json.dumps(redact_mapping(events), ensure_ascii=False, indent=2, default=str))

    def _configure_llm(self, text: str) -> None:
        """热加载 LLM 配置，或开关 action 后诊断。"""
        if not text:
            self.output("格式：llm config base_url=... api_key=... model=... action_analysis_prompt_file=... | llm test [文本] | llm fallback | llm action-analysis on|off")
            return
        try:
            parts = shlex.split(text)
        except ValueError as exc:
            logger.exception("chat LLM 命令解析失败 text=%s", redact_for_log(text, max_text_len=500))
            self.output(f"LLM 命令解析失败: {exc}")
            return
        if parts[0] == "fallback":
            self.agent.llm_client = RuleBasedLlmClient()
            self.llm_config = {}
            self.output("已切回本地规则 LLM fallback。")
            logger.info("chat LLM 已切回 fallback")
            return
        if parts[0] == "test":
            test_text = text.partition("test")[2].strip()
            self._test_llm(test_text)
            return
        if parts[0] == "action-analysis":
            if len(parts) < 2 or parts[1] not in ("on", "off"):
                self.output("格式：llm action-analysis on|off")
                return
            self.agent.action_analysis_enabled = parts[1] == "on"
            self.output(f"action 审核详情写入 events 已{'开启' if self.agent.action_analysis_enabled else '关闭'}。")
            logger.info("chat action 审核事件写入开关=%s", self.agent.action_analysis_enabled)
            return
        if parts[0] != "config":
            self.output("未知 llm 命令。")
            return
        updates = _parse_key_values(parts[1:])
        self.llm_config.update(updates)
        try:
            logger.info("chat 开始加载 LLM 配置 updates=%s merged=%s", json_for_log(updates), json_for_log(self.llm_config))
            self.agent.llm_client = build_llm_client(
                base_url=self.llm_config.get("base_url"),
                api_key=self.llm_config.get("api_key"),
                model=self.llm_config.get("model"),
                action_analysis_prompt_path=self.llm_config.get("action_analysis_prompt_file"),
            )
        except Exception as exc:
            logger.exception("chat LLM 配置失败 config=%s", json_for_log(self.llm_config))
            self.output(f"LLM 配置失败: {exc}")
            return
        safe = {**self.llm_config}
        if safe.get("api_key"):
            safe["api_key"] = "***"
        self.output("LLM 配置已加载: " + json.dumps(safe, ensure_ascii=False))
        logger.info("chat LLM 配置已加载 client=%s config=%s", type(self.agent.llm_client).__name__, json_for_log(self.llm_config))

    def _test_llm(self, text: str) -> None:
        """使用当前 LLM client 做一次轻量调用，便于确认配置是否生效。"""
        prompt = text or "请判断这是一次 LLM 连通性测试，并返回结构化意图。"
        client_name = type(self.agent.llm_client).__name__
        self.output(f"正在测试 LLM: {client_name}")
        logger.info("chat LLM 测试开始 client=%s prompt=%s", client_name, redact_for_log(prompt, max_text_len=500))
        try:
            result = self.agent.understand_request(prompt)
        except Exception as exc:
            logger.exception("chat LLM 测试失败 client=%s", client_name)
            self.output(f"LLM 测试失败: {exc}")
            return
        self.output("LLM 测试通过")
        self.output(f"- client: {client_name}")
        self.output(f"- intent: {result.intent}")
        self.output(f"- strategy: {result.strategy_preference}")
        self.output(f"- confidence: {result.confidence}")
        if result.reasons:
            self.output("- reasons: " + "; ".join(result.reasons))
        logger.info("chat LLM 测试通过 client=%s result=%s", client_name, json_for_log(asdict(result)))

    def _configure_mcp(self, text: str) -> None:
        """热加载 MCP client 配置。"""
        command, _, path = text.partition(" ")
        if command != "config" or not path.strip():
            self.output("格式：mcp config <mcp_client.json>")
            return
        path = path.strip().strip('"')
        try:
            logger.info("chat 开始加载 MCP 配置 path=%s", path)
            runner = build_mcp_runner_from_config(path)
        except Exception as exc:
            logger.exception("chat MCP 配置失败 path=%s", path)
            self.output(f"MCP 配置失败: {exc}")
            return
        self.agent.mcp_runner = runner
        self.agent.router.mcp_runner = runner
        self.mcp_config_path = path
        self.output(f"MCP 配置已加载: {path}")
        logger.info("chat MCP 配置已加载 path=%s runner=%s", path, type(runner).__name__)

    def _list_checkpoints(self) -> None:
        """列出当前 checkpoint 目录下的 JSON 文件。"""
        checkpoint_dir = Path(self.checkpoint_path).parent
        logger.info("chat 查询 checkpoint 列表 dir=%s", checkpoint_dir)
        if not checkpoint_dir.exists():
            self.output(f"checkpoint 目录不存在: {checkpoint_dir}")
            return
        files = sorted(checkpoint_dir.glob("*.json"), key=lambda item: item.stat().st_mtime, reverse=True)
        if not files:
            self.output(f"checkpoint 目录没有 JSON 文件: {checkpoint_dir}")
            return
        lines = ["checkpoint 列表："]
        for file in files[:20]:
            lines.append(f"- {file}")
        self.output("\n".join(lines))

    def _load_checkpoint(self, path_text: str) -> None:
        """加载指定 checkpoint 文件。"""
        if not path_text:
            self.output("格式：load checkpoint <路径>")
            return
        checkpoint = Path(path_text)
        logger.info("chat 开始加载 checkpoint path=%s", checkpoint)
        if not checkpoint.exists():
            self.output(f"checkpoint 不存在: {checkpoint}")
            return
        self.state = load_agent_state(checkpoint)
        self.state.checkpoint_path = str(checkpoint)
        self.checkpoint_path = str(checkpoint)
        self.params = dict(self.state.params)
        self.strategy = self.state.execution_strategy
        self.target_ips = list(self.state.target_ips)
        self.graph_runtime = None
        self.output(f"已加载 checkpoint: {checkpoint}")
        logger.info(
            "chat checkpoint 已加载 path=%s run_id=%s strategy=%s paused=%s pending=%s",
            checkpoint,
            self.state.run_id,
            self.strategy,
            self.state.paused,
            self.state.pending_confirmation,
        )
        if self.state.pending_confirmation:
            self._print_confirmation()
        self._print_pause_context()

    def _load_params(self, path_text: str) -> None:
        """从参数文件热更新当前会话参数，并同步到已暂停 state。"""
        if not path_text:
            self.output("格式：load params <路径>")
            return
        path = Path(path_text)
        logger.info("chat 开始加载参数文件 path=%s", path)
        if not path.exists():
            self.output(f"参数文件不存在: {path}")
            return
        try:
            updates = load_params_file(path)
        except Exception as exc:
            logger.exception("chat 参数文件加载失败 path=%s", path)
            self.output(f"参数文件加载失败: {exc}")
            return
        self.params.update(updates)
        try:
            self.params = self.agent.normalize_params(self.params)
        except ValueError as exc:
            logger.exception("chat 参数热更新归一化失败 path=%s updates=%s", path, json_for_log(updates))
            self.output(f"参数热更新失败: {exc}")
            return
        self._sync_params_to_state()
        self.output(f"已加载参数文件: {path}")
        self.output(_format_redacted_params(redact_mapping(self.params)))
        logger.info("chat 参数文件已加载 path=%s updates=%s params=%s", path, json_for_log(updates), json_for_log(self.params))

    def _run_deploy(self) -> None:
        """在用户确认后创建状态并执行完整部署流程。"""
        logger.info("chat run 请求开始 strategy=%s checkpoint=%s target_ips=%s", self.strategy, self.checkpoint_path, self.target_ips)
        if self.state and self.state.pending_confirmation:
            logger.info("chat run 命中待确认事项 pending=%s", self.state.pending_confirmation)
            self._print_confirmation()
            return

        if not self._prepare_params_for_run():
            logger.info("chat run 参数准备失败")
            return

        problems = self._validate_run_prerequisites(self.params)
        if problems:
            logger.info("chat run 前置检查失败 problems=%s", problems)
            self.output("执行前检查未通过：")
            for problem in problems:
                self.output(f"- {problem}")
            self.output("请修正参数或配置后再输入 run。")
            return

        if not self._confirm_params_and_scope():
            logger.info("chat run 用户取消参数或目标范围确认")
            self.output("已取消执行。")
            return

        if not self._ask_yes_no("即将执行真实 action；确认执行请输入 yes: "):
            logger.info("chat run 用户取消最终执行确认")
            self.output("已取消执行。")
            return

        self.state = self.agent.create_state(
            params=self.params,
            execution_strategy=self.strategy,
            checkpoint_path=self.checkpoint_path,
            target_ips=self.target_ips,
        )
        self.graph_runtime = None
        logger.info(
            "chat run state 已创建 run_id=%s strategy=%s checkpoint=%s config=%s target_ips=%s",
            self.state.run_id,
            self.state.execution_strategy,
            self.state.checkpoint_path,
            self.state.config_path,
            self.state.target_ips,
        )
        self._execute_current_state()

    def _confirm_params_and_scope(self) -> bool:
        """执行前确认参数和目标 IP 范围。"""
        self.output(_format_redacted_params(redact_mapping(self.params)))
        if not self._ask_yes_no("确认以上参数请输入 yes: "):
            return False
        if self.target_ips:
            self.output("目标 IP: " + ", ".join(self.target_ips))
        else:
            self.output("目标 IP: 未指定，将在 get-online-ips 后使用全部在线 IP。")
        return self._ask_yes_no("确认目标范围请输入 yes: ")

    def _resume(self) -> None:
        """从内存状态或 checkpoint 文件继续执行部署流程。"""
        if self.state is None:
            checkpoint = Path(self.checkpoint_path)
            if not checkpoint.exists():
                self.output("当前没有可续跑的 checkpoint。")
                logger.info("chat resume 未找到 checkpoint path=%s", checkpoint)
                return
            logger.info("chat resume 从 checkpoint 加载 path=%s", checkpoint)
            self.state = load_agent_state(checkpoint)
            self.state.checkpoint_path = self.state.checkpoint_path or str(checkpoint)
        if self.state.paused:
            logger.info("chat resume 清理暂停状态 run_id=%s reason=%s", self.state.run_id, self.state.pause_reason)
            self.state = self.agent.resume_state(self.state)
        if self.graph_runtime and self.graph_runtime.waiting_confirmation:
            logger.info("chat resume 停在 LangGraph 确认点 pending=%s", self.state.pending_confirmation if self.state else "")
            self._print_confirmation()
            return
        logger.info("chat resume 开始执行 run_id=%s checkpoint=%s", self.state.run_id if self.state else "", self.checkpoint_path)
        self._execute_current_state()

    def _execute_current_state(self) -> None:
        """执行当前 state，并输出报告、确认提示和 checkpoint 路径。"""
        if self.state is None:
            self.output("当前没有运行状态。")
            return
        logger.info(
            "chat 开始执行当前 state run_id=%s strategy=%s checkpoint=%s graph_runtime=%s waiting_confirmation=%s",
            self.state.run_id,
            self.state.execution_strategy,
            self.state.checkpoint_path,
            type(self.graph_runtime).__name__ if self.graph_runtime else "",
            self.graph_runtime.waiting_confirmation if self.graph_runtime else False,
        )
        if self.graph_runtime is None or not self.graph_runtime.waiting_confirmation:
            try:
                self.graph_runtime = LangGraphDeploymentRuntime(agent=self.agent)
            except RuntimeError as exc:
                logger.exception("chat LangGraph runtime 不可用，降级本地执行 run_id=%s", self.state.run_id)
                self.output(f"LangGraph 确认运行器不可用，降级为本地执行: {exc}")
                self.graph_runtime = None
                try:
                    self.state = self.agent.run_deploy_flow(self.state)
                except KeyboardInterrupt:
                    self._handle_execution_interrupt()
                    return
                except Exception as fallback_exc:
                    self._handle_execution_error(fallback_exc)
                    return
                self._print_state_report_and_checkpoint()
                logger.info("chat 本地执行完成 run_id=%s checkpoint=%s", self.state.run_id, self.state.checkpoint_path)
                return
        try:
            result = self.graph_runtime.start(self.state)
        except KeyboardInterrupt:
            self._handle_execution_interrupt()
            return
        except Exception as exc:
            self._handle_execution_error(exc)
            return
        self._apply_graph_result(result)
        logger.info(
            "chat LangGraph 执行返回 interrupted=%s pending=%s checkpoint=%s",
            result.interrupted,
            self.state.pending_confirmation if self.state else "",
            self.state.checkpoint_path if self.state else self.checkpoint_path,
        )

    def _prepare_params_for_run(self) -> bool:
        """执行前归一化参数，确保确认值和实际写入脚本配置一致。"""
        try:
            self.params = self.agent.normalize_params(self.params)
        except ValueError as exc:
            logger.exception("chat 参数检查失败 params=%s", json_for_log(self.params))
            self.output(f"参数检查失败: {exc}")
            return False
        logger.info("chat 参数检查通过 params=%s", json_for_log(self.params))
        return True

    def _validate_run_prerequisites(self, params: dict[str, Any]) -> list[str]:
        """在创建 state 前检查可提前发现的运行问题。"""
        problems: list[str] = []
        if self.strategy != "fake":
            zip_path = str(params.get("ZIP_FILE_PATH", "")).strip()
            if not _path_exists(zip_path):
                problems.append(f"ZIP_FILE_PATH 不存在: {zip_path}")
        if self.strategy in ("script_only", "hybrid_node_mcp"):
            script_entry = self.agent.script_base_dir / "deploy.sh"
            ps_entry = self.agent.script_base_dir / "deploy.ps1"
            if not script_entry.exists() and not ps_entry.exists():
                problems.append(f"脚本入口不存在: {script_entry} 或 {ps_entry}")
        if self.strategy == "hybrid_node_mcp" and self.agent.mcp_runner is None:
            problems.append("当前策略需要 MCP runner，请启动时传 --mcp-config 或在 chat 内执行 mcp config <路径>。")
        return problems

    def _handle_execution_error(self, exc: Exception) -> None:
        """输出 action 执行失败后的可恢复提示，不再误报 LangGraph 不可用。"""
        self.output(f"执行已停止: {exc}")
        logger.exception(
            "chat 执行停止 run_id=%s checkpoint=%s",
            self.state.run_id if self.state else "",
            self.state.checkpoint_path if self.state else self.checkpoint_path,
        )
        if self.state is None:
            return
        if self.state.last_failed_step:
            self.output(f"最后失败步骤: {self.state.last_failed_step}")
        self._print_pause_context()
        if self.state.pending_confirmation:
            self._print_confirmation()
        self.output(f"checkpoint: {self.state.checkpoint_path or self.checkpoint_path}")
        self.output("请修正参数或外部环境后，使用 load checkpoint <路径> / resume 继续，或重新 run。")

    def _handle_execution_interrupt(self) -> None:
        """处理执行中的用户中断，并保留断点。"""
        if self.state is None:
            self.output("执行已中断。")
            logger.info("chat 执行中断时没有 state")
            return
        self.graph_runtime = None
        logger.info("chat 执行被用户中断 run_id=%s checkpoint=%s", self.state.run_id, self.state.checkpoint_path)
        self.state = self.agent.pause_state(
            self.state,
            reason="user_interrupted",
            review_context={"type": "user_interrupt", "message": "用户手动中断执行"},
        )
        self.output("执行已由用户中断，当前 checkpoint 已保存。")
        self._print_pause_context()
        self.output(f"checkpoint: {self.state.checkpoint_path or self.checkpoint_path}")

    def _apply_graph_result(self, result: LangGraphRunResult) -> None:
        """把 LangGraph 运行结果同步回 chat 会话并输出用户可见状态。"""
        if result.state is not None:
            self.state = result.state
        if self.state is None:
            self.output("当前没有运行状态。")
            return
        logger.info(
            "chat 应用 LangGraph 结果 run_id=%s interrupted=%s pending=%s paused=%s",
            self.state.run_id,
            result.interrupted,
            self.state.pending_confirmation,
            self.state.paused,
        )
        self.output(result.report or self.agent.render_report(self.state))
        if result.interrupted and result.confirmation:
            self._print_confirmation_request(result.confirmation)
        elif self.state.pending_confirmation:
            self._print_confirmation()
        self._print_pause_context()
        self.output(f"checkpoint: {self.state.checkpoint_path or self.checkpoint_path}")

    def _print_state_report_and_checkpoint(self) -> None:
        """输出本地执行路径的状态报告和 checkpoint。"""
        if self.state is None:
            return
        self.output(self.agent.render_report(self.state))
        self._print_pause_context()
        if self.state.pending_confirmation:
            self._print_confirmation()
        self.output(f"checkpoint: {self.state.checkpoint_path or self.checkpoint_path}")

    def _status(self) -> None:
        """输出当前运行状态；没有 state 时输出 checkpoint 路径。"""
        if self.state is None:
            self.output("当前还没有运行状态。")
            self.output(f"checkpoint: {self.checkpoint_path}")
            return
        self.output(self.agent.render_report(self.state))
        self._print_pause_context()
        if self.state.pending_confirmation:
            self._print_confirmation()

    def _confirm(self, *, approved: bool, note: str = "") -> None:
        """处理 approve/reject 命令。"""
        if self.state is None:
            checkpoint = Path(self.checkpoint_path)
            if checkpoint.exists():
                logger.info("chat confirm 从 checkpoint 加载 path=%s", checkpoint)
                self.state = load_agent_state(checkpoint)
                self.state.checkpoint_path = self.state.checkpoint_path or str(checkpoint)
            else:
                self.output("当前没有待确认任务。")
                logger.info("chat confirm 无 state 且 checkpoint 不存在 path=%s", checkpoint)
                return
        if not self.state.pending_confirmation:
            self.output("当前没有待确认任务。")
            logger.info("chat confirm 无待确认事项 run_id=%s", self.state.run_id)
            return

        logger.info(
            "chat confirm 开始 run_id=%s approved=%s pending=%s note_len=%s",
            self.state.run_id,
            approved,
            self.state.pending_confirmation,
            len(note),
        )
        if self.graph_runtime and self.graph_runtime.waiting_confirmation:
            try:
                result = self.graph_runtime.resume(approved=approved, note=note)
            except RuntimeError as exc:
                logger.exception("chat LangGraph 确认恢复失败，降级本地确认 run_id=%s", self.state.run_id)
                self.output(f"LangGraph 确认恢复失败，降级为本地确认: {exc}")
            else:
                self._apply_graph_result(result)
                return

        self.state = self.agent.confirm_pending(self.state, approved=approved, operator_note=note)
        logger.info(
            "chat confirm 完成 run_id=%s pending=%s paused=%s",
            self.state.run_id,
            self.state.pending_confirmation,
            self.state.paused,
        )
        self.output(self.agent.render_report(self.state))
        self._print_pause_context()
        if self.state.pending_confirmation:
            self._print_confirmation()

    def _rollback(self, text: str) -> None:
        """显式执行单 IP 回滚；主 workflow 不再自动触发回滚。"""
        if self.state is None:
            checkpoint = Path(self.checkpoint_path)
            if checkpoint.exists():
                logger.info("chat rollback 从 checkpoint 加载 path=%s", checkpoint)
                self.state = load_agent_state(checkpoint)
                self.state.checkpoint_path = self.state.checkpoint_path or str(checkpoint)
            else:
                self.output("当前没有可回滚的运行状态。")
                logger.info("chat rollback 无 state 且 checkpoint 不存在 path=%s", checkpoint)
                return
        try:
            ip, stop_first, note = _parse_rollback_args(text)
        except ValueError as exc:
            self.output(f"rollback 参数错误: {exc}")
            return
        ip = ip or _find_current_failed_ip(self.state)
        if not ip:
            self.output("未找到当前失败 IP，请使用 rollback <IP> 指定。")
            logger.info("chat rollback 未找到可回滚 IP run_id=%s", self.state.run_id)
            return
        logger.info(
            "chat rollback 开始 run_id=%s ip=%s stop_first=%s note_len=%s",
            self.state.run_id,
            ip,
            stop_first,
            len(note),
        )
        self.graph_runtime = None
        try:
            self.state = self.agent.rollback_ip(
                self.state,
                ip,
                stop_first=stop_first,
                operator_note=note,
            )
        except Exception as exc:
            logger.exception("chat rollback 执行失败 run_id=%s ip=%s", self.state.run_id, ip)
            self.output(f"rollback 执行失败: {exc}")
            self._print_pause_context()
            return
        self.output(self.agent.render_report(self.state))
        self._print_pause_context()
        self.output(f"checkpoint: {self.state.checkpoint_path or self.checkpoint_path}")
        if not self.state.paused:
            self.output("回滚已完成；如需继续主流程，输入 resume。")
        logger.info(
            "chat rollback 完成 run_id=%s ip=%s status=%s paused=%s",
            self.state.run_id,
            ip,
            self.state.ip_states.get(ip, {}).get("rollback_status"),
            self.state.paused,
        )

    def _sync_params_to_state(self) -> None:
        """若当前已有 state，则把热更新参数同步到 checkpoint/config。"""
        if self.state is None:
            return
        try:
            self.state = self.agent.update_state_params(self.state, self.params)
        except ValueError as exc:
            logger.exception("chat 参数同步到 state 失败 run_id=%s params=%s", self.state.run_id, json_for_log(self.params))
            self.output(f"参数同步到当前任务失败: {exc}")
            return
        self.params = dict(self.state.params)
        if self.target_ips:
            self.state.target_ips = list(self.target_ips)
        logger.info(
            "chat 参数已同步到 state run_id=%s checkpoint=%s params=%s target_ips=%s",
            self.state.run_id,
            self.state.checkpoint_path,
            json_for_log(self.params),
            self.target_ips,
        )

    def _print_pause_context(self) -> None:
        """输出暂停原因和审核建议，避免黑盒暂停。"""
        if self.state is None or not self.state.paused:
            return
        context = self.state.review_context or {}
        reason = self.state.pause_reason or "unknown"
        self.output(f"当前流程已暂停: {reason}")
        if context.get("stage"):
            self.output(f"- stage: {context.get('stage')}")
        if context.get("ip"):
            self.output(f"- ip: {context.get('ip')}")
        if context.get("possible_reason"):
            self.output(f"- reason: {context.get('possible_reason')}")
        elif context.get("error_summary"):
            self.output(f"- reason: {context.get('error_summary')}")
        if context.get("suggested_action"):
            self.output(f"- suggestion: {context.get('suggested_action')}")
        if context.get("severity"):
            self.output(f"- severity: {context.get('severity')}")
        if context.get("notes"):
            self.output("- notes: " + "; ".join(str(item) for item in context.get("notes", [])))
        if reason == "user_interrupted":
            self.output("输入 resume 可从当前 checkpoint 继续。")
        elif reason == "llm_review_blocked":
            self.output("请根据以上建议判断后续；如需继续，输入 resume。")
        elif reason == "action_failed":
            ip = context.get("ip")
            rollback_hint = f"rollback {ip}" if ip else "rollback <IP>"
            self.output(f"请修复失败原因后输入 resume 重试当前 action；如需回滚，输入 {rollback_hint}。")
        elif reason == "rollback_failed":
            self.output("请检查回滚失败原因；修复后可再次输入 rollback 重试，或人工处理后再 resume。")

    def _on_progress(self, payload: dict[str, Any]) -> None:
        """把 Agent action 进度转成 chat 可见输出。"""
        event_type = str(payload.get("type", ""))
        stage = str(payload.get("stage", ""))
        backend = str(payload.get("backend", ""))
        ip = str(payload.get("ip", ""))
        message = str(payload.get("message", ""))
        suffix_parts = []
        if backend:
            suffix_parts.append(f"backend={backend}")
        if ip:
            suffix_parts.append(f"ip={ip}")
        suffix = f" [{', '.join(suffix_parts)}]" if suffix_parts else ""
        if event_type == "ACTION_START":
            self.output(f"开始执行 action: {stage}{suffix}")
        elif event_type == "ACTION_DONE":
            detail = f": {message}" if message and message != "ok" else ""
            self.output(f"完成 action: {stage}{suffix}{detail}")
        elif event_type == "ACTION_FAIL":
            detail = f": {message}" if message else ""
            self.output(f"失败 action: {stage}{suffix}{detail}")
        elif event_type == "ACTION_REVIEW_START":
            self.output(f"开始分析 action 结果: {stage}{suffix}")
        elif event_type == "ACTION_REVIEW_DONE":
            detail = f": {message}" if message else ""
            self.output(f"分析完成: {stage}{suffix}{detail}")
        elif event_type == "ACTION_REVIEW_FAIL":
            detail = f": {message}" if message else ""
            self.output(f"分析失败: {stage}{suffix}{detail}")
        logger.info("chat progress event=%s", json_for_log(payload))

    def _print_confirmation(self) -> None:
        """输出当前待人工确认事项。"""
        if self.state is None:
            return
        request = self.agent.build_confirmation_request(self.state)
        if not request:
            return
        self._print_confirmation_request(request)

    def _print_confirmation_request(self, request: dict[str, Any]) -> None:
        """输出指定的人工确认请求。"""
        self.output("需要人工确认：")
        self.output(f"- type: {request.get('type')}")
        if request.get("ip"):
            self.output(f"- ip: {request['ip']}")
        if request.get("failed_stage"):
            self.output(f"- failed_stage: {request['failed_stage']}")
        if request.get("failure_reason"):
            self.output(f"- reason: {request['failure_reason']}")
        self.output("输入 approve 执行回滚，或 reject [原因] 拒绝回滚。")

    def _ask_yes_no(self, prompt: str) -> bool:
        """读取一次 yes/no 确认，只有 yes/y 视为确认。"""
        try:
            answer = self.input(prompt).strip().lower()
        except EOFError:
            return False
        return answer in ("yes", "y")

    def _load_existing_checkpoint_if_any(self) -> None:
        """会话启动时自动加载已存在的 checkpoint。"""
        checkpoint = Path(self.checkpoint_path)
        if not checkpoint.exists():
            return
        logger.info("chat 启动时自动加载已有 checkpoint path=%s", checkpoint)
        self.state = load_agent_state(checkpoint)
        self.state.checkpoint_path = self.state.checkpoint_path or str(checkpoint)
        self.output(f"已加载 checkpoint: {checkpoint}")
        if self.state.pending_confirmation:
            self._print_confirmation()
        self._print_pause_context()


def run_interactive_chat(
    *,
    agent: PamDeployAgent,
    params: dict[str, Any],
    strategy: ExecutionStrategy,
    checkpoint_path: str | None = None,
    target_ips: list[str] | None = None,
    input_func: InputFunc = input,
    output_func: OutputFunc = print,
) -> InteractiveCliSession:
    """创建并运行交互式 CLI 会话，返回会话对象便于测试。"""
    session = InteractiveCliSession(
        agent=agent,
        params=params,
        strategy=strategy,
        checkpoint_path=checkpoint_path,
        target_ips=target_ips,
        input_func=input_func,
        output_func=output_func,
    )
    session.run()
    return session


def _default_checkpoint_path() -> str:
    """生成默认 chat checkpoint 路径。"""
    return str(Path("runtime") / "checkpoints" / f"chat_{time.strftime('%Y%m%d_%H%M%S')}.json")


def _choose_strategy(preference: str, default: ExecutionStrategy) -> ExecutionStrategy:
    """根据 LLM 偏好更新执行策略，非法值保留默认策略。"""
    if preference in ("hybrid_node_mcp", "script_only", "fake"):
        return preference  # type: ignore[return-value]
    return default


def _format_redacted_params(params: dict[str, Any]) -> str:
    """把脱敏后的参数字典格式化为多行文本。"""
    lines = ["当前参数："]
    for key in sorted(params):
        lines.append(f"- {key}: {params[key]}")
    return "\n".join(lines)


def _parse_key_values(parts: list[str]) -> dict[str, str]:
    """解析 KEY=VALUE 参数列表。"""
    values: dict[str, str] = {}
    for part in parts:
        if "=" not in part:
            continue
        key, value = part.split("=", 1)
        if key:
            values[key] = value
    return values


def _parse_rollback_args(text: str) -> tuple[str, bool | None, str]:
    """解析 chat rollback 命令参数，返回 IP、停机覆盖值和备注。"""
    try:
        parts = shlex.split(text)
    except ValueError as exc:
        raise ValueError(str(exc)) from exc
    ip = ""
    stop_first: bool | None = None
    note_parts: list[str] = []
    index = 0
    while index < len(parts):
        part = parts[index]
        if part == "--stop-first":
            stop_first = True
        elif part == "--no-stop-first":
            stop_first = False
        elif part in ("--note", "-n"):
            index += 1
            if index >= len(parts):
                raise ValueError("--note 需要提供备注内容")
            note_parts.append(parts[index])
        elif not ip:
            ip = part
        else:
            note_parts.append(part)
        index += 1
    return ip, stop_first, " ".join(note_parts)


def _find_current_failed_ip(state: AgentState) -> str:
    """从当前 state 中找一个适合显式回滚的失败 IP。"""
    context_ip = str((state.review_context or {}).get("ip", ""))
    if context_ip and context_ip in state.ip_states:
        return context_ip
    for ip, ip_state in state.ip_states.items():
        if ip_state.get("status") == "FAILED":
            return ip
    return ""


def _is_small_talk(text: str) -> bool:
    """识别不应触发 LLM/结构化分析的简单寒暄。"""
    normalized = text.strip().lower()
    return normalized in {
        "你好",
        "您好",
        "hello",
        "hi",
        "hey",
        "在吗",
        "谢谢",
        "thanks",
        "thank you",
    }


def _looks_like_deploy_request(text: str) -> bool:
    """粗筛自然语言部署需求，避免任意闲聊都触发耗时分析。"""
    lowered = text.lower()
    deploy_keywords = (
        "部署",
        "发布",
        "升级",
        "回滚",
        "预演",
        "执行",
        "pam",
        "mcp",
        "node",
        "版本",
        "机场",
        "deploy",
        "release",
        "upgrade",
        "rollback",
        "preview",
    )
    param_markers = (
        "HOME_BASE_URL",
        "CLIENT_ID",
        "AIRPORT_CODE",
        "APP_NAME",
        "MODULE_NAME",
        "VERSION_NUMBER",
        "ZIP_FILE_PATH",
    )
    return any(keyword in lowered for keyword in deploy_keywords) or any(marker in text for marker in param_markers)


def _path_exists(path: str) -> bool:
    """检查本地路径是否存在，兼容打包到 Linux 后的绝对路径。"""
    if not path:
        return False
    return Path(path).expanduser().exists()


def _build_prompt_input(input_func: InputFunc) -> InputFunc:
    """如果安装了 prompt_toolkit，则启用历史记录和命令补全。"""
    if input_func is not builtins.input:
        return input_func
    try:
        from prompt_toolkit import PromptSession
        from prompt_toolkit.completion import WordCompleter
        from prompt_toolkit.history import FileHistory
    except ImportError:
        return _build_readline_input(input_func)

    commands = [
        "help",
        "preview",
        "analyze",
        "params",
        "events",
        "set",
        "llm config",
        "llm test",
        "llm fallback",
        "llm action-analysis on",
        "llm action-analysis off",
        "mcp config",
        "run",
        "status",
        "resume",
        "rollback",
        "rollback --stop-first",
        "list checkpoints",
        "load params",
        "load checkpoint",
        "checkpoint",
        "exit",
    ]
    history = None
    try:
        history_path = Path("runtime") / "chat_history.txt"
        history_path.parent.mkdir(parents=True, exist_ok=True)
        history = FileHistory(str(history_path))
    except OSError:
        history = None

    try:
        session = PromptSession(
            history=history,
            completer=WordCompleter(commands, ignore_case=True, sentence=True),
        )
    except Exception:
        logger.exception("chat prompt_toolkit 初始化失败，降级为普通 input")
        return _build_readline_input(input_func)
    return session.prompt


def _build_readline_input(input_func: InputFunc) -> InputFunc:
    """在没有 prompt_toolkit 时尽量启用 GNU readline，改善 Linux 终端退格键兼容。"""
    if input_func is not builtins.input or os.name == "nt":
        return input_func
    try:
        import readline  # noqa: F401
    except ImportError:
        logger.debug("chat readline 不可用，使用普通 input")
    return input_func


def _build_output_func(output_func: OutputFunc) -> OutputFunc:
    """如果安装了 rich，则使用 rich 输出；否则保持原输出函数。"""
    if output_func is not builtins.print:
        return output_func
    try:
        from rich.console import Console
        from rich.markdown import Markdown
    except ImportError:
        return output_func
    console = Console()

    def rich_print(value: str) -> None:
        text = str(value)
        stripped = text.lstrip()
        if stripped.startswith("{") or stripped.startswith("["):
            try:
                console.print_json(text)
                return
            except Exception:
                pass
        if text.startswith("## ") or "\n| ---" in text:
            console.print(Markdown(text))
            return
        console.print(text)

    return rich_print