"""Connect agent hosts to Harbor: `harbor install <host> --agent <Name> [--project <name>] [--dry-run|--uninstall]`.

Hosts and what gets written (every edited file is backed up first; Harbor's part sits between marker lines so it
can be replaced or removed without touching anything else):

  codex     ~/.codex/config.toml   [mcp_servers.harbor]           (Harbor's MCP tools)
            ~/.codex/hooks.json    SessionStart, UserPromptSubmit, PreToolUse, Stop -> `harbor hook ...`
            ~/.codex/AGENTS.md     the Harbor protocol, applied only inside Harbor projects
            Codex runs hooks only after you trust them: Settings > Hooks > Trust.
  opencode  ~/.config/opencode/opencode.jsonc  "mcp": {"harbor": ...}
            ~/.config/opencode/plugin/harbor.js  STOP gate, session brief, idle nudges
            ~/.config/opencode/AGENTS.md
  deepseek  ~/.dsh/profiles/desktop/cordis.patch.yml  MCP client row + Claude-format hooks bridge row
            <harbor home>/integrations/deepseek/hooks.json
            ~/.dsh/AGENTS.md
            MCP tools hot-reload; the hooks file is read when DeepSeek Harness starts.
  kimi      <harbor home>/integrations/kimi/harbor-<project>/  a Kimi personal plugin (MCP, hooks, system prompt),
            validated and registered with Kimi's own tools; you install it from Kimi's Plugins > Personal tab.
            Kimi works outside the project folder, so its plugin is bound to one project.
  claude    prints how to add the Claude Code plugin in integrations/claude-code.

Hooks resolve the project from the agent's working directory (or --project when bound), and stay silent in folders
that are not Harbor projects, so installing them in a host used for other work is harmless.
"""
import datetime
import json
import os
import re
import shutil
import subprocess
import sys
import tomllib
from pathlib import Path

from . import projects
from .texts import launcher, protocol as agents_section  # noqa: F401

PACKAGE_ROOT = projects.PACKAGE_ROOT
INTEGRATIONS = PACKAGE_ROOT / "integrations"
START, END = "# >>> harbor >>>", "# <<< harbor <<<"
MD_START, MD_END = "<!-- >>> harbor >>> -->", "<!-- <<< harbor <<< -->"
HOSTS = ("codex", "opencode", "deepseek", "kimi", "claude")
DEFAULT_AGENT = {"codex": "Codex", "opencode": "OpenCode", "deepseek": "DeepSeek", "kimi": "Kimi", "claude": "Claude"}


class InstallError(Exception):
    pass


def user_home():
    return Path(os.environ.get("HARBOR_INSTALL_HOME") or Path.home())


def identity_args(agent, project):
    return ["--as", agent] + (["--project", project] if project else [])


class Plan:
    """Collects file writes so --dry-run can show them and a real run can back up and apply them."""

    def __init__(self, host, dry_run):
        self.host = host
        self.dry_run = dry_run
        self.writes = []
        self.notes = []
        self.stamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")

    def write(self, path, text, validate=None):
        if validate and text is not None:
            validate(text)
        self.writes.append((Path(path), text))

    def remove(self, path):
        self.writes.append((Path(path), None))

    def apply(self):
        report = []
        for path, text in self.writes:
            old = path.read_text(encoding="utf-8") if path.exists() else None
            if old == text:
                report.append(f"unchanged  {path}")
                continue
            action = "remove" if text is None else ("update" if old is not None else "create")
            report.append(f"{action:<10} {path}")
            if self.dry_run:
                continue
            if old is not None:
                backup = projects.harbor_home() / "backups" / "integrations" / self.stamp / self.host / path.name
                backup.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(path, backup)
                report[-1] += f"   (backup: {backup})"
            if text is None:
                path.unlink()
            else:
                path.parent.mkdir(parents=True, exist_ok=True)
                path.write_text(text, encoding="utf-8", newline="\n")
        return report + self.notes


def replace_block(text, block, start=START, end=END):
    """Put block between the markers (replacing an earlier Harbor block); block=None removes it."""
    pattern = re.compile(re.escape(start) + r".*?" + re.escape(end) + r"\n?", re.S)
    text = pattern.sub("", text or "")
    if block is None:
        return text.rstrip("\n") + "\n" if text.strip() else ""
    return (text.rstrip("\n") + "\n\n" if text.strip() else "") + f"{start}\n{block.rstrip()}\n{end}\n"


