#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ZSGLPT Update-Agent（宿主机运行）

职责：
- 定期检查 Git 远端是否有新版本（写入 data/update/status.json）
- 接收后台写入的 data/update/request.json 请求（check/update）
- 执行 git reset --hard origin/<branch> + docker compose build/up
- 更新前备份数据库 data/app_data.db
- 写入 data/update/result.json 与 data/update/jobs/<job_id>.log

仅使用标准库，便于在宿主机直接运行。
"""

from __future__ import annotations

import argparse
import json
import os
import shutil
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Dict, Optional, Tuple


def ts_str() -> str:
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


def json_load(path: Path) -> Tuple[dict, Optional[str]]:
    try:
        with open(path, "r", encoding="utf-8") as f:
            return dict(json.load(f) or {}), None
    except FileNotFoundError:
        return {}, None
    except Exception as e:
        return {}, f"{type(e).__name__}: {e}"


def json_dump_atomic(path: Path, data: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(f"{path.suffix}.tmp.{os.getpid()}.{int(time.time() * 1000)}")
    with open(tmp, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2, sort_keys=True)
        f.flush()
        os.fsync(f.fileno())
    os.replace(tmp, path)


def sanitize_job_id(value: object) -> str:
    import re

    text = str(value or "").strip()
    if not text:
        return f"job_{uuid.uuid4().hex[:8]}"
    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,63}", text):
        return f"job_{uuid.uuid4().hex[:8]}"
    return text


def _run(cmd: list[str], *, cwd: Path, log_fp, env: Optional[dict] = None, check: bool = True) -> subprocess.CompletedProcess:
    log_fp.write(f"[{ts_str()}] $ {' '.join(cmd)}\n")
    log_fp.flush()
    merged_env = os.environ.copy()
    if env:
        merged_env.update(env)
    return subprocess.run(
        cmd,
        cwd=str(cwd),
        env=merged_env,
        stdout=log_fp,
        stderr=log_fp,
        text=True,
        check=check,
    )


def _git_rev_parse(ref: str, *, cwd: Path) -> str:
    out = subprocess.check_output(["git", "rev-parse", ref], cwd=str(cwd), text=True).strip()
    return out


def _git_is_dirty(*, cwd: Path) -> bool:
    out = subprocess.check_output(["git", "status", "--porcelain"], cwd=str(cwd), text=True)
    return bool(out.strip())


def _compose_cmd() -> list[str]:
    # 优先使用 docker compose（v2）
    try:
        subprocess.check_output(["docker", "compose", "version"], stderr=subprocess.STDOUT, text=True)
        return ["docker", "compose"]
    except Exception:
        return ["docker-compose"]


def _http_healthcheck(url: str, *, timeout: float = 5.0) -> Tuple[bool, str]:
    try:
        req = urllib.request.Request(url, headers={"User-Agent": "zsglpt-update-agent/1.0"})
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            code = int(getattr(resp, "status", 200) or 200)
            if 200 <= code < 400:
                return True, f"HTTP {code}"
            return False, f"HTTP {code}"
    except urllib.error.HTTPError as e:
        return False, f"HTTPError {e.code}"
    except Exception as e:
        return False, f"{type(e).__name__}: {e}"


@dataclass
class Paths:
    repo_dir: Path
    data_dir: Path
    update_dir: Path
    status_path: Path
    request_path: Path
    result_path: Path
    jobs_dir: Path


def build_paths(repo_dir: Path, data_dir: Optional[Path] = None) -> Paths:
    repo_dir = repo_dir.resolve()
    data_dir = (data_dir or (repo_dir / "data")).resolve()
    update_dir = data_dir / "update"
    return Paths(
        repo_dir=repo_dir,
        data_dir=data_dir,
        update_dir=update_dir,
        status_path=update_dir / "status.json",
        request_path=update_dir / "request.json",
        result_path=update_dir / "result.json",
        jobs_dir=update_dir / "jobs",
    )


def ensure_dirs(paths: Paths) -> None:
    paths.jobs_dir.mkdir(parents=True, exist_ok=True)


def check_updates(*, paths: Paths, branch: str, log_fp=None) -> dict:
    env = {"GIT_TERMINAL_PROMPT": "0"}
    err = ""
    local = ""
    remote = ""
    dirty = False
    try:
        if log_fp:
            _run(["git", "fetch", "origin", branch], cwd=paths.repo_dir, log_fp=log_fp, env=env)
        else:
            subprocess.run(["git", "fetch", "origin", branch], cwd=str(paths.repo_dir), env={**os.environ, **env}, check=True)
        local = _git_rev_parse("HEAD", cwd=paths.repo_dir)
        remote = _git_rev_parse(f"origin/{branch}", cwd=paths.repo_dir)
        dirty = _git_is_dirty(cwd=paths.repo_dir)
    except Exception as e:
        err = f"{type(e).__name__}: {e}"

    update_available = bool(local and remote and local != remote) if not err else False
    return {
        "branch": branch,
        "checked_at": ts_str(),
        "local_commit": local,
        "remote_commit": remote,
        "update_available": update_available,
        "dirty": dirty,
        "error": err,
    }


def backup_db(*, paths: Paths, log_fp, keep: int = 20) -> str:
    db_path = paths.data_dir / "app_data.db"
    backups_dir = paths.data_dir / "backups"
    backups_dir.mkdir(parents=True, exist_ok=True)
    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_path = backups_dir / f"app_data.db.{stamp}.bak"

    if db_path.exists():
        log_fp.write(f"[{ts_str()}] backup db: {db_path} -> {backup_path}\n")
        log_fp.flush()
        shutil.copy2(db_path, backup_path)
    else:
        log_fp.write(f"[{ts_str()}] backup skipped: db not found: {db_path}\n")
        log_fp.flush()

    # 简单保留策略：按文件名排序，保留最近 keep 个
    try:
        items = sorted([p for p in backups_dir.glob("app_data.db.*.bak") if p.is_file()], key=lambda p: p.name)
        if len(items) > keep:
            for p in items[: len(items) - keep]:
                try:
                    p.unlink()
                except Exception:
                    pass
    except Exception:
        pass

    return str(backup_path)


def write_result(paths: Paths, data: dict) -> None:
    json_dump_atomic(paths.result_path, data)


def consume_request(paths: Paths) -> Tuple[dict, Optional[str]]:
    data, err = json_load(paths.request_path)
    if err:
        # 避免解析失败导致死循环：将坏文件移走
        try:
            bad_name = f"request.bad.{datetime.now().strftime('%Y%m%d_%H%M%S')}.{uuid.uuid4().hex[:6]}.json"
            bad_path = paths.update_dir / bad_name
            paths.request_path.rename(bad_path)
        except Exception:
            try:
                paths.request_path.unlink(missing_ok=True)  # type: ignore[arg-type]
            except Exception:
                pass
        return {}, err
    if not data:
        return {}, None
    try:
        paths.request_path.unlink(missing_ok=True)  # type: ignore[arg-type]
    except Exception:
        try:
            os.remove(paths.request_path)
        except Exception:
            pass
    return data, None


def handle_update_job(*, paths: Paths, branch: str, health_url: str, job_id: str, requested_by: str) -> None:
    ensure_dirs(paths)
    log_path = paths.jobs_dir / f"{job_id}.log"
    with open(log_path, "a", encoding="utf-8") as log_fp:
        log_fp.write(f"[{ts_str()}] job start: {job_id}, branch={branch}, by={requested_by}\n")
        log_fp.flush()

        result: Dict[str, object] = {
            "job_id": job_id,
            "action": "update",
            "status": "running",
            "stage": "start",
            "message": "",
            "started_at": ts_str(),
            "finished_at": None,
            "duration_seconds": None,
            "requested_by": requested_by,
            "branch": branch,
            "from_commit": None,
            "to_commit": None,
            "backup_db": None,
            "health_url": health_url,
            "health_ok": None,
            "health_message": None,
            "error": "",
        }
        write_result(paths, result)

        start_ts = time.time()
        try:
            result["stage"] = "backup"
            result["message"] = "备份数据库"
            write_result(paths, result)
            result["backup_db"] = backup_db(paths=paths, log_fp=log_fp)

            result["stage"] = "git_fetch"
            result["message"] = "拉取远端代码"
            write_result(paths, result)
            _run(["git", "fetch", "origin", branch], cwd=paths.repo_dir, log_fp=log_fp, env={"GIT_TERMINAL_PROMPT": "0"})

            from_commit = _git_rev_parse("HEAD", cwd=paths.repo_dir)
            result["from_commit"] = from_commit

            result["stage"] = "git_reset"
            result["message"] = f"切换到 origin/{branch}"
            write_result(paths, result)
            _run(["git", "reset", "--hard", f"origin/{branch}"], cwd=paths.repo_dir, log_fp=log_fp, env={"GIT_TERMINAL_PROMPT": "0"})

            to_commit = _git_rev_parse("HEAD", cwd=paths.repo_dir)
            result["to_commit"] = to_commit

            compose = _compose_cmd()
            result["stage"] = "docker_build"
            result["message"] = "构建容器镜像"
            write_result(paths, result)
            _run([*compose, "build"], cwd=paths.repo_dir, log_fp=log_fp)

            result["stage"] = "docker_up"
            result["message"] = "重建并启动服务"
            write_result(paths, result)
            _run([*compose, "up", "-d", "--force-recreate"], cwd=paths.repo_dir, log_fp=log_fp)

            result["stage"] = "health_check"
            result["message"] = "健康检查"
            write_result(paths, result)

            ok = False
            health_msg = ""
            deadline = time.time() + 180
            while time.time() < deadline:
                ok, health_msg = _http_healthcheck(health_url, timeout=5.0)
                if ok:
                    break
                time.sleep(3)

            result["health_ok"] = ok
            result["health_message"] = health_msg
            if not ok:
                raise RuntimeError(f"healthcheck failed: {health_msg}")

            result["status"] = "success"
            result["stage"] = "done"
            result["message"] = "更新完成"
        except Exception as e:
            result["status"] = "failed"
            result["error"] = f"{type(e).__name__}: {e}"
            result["stage"] = result.get("stage") or "failed"
            result["message"] = "更新失败"
            log_fp.write(f"[{ts_str()}] ERROR: {result['error']}\n")
            log_fp.flush()
        finally:
            result["finished_at"] = ts_str()
            result["duration_seconds"] = int(time.time() - start_ts)
            write_result(paths, result)

            # 更新 status（成功/失败都尽量写一份最新状态）
            try:
                status = check_updates(paths=paths, branch=branch, log_fp=log_fp)
                json_dump_atomic(paths.status_path, status)
            except Exception:
                pass

            log_fp.write(f"[{ts_str()}] job end: {job_id}\n")
            log_fp.flush()


def handle_check_job(*, paths: Paths, branch: str, job_id: str, requested_by: str) -> None:
    ensure_dirs(paths)
    log_path = paths.jobs_dir / f"{job_id}.log"
    with open(log_path, "a", encoding="utf-8") as log_fp:
        log_fp.write(f"[{ts_str()}] job start: {job_id}, action=check, branch={branch}, by={requested_by}\n")
        log_fp.flush()
        status = check_updates(paths=paths, branch=branch, log_fp=log_fp)
        json_dump_atomic(paths.status_path, status)
        log_fp.write(f"[{ts_str()}] job end: {job_id}\n")
        log_fp.flush()


def main(argv: list[str]) -> int:
    parser = argparse.ArgumentParser(description="ZSGLPT Update-Agent (host)")
    parser.add_argument("--repo-dir", default=".", help="部署仓库目录（包含 docker-compose.yml）")
    parser.add_argument("--data-dir", default="", help="数据目录（默认 <repo>/data）")
    parser.add_argument("--branch", default="master", help="允许更新的分支名（默认 master）")
    parser.add_argument("--health-url", default="http://127.0.0.1:51232/", help="更新后健康检查URL")
    parser.add_argument("--check-interval-seconds", type=int, default=300, help="自动检查更新间隔（秒）")
    parser.add_argument("--poll-seconds", type=int, default=5, help="轮询 request.json 的间隔（秒）")
    args = parser.parse_args(argv)

    repo_dir = Path(args.repo_dir).resolve()
    if not (repo_dir / "docker-compose.yml").exists():
        print(f"[fatal] docker-compose.yml not found in {repo_dir}", file=sys.stderr)
        return 2
    if not (repo_dir / ".git").exists():
        print(f"[fatal] .git not found in {repo_dir} (need git repo)", file=sys.stderr)
        return 2

    data_dir = Path(args.data_dir).resolve() if args.data_dir else None
    paths = build_paths(repo_dir, data_dir=data_dir)
    ensure_dirs(paths)

    last_check_ts = 0.0
    check_interval = max(30, int(args.check_interval_seconds))
    poll_seconds = max(2, int(args.poll_seconds))
    branch = str(args.branch or "master").strip()
    health_url = str(args.health_url or "").strip()

    # 启动时先写一次状态，便于后台立即看到
    try:
        status = check_updates(paths=paths, branch=branch)
        json_dump_atomic(paths.status_path, status)
        last_check_ts = time.time()
    except Exception:
        pass

    while True:
        try:
            # 1) 优先处理 request
            req, err = consume_request(paths)
            if err:
                # request 文件损坏：写入 result 便于后台看到
                write_result(
                    paths,
                    {
                        "job_id": f"badreq_{uuid.uuid4().hex[:8]}",
                        "action": "unknown",
                        "status": "failed",
                        "stage": "parse_request",
                        "message": "request.json 解析失败",
                        "error": err,
                        "started_at": ts_str(),
                        "finished_at": ts_str(),
                    },
                )
            elif req:
                action = str(req.get("action") or "").strip().lower()
                job_id = sanitize_job_id(req.get("job_id"))
                requested_by = str(req.get("requested_by") or "")

                # 只允许固定分支，避免被注入/误操作
                if action not in ("check", "update"):
                    write_result(
                        paths,
                        {
                            "job_id": job_id,
                            "action": action,
                            "status": "failed",
                            "stage": "validate",
                            "message": "不支持的 action",
                            "error": f"unsupported action: {action}",
                            "started_at": ts_str(),
                            "finished_at": ts_str(),
                        },
                    )
                elif action == "check":
                    handle_check_job(paths=paths, branch=branch, job_id=job_id, requested_by=requested_by)
                else:
                    handle_update_job(
                        paths=paths,
                        branch=branch,
                        health_url=health_url,
                        job_id=job_id,
                        requested_by=requested_by,
                    )

                last_check_ts = time.time()

            # 2) 周期性 check
            now = time.time()
            if now - last_check_ts >= check_interval:
                try:
                    status = check_updates(paths=paths, branch=branch)
                    json_dump_atomic(paths.status_path, status)
                except Exception:
                    pass
                last_check_ts = now

            time.sleep(poll_seconds)
        except KeyboardInterrupt:
            return 0
        except Exception:
            time.sleep(2)


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1:]))