# ============================================================
# 外部算法排产 Skill 注册表（moduleId: core-skills, 可重生 ✅）
# 桌面端：~/.aps/skills/<skill_id>/manifest.json（对标 Codex skills 目录）
# Web：server/data/skills/…；APS_SKILLS_PATH 仍可指向单文件 JSON（测试兼容）
# ============================================================
from __future__ import annotations

import json
import os
import shutil
import tempfile
import threading
from pathlib import Path
from typing import Any

import httpx
from pydantic import BaseModel, Field

_PATH_ENV = "APS_SKILLS_PATH"


class SkillManifest(BaseModel):
    skill_id: str
    name: str
    endpoint: str = "local://stub"
    auth: str = ""
    max_power: str = "P1"
    track: str = "flex"
    enabled: bool = True
    timeout_sec: float = 60.0
    description: str = ""
    golden_tests: list[str] = Field(default_factory=list)
    version: str = "1.0"
    capabilities: list[str] = Field(
        default_factory=lambda: ["flex_schedule"])
    ragScopes: list[str] = Field(default_factory=list)


def _default_skills() -> list[dict[str, Any]]:
    return [
        SkillManifest(
            skill_id="algo.stub",
            name="内置算法桩（演示）",
            endpoint="local://stub",
            track="flex",
            enabled=True,
            description="本地桩：把工序顺序串到能力池首台设备，供联调与黄金测试",
            golden_tests=["test_external_engine"],
            capabilities=["flex_schedule"],
            ragScopes=["process", "sop"],
        ).model_dump()
    ]


def _skills_root() -> Path:
    """Skill 根目录（目录化布局）。"""
    from server.aps_home import skills_dir
    return skills_dir()