def _hook_entries(cmd, agent, project, host, events):
    base = " ".join(cmd + identity_args(agent, project) + ["hook"])
    names = {"SessionStart": "session-start", "UserPromptSubmit": "prompt-submit", "PreToolUse": "pre-tool",
             "Stop": "stop"}
    return {event: [{"hooks": [{"type": "command", "command": f"{base} {names[event]} --host {host}", "timeout": 30}]}]
            for event in events}


def _is_ours(entry):
    return "run.py" in json.dumps(entry) and " hook " in json.dumps(entry)


def merge_hooks_json(text, ours, remove=False):
    data = json.loads(text) if text and text.strip() else {}
    hooks = data.setdefault("hooks", {})
    for event in list(hooks):
        hooks[event] = [e for e in hooks[event] if not _is_ours(e)]
        if not hooks[event]:
            del hooks[event]
    if not remove:
        for event, entries in ours.items():
            hooks.setdefault(event, []).extend(entries)
    if not hooks:
        data.pop("hooks")
    return json.dumps(data, indent=2) + "\n"


def _read(path):
    return path.read_text(encoding="utf-8") if path.exists() else ""


def _md_block(path, section, remove):
    return replace_block(_read(path), None if remove else section, MD_START, MD_END)


# ----------------------------------------------------------------------------------------------- hosts
def install_codex(plan, agent, project, cmd, remove):
    home = user_home() / ".codex"
    config = home / "config.toml"
    text = _read(config)
    outside = replace_block(text, None)
    if re.search(r"^\[mcp_servers\.harbor\]", outside, re.M):
        raise InstallError(f"{config} already defines [mcp_servers.harbor] outside Harbor's block; remove it first")
    if re.search(r"^\[hooks\]", outside, re.M):
        raise InstallError(f"{config} has a [hooks] table; Codex refuses hooks in both config.toml and hooks.json")
    args = cmd[1:] + identity_args(agent, project) + ["mcp"]
    env = {"HARBOR_AGENT": agent, "HARBOR_HOST": "codex", **({"HARBOR_PROJECT": project} if project else {})}
    block = (f"# Managed by `harbor install codex`; remove with `harbor install codex --uninstall`.\n"
             f"[mcp_servers.harbor]\ncommand = {json.dumps(cmd[0])}\nargs = {json.dumps(args)}\n"
             f"startup_timeout_sec = 30\ntool_timeout_sec = 1900\n\n[mcp_servers.harbor.env]\n"
             + "".join(f"{k} = {json.dumps(v)}\n" for k, v in env.items()))
    plan.write(config, replace_block(text, None if remove else block), validate=tomllib.loads)
    hooks_path = home / "hooks.json"
    ours = _hook_entries(cmd, agent, project, "codex", ("SessionStart", "UserPromptSubmit", "PreToolUse", "Stop"))
    merged = merge_hooks_json(_read(hooks_path), ours, remove=remove)
    plan.write(hooks_path, merged if json.loads(merged) else None, validate=json.loads)
    plan.write(home / "AGENTS.md", _md_block(home / "AGENTS.md", agents_section(agent, project, cmd), remove))
    if not remove:
        plan.notes.append("Codex: open Settings > Hooks and trust the Harbor hooks (until then Codex skips them). "
                          "The MCP tools load in new Codex threads.")


def _jsonc_load(text):
    if re.search(r"(^|\s)//|/\*", re.sub(r'"(?:\\.|[^"\\])*"', '""', text)):
        raise InstallError("opencode.jsonc has comments; add the \"mcp\" entry by hand (see `--dry-run` output)")
    return json.loads(text) if text.strip() else {}


def install_opencode(plan, agent, project, cmd, remove):
    home = user_home() / ".config" / "opencode"
    config = next((p for p in (home / "opencode.jsonc", home / "opencode.json") if p.exists()), home / "opencode.jsonc")
    data = _jsonc_load(_read(config))
    mcp = data.setdefault("mcp", {})
    mcp.pop("harbor", None)
    if not remove:
        env = {"HARBOR_AGENT": agent, "HARBOR_HOST": "opencode", **({"HARBOR_PROJECT": project} if project else {})}
        mcp["harbor"] = {"type": "local", "command": cmd + identity_args(agent, project) + ["mcp"],
                         "environment": env, "enabled": True, "timeout": 15000}
    if not mcp:
        data.pop("mcp")
    plan.write(config, json.dumps(data, indent=2) + "\n", validate=json.loads)
    plugin = home / "plugin" / "harbor.js"
    if remove:
        plan.remove(plugin) if plugin.exists() else None
    else:
        source = (INTEGRATIONS / "opencode" / "harbor.js").read_text(encoding="utf-8")
        settings = (f"const AGENT = {json.dumps(agent)};\nconst PROJECT = {json.dumps(project)};\n"
                    f"const COMMAND = {json.dumps(cmd)};\nconst WAKE_IDLE_SESSIONS = true;   // nudge idle sessions "
                    "when messages arrive (never while stopped)\n")
        source = re.sub(r"(// >>> harbor settings >>>\n).*?(// <<< harbor settings <<<)",
                        lambda m: m.group(1) + settings + m.group(2), source, flags=re.S)
        plan.write(plugin, source)
    plan.write(home / "AGENTS.md", _md_block(home / "AGENTS.md", agents_section(agent, project, cmd), remove))
    if not remove:
        plan.notes.append("OpenCode: restart OpenCode to load the plugin and the MCP server.")


class _TolerantLoader:
    @staticmethod
    def load(text):
        import yaml

        class Loader(yaml.SafeLoader):
            pass
        Loader.add_multi_constructor("", lambda loader, suffix, node: None)
        Loader.add_multi_constructor("tag:yaml.org,2002:js", lambda loader, suffix, node: None)
        value = yaml.load(text, Loader=Loader)
        if not isinstance(value, list):
            raise InstallError("cordis.patch.yml must stay a YAML list")
        return value


def install_deepseek(plan, agent, project, cmd, remove):
    home = user_home() / ".dsh"
    patch = home / "profiles" / "desktop" / "cordis.patch.yml"
    if not patch.exists() and not remove:
        raise InstallError(f"{patch} not found: is DeepSeek Harness set up for this user?")
    hooks_path = projects.harbor_home() / "integrations" / "deepseek" / "hooks.json"
    args = cmd[1:] + identity_args(agent, project) + ["mcp"]
    env = {"HARBOR_AGENT": agent, "HARBOR_HOST": "deepseek", **({"HARBOR_PROJECT": project} if project else {})}
    q = lambda s: "'" + str(s).replace("'", "''") + "'"
    block = ("# Managed by `harbor install deepseek`: Harbor's MCP tools and hooks.\n- insert:\n"
             "    - id: mcp-harbor\n      name: '@deepseek-ai/dsh-mcp-client'\n      config:\n"
             f"        serverName: harbor\n        transport: stdio\n        command: {q(cmd[0])}\n"
             f"        args: [{', '.join(q(a) for a in args)}]\n"
             f"        env: {{{', '.join(f'{k}: {q(v)}' for k, v in env.items())}}}\n"
             "        toolCallTimeoutMs: 1900000\n"
             "    - id: hooks-harbor\n      name: '@deepseek-ai/dsh-hooks-claude-code'\n      config:\n"
             f"        configPath: {q(hooks_path.as_posix())}\n        defaultTimeoutMs: 30000\n")
    text = replace_block(_read(patch), None if remove else block)
    plan.write(patch, text if text.strip() else "[]\n", validate=_TolerantLoader.load)
    if remove:
        plan.remove(hooks_path) if hooks_path.exists() else None
    else:
        ours = _hook_entries(cmd, agent, project, "deepseek", ("SessionStart", "UserPromptSubmit", "PreToolUse", "Stop"))
        plan.write(hooks_path, json.dumps({"hooks": ours}, indent=2) + "\n", validate=json.loads)
    plan.write(home / "AGENTS.md", _md_block(home / "AGENTS.md", agents_section(agent, project, cmd), remove))
    if not remove:
        plan.notes.append("DeepSeek Harness: the MCP tools hot-reload; restart the app once to load the hooks file.")


def kimi_share():
    return Path(os.environ.get("KIMI_SHARE_DIR") or Path(os.environ.get("APPDATA", user_home())) / "kimi-desktop" / "daimon-share")