class SkillRegistry:
    """外部算法 skill 清单：目录扫描 + 启停/健康检查。"""

    def __init__(self, path: str | None = None) -> None:
        # path：单文件 JSON（测试/旧配置）；None → ~/.aps/skills 目录布局
        self.legacy_file = path or os.environ.get(_PATH_ENV)
        self._lock = threading.Lock()
        self.health_history: dict[str, list[dict[str, Any]]] = {}
        self.skills: list[dict[str, Any]] = self._load()
        if not self.skills:
            self.skills = _default_skills()
            self._write_all()
        else:
            upgraded = False
            for s in self.skills:
                for key, default in (("version", "1.0"),
                                     ("capabilities", ["flex_schedule"]),
                                     ("ragScopes", [])):
                    if key not in s:
                        s[key] = default
                        upgraded = True
            if upgraded:
                self._write_all()

    def _load(self) -> list[dict[str, Any]]:
        if self.legacy_file:
            return self._load_legacy_file(Path(self.legacy_file))
        root = _skills_root()
        root.mkdir(parents=True, exist_ok=True)
        # 迁移：若仍有旧 skills.json，导入后可保留文件
        legacy = root.parent / "skills.json"
        if not any(root.iterdir()) and legacy.exists():
            items = self._load_legacy_file(legacy)
            for s in items:
                self._write_one(root, s)
            return items
        # 同层 server/data/skills.json（web 默认 data 根）
        flat = root.parent / "skills.json" if root.name == "skills" else None
        out: list[dict[str, Any]] = []
        for child in sorted(root.iterdir()):
            if not child.is_dir() or child.name.startswith("."):
                continue
            manifest = child / "manifest.json"
            if not manifest.exists():
                continue
            try:
                data = json.loads(manifest.read_text(encoding="utf-8"))
                if isinstance(data, dict) and data.get("skill_id"):
                    out.append(data)
            except (OSError, json.JSONDecodeError):
                continue
        if not out and flat and flat.exists():
            return self._load_legacy_file(flat)
        return out

    @staticmethod
    def _load_legacy_file(path: Path) -> list[dict[str, Any]]:
        try:
            with open(path, "r", encoding="utf-8") as f:
                return json.load(f).get("skills", [])
        except (FileNotFoundError, json.JSONDecodeError, OSError):
            return []

    @staticmethod
    def _write_one(root: Path, skill: dict[str, Any]) -> None:
        sid = skill.get("skill_id") or "unknown"
        folder = root / sid
        folder.mkdir(parents=True, exist_ok=True)
        path = folder / "manifest.json"
        fd, tmp = tempfile.mkstemp(dir=str(folder), suffix=".tmp")
        try:
            with os.fdopen(fd, "w", encoding="utf-8") as f:
                json.dump(skill, f, ensure_ascii=False, indent=2)
            os.replace(tmp, path)
        except BaseException:
            if os.path.exists(tmp):
                os.unlink(tmp)
            raise
        # 可选说明文件，便于人在资源管理器里阅读
        readme = folder / "README.md"
        if not readme.exists():
            readme.write_text(
                f"# {skill.get('name') or sid}\n\n"
                f"- id: `{sid}`\n"
                f"- endpoint: `{skill.get('endpoint')}`\n"
                f"- {skill.get('description') or ''}\n",
                encoding="utf-8",
            )

    def _write_all(self) -> None:
        if self.legacy_file:
            path = Path(self.legacy_file)
            path.parent.mkdir(parents=True, exist_ok=True)
            fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
            try:
                with os.fdopen(fd, "w", encoding="utf-8") as f:
                    json.dump({"skills": self.skills}, f, ensure_ascii=False, indent=1)
                os.replace(tmp, path)
            except BaseException:
                if os.path.exists(tmp):
                    os.unlink(tmp)
                raise
            return
        root = _skills_root()
        root.mkdir(parents=True, exist_ok=True)
        keep = {s["skill_id"] for s in self.skills}
        for s in self.skills:
            self._write_one(root, s)
        # 清理已删除的 skill 目录
        for child in root.iterdir():
            if child.is_dir() and child.name not in keep and not child.name.startswith("."):
                shutil.rmtree(child, ignore_errors=True)

    def list(self) -> list[dict[str, Any]]:
        return list(self.skills)

    def get(self, skill_id: str) -> dict[str, Any] | None:
        return next((s for s in self.skills if s["skill_id"] == skill_id), None)

    def get_enabled(self, skill_id: str | None = None, track: str | None = None) -> dict[str, Any] | None:
        if skill_id:
            s = self.get(skill_id)
            return s if s and s.get("enabled") else None
        for s in self.skills:
            if not s.get("enabled"):
                continue
            if track and s.get("track") != track:
                continue
            return s
        return None

    def upsert(self, manifest: dict[str, Any]) -> dict[str, Any]:
        m = SkillManifest(**manifest).model_dump()
        with self._lock:
            for i, s in enumerate(self.skills):
                if s["skill_id"] == m["skill_id"]:
                    self.skills[i] = m
                    self._write_all()
                    return m
            self.skills.append(m)
            self._write_all()
            return m

    def set_enabled(self, skill_id: str, enabled: bool) -> dict[str, Any]:
        with self._lock:
            s = self.get(skill_id)
            if not s:
                raise ValueError(f"未找到 skill：{skill_id}")
            s["enabled"] = bool(enabled)
            self._write_all()
            return dict(s)

    def health(self, skill_id: str | None = None) -> list[dict[str, Any]]:
        from datetime import datetime
        targets = [self.get(skill_id)] if skill_id else self.skills
        out = []
        for s in targets:
            if not s:
                continue
            status = self._probe(s)
            record = {"ts": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **status}
            hist = self.health_history.setdefault(s["skill_id"], [])
            hist.append(record)
            del hist[:-20]
            out.append({"skill_id": s["skill_id"], "name": s["name"],
                        "enabled": s.get("enabled"), "endpoint": s.get("endpoint"),
                        **status})
        return out

    def history(self, skill_id: str) -> list[dict[str, Any]]:
        return list(self.health_history.get(skill_id) or [])

    def _probe(self, s: dict[str, Any]) -> dict[str, Any]:
        ep = s.get("endpoint") or ""
        if ep.startswith("local://"):
            return {"ok": True, "latencyMs": 0, "detail": "local stub"}
        health_url = ep.rstrip("/") + "/health"
        try:
            headers = {}
            if s.get("auth"):
                headers["Authorization"] = f"Bearer {s['auth']}"
            with httpx.Client(timeout=5.0) as client:
                r = client.get(health_url, headers=headers)
                return {"ok": r.status_code < 400, "latencyMs": int(r.elapsed.total_seconds() * 1000),
                        "detail": f"HTTP {r.status_code}"}
        except Exception as exc:
            return {"ok": False, "latencyMs": None, "detail": str(exc)}


_registry: SkillRegistry | None = None


def get_skills() -> SkillRegistry:
    global _registry
    if _registry is None:
        _registry = SkillRegistry()
    return _registry


def reset_skills_registry() -> None:
    """测试用：丢弃单例，下次按当前环境变量重建。"""
    global _registry
    _registry = None