def install_kimi(plan, agent, project, cmd, remove):
    if not project:
        project = projects.resolve().name
    folder = projects.harbor_home() / "integrations" / "kimi" / f"harbor-{project}"
    name = f"harbor-{project}"
    if remove:
        for path in sorted(folder.rglob("*"), reverse=True) if folder.exists() else []:
            if path.is_file():
                plan.remove(path)
        plan.notes.append(f"Kimi: uninstall '{name}' from Plugins > Personal in Kimi as well.")
        return
    base = " ".join(cmd + identity_args(agent, project) + ["hook"])
    title = projects.load_named(project).title
    manifest = {
        "$schema": "https://catalog.msh.team/misc/kimi.plugin.schema.json",
        "name": name, "version": "1.3.0",
        "description": f"Connects Kimi to the Harbor team hub for {title}: messages, acknowledgements, claims, the "
                       "review queue and the stop switch shared with the other agents.",
        "keywords": ["harbor", "team", "coordination"], "author": "Harbor", "license": "MIT",
        "skillInstructions": "Use the Harbor tools for all team communication on this project.",
        "interface": {
            "displayName": f"Harbor: {title}", "shortDescription": f"Team coordination for {title}",
            "longDescription": f"Harbor tools, session brief, stop gate and message nudges for {title}.",
            "developerName": "Harbor", "websiteURL": "", "iconUrl": "", "category": "PRODUCTIVITY",
            "defaultLocale": "en-US", "locales": "./locales/",
            "tryPrompts": ["Check Harbor for messages", "What is the team doing right now?"],
            "skillOverrides": {name: {"displayName": f"Harbor: {title}", "description": f"Team coordination for {title}"}},
            "hostKind": "local", "platforms": ["windows", "macos", "linux"],
            "mcpOverrides": {"harbor": {"displayName": "Harbor", "description": f"Team coordination for {title}"}},
        },
        "skills": "./skills/",
        "mcpServers": {"harbor": {"command": cmd[0], "args": cmd[1:] + identity_args(agent, project) + ["mcp"],
                                  "env": {"HARBOR_AGENT": agent, "HARBOR_PROJECT": project, "HARBOR_HOST": "kimi"},
                                  "toolTimeoutMs": 1900000}},
        "systemPromptPath": "./system-prompt.md",
        "hooks": [
            {"event": "UserPromptSubmit", "command": f"{base} prompt-submit --host kimi", "timeout": 30},
            {"event": "PreToolUse", "command": f"{base} pre-tool --host kimi", "timeout": 30},
            {"event": "Stop", "command": f"{base} stop --host kimi", "timeout": 30},
        ],
    }
    zh = {"description": f"把 Kimi 接入 {title} 的 Harbor 团队协作：消息、确认、认领、评审队列和暂停开关。",
          "interface": {"displayName": f"Harbor：{title}", "shortDescription": f"{title} 的团队协作",
                        "longDescription": f"{title} 的 Harbor 工具、会话简报、暂停闸门和消息提醒。",
                        "tryPrompts": ["查看 Harbor 消息", "团队现在在做什么？"],
                        "skillOverrides": {name: {"displayName": f"Harbor：{title}", "description": f"{title} 的团队协作"}},
                        "mcpOverrides": {"harbor": {"displayName": "Harbor", "description": f"{title} 的团队协作"}}}}
    plan.write(folder / "kimi.plugin.json", json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", validate=json.loads)
    plan.write(folder / "locales" / "zh-CN.json", json.dumps(zh, indent=2, ensure_ascii=False) + "\n", validate=json.loads)
    plan.write(folder / "system-prompt.md", agents_section(agent, project, cmd))
    plan.write(folder / "skills" / name / "SKILL.md",
               f"---\nname: {name}\ndescription: Team coordination for {title} through Harbor (messages, claims, "
               "review queue, stop switch). Use at the start of every session and whenever you talk to the team.\n---\n\n"
               + agents_section(agent, project, cmd))
    plan.notes.append(f"Kimi: plugin folder {folder}. After it is registered, install it from Kimi's Plugins > "
                      "Personal tab (Kimi asks you to review plugins that carry hooks).")
    plan.kimi_folder = folder


def kimi_register(folder, dry_run):
    scripts = kimi_share() / "daimon" / "skills" / "plugin-builder" / "scripts"
    daimon = Path(os.environ.get("APPDATA", "")) / "kimi-desktop" / "daimon-bundle" / "bin" / "kimi-daimon.cmd"
    if not (scripts / "register_personal.py").exists() or not daimon.exists():
        return "Kimi: its plugin tools were not found; ask Kimi to register the plugin folder (plugin-builder skill)."
    validate = subprocess.run([sys.executable, str(scripts / "validate_plugin.py"), str(folder)], capture_output=True,
                              text=True, encoding="utf-8", errors="replace")
    errors = [line for line in validate.stdout.splitlines() + validate.stderr.splitlines() if "[ERROR]" in line]
    if errors:
        return "Kimi validation failed:\n  " + "\n  ".join(errors)
    if dry_run:
        return "Kimi: plugin validates; a real run registers it in the Personal market."
    r = subprocess.run([sys.executable, str(scripts / "register_personal.py"), "--share-dir", str(kimi_share()),
                        "--daimon-bin", str(daimon), str(folder)], capture_output=True, text=True, encoding="utf-8",
                       errors="replace")
    return ("Kimi: registered in the Personal market. " if r.returncode == 0 else
            f"Kimi registration failed (exit {r.returncode}): ") + (r.stdout.strip() or r.stderr.strip())[-600:]


def install_claude(plan, agent, project, cmd, remove):
    """A local Claude Code marketplace holding the Harbor plugin (MCP server, hooks, skill)."""
    market = projects.harbor_home() / "integrations" / "claude"
    plugin = market / "harbor"
    if remove:
        for path in sorted(market.rglob("*"), reverse=True) if market.exists() else []:
            if path.is_file():
                plan.remove(path)
        plan.notes.append("Claude Code: also run `/plugin uninstall harbor@harbor-local`.")
        return
    ident = ["--project", project] if project else []
    base = " ".join(cmd + ident + ["hook"])
    hooks = {event: [{"hooks": [{"type": "command", "command": f"{base} {name} --host claude", "timeout": 30}]}]
             for event, name in (("SessionStart", "session-start"), ("UserPromptSubmit", "prompt-submit"),
                                 ("PreToolUse", "pre-tool"), ("Stop", "stop"))}
    dump = lambda value: json.dumps(value, indent=2) + "\n"
    plan.write(market / ".claude-plugin" / "marketplace.json", dump({
        "name": "harbor-local", "owner": {"name": "Harbor"},
        "plugins": [{"name": "harbor", "source": "./harbor",
                     "description": "Harbor team coordination: MCP tools, session brief, stop gate, message nudges"}]}),
        validate=json.loads)
    plan.write(plugin / ".claude-plugin" / "plugin.json", dump({
        "name": "harbor", "version": "2.0.0", "author": {"name": "Harbor"},
        "description": "Harbor team coordination: MCP tools, session brief, stop gate and message nudges. The agent "
                       "identity comes from the HARBOR_AGENT environment variable."}), validate=json.loads)
    plan.write(plugin / "hooks" / "hooks.json", dump({"hooks": hooks}), validate=json.loads)
    env = {"HARBOR_AGENT": "${HARBOR_AGENT:-" + agent + "}", "HARBOR_HOST": "claude",
           **({"HARBOR_PROJECT": project} if project else {})}
    plan.write(plugin / ".mcp.json", dump({"mcpServers": {"harbor": {"command": cmd[0], "args": cmd[1:] + ident + ["mcp"],
                                                                     "env": env}}}), validate=json.loads)
    plan.write(plugin / "skills" / "harbor" / "SKILL.md",
               "---\nname: harbor\ndescription: Team coordination through Harbor (messages, claims, review queue, "
               "stop switch). Use at the start of a session in a Harbor project and whenever you talk to the team.\n"
               "---\n\n" + agents_section("the agent named by HARBOR_AGENT", project, cmd))
    settings = json.dumps({"env": {"HARBOR_AGENT": agent}})
    plan.notes.append(f"Claude Code: run `/plugin marketplace add {market.as_posix()}` then `/plugin install "
                      f"harbor@harbor-local`, and set HARBOR_AGENT for the session, for example {settings} in "
                      ".claude/settings.json.")


def install(host, agent=None, project=None, dry_run=False, remove=False, python=None, register=True):
    if host not in HOSTS:
        raise InstallError(f"host must be one of {', '.join(HOSTS)}")
    agent = agent or DEFAULT_AGENT[host]
    if project:
        p = projects.load_named(project)
    else:
        try:
            p = projects.resolve()
        except projects.ProjectError:
            p = None
    if p and agent not in p.ai_names and not remove:      # an agent that left the roster can still be uninstalled
        raise InstallError(f"{agent} is not an agent of project {p.name} ({', '.join(p.ai_names)})")
    cmd = launcher(python)
    plan = Plan(host, dry_run)
    {"codex": install_codex, "opencode": install_opencode, "deepseek": install_deepseek, "kimi": install_kimi,
     "claude": install_claude}[host](plan, agent, project, cmd, remove)
    report = plan.apply()
    if host == "kimi" and not remove and getattr(plan, "kimi_folder", None):
        if dry_run:
            report.append("Kimi: a real run validates the plugin with Kimi's validator and registers it.")
        elif register:
            report.append(kimi_register(plan.kimi_folder, dry_run))
    return report