"""Compatibility helper for unified PRD Plugin hook configuration.

Host wiring stays installed. Enable/disable changes the persistent
``hooks.enabled`` master switch used by the shared dispatcher, so one operation
applies consistently to Claude, Codex, and OpenCode without rewriting manifests.

Usage:
  prd_hooks.py status            show whether hooks are enabled
  prd_hooks.py disable           turn all configured hook behavior off
  prd_hooks.py enable            turn all configured hook behavior on
"""

import argparse
import json
from pathlib import Path

import prd_config


def _settings_path(root):
    return Path(root) / ".claude" / "settings.json"


def _stash_path(root):
    return Path(root) / ".prd_plugin" / "local" / "claude-hooks.stash.json"


def _load(path):
    if path.is_file():
        try:
            return json.loads(path.read_text(encoding="utf-8-sig"))
        except Exception:
            return {}
    return {}


def _save(path, data):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")


def _has_hooks(settings):
    h = settings.get("hooks")
    return isinstance(h, dict) and len(h) > 0


def status(root="."):
    settings = _load(_settings_path(root))
    if not _config_path(root).is_file() and not _has_hooks(settings):
        return {"state": "none", "events": []}
    events = sorted(settings.get("hooks", {}).keys()) if _has_hooks(settings) else []
    try:
        enabled = prd_config.get(root, "hooks.enabled") is True
    except (KeyError, ValueError):
        enabled = _has_hooks(settings)
    return {"state": "enabled" if enabled else "disabled", "events": events,
            "control": "hooks.enabled"}


def disable(root="."):
    before = prd_config.get(root, "hooks.enabled")
    prd_config.disable(root, "hooks.enabled")
    return {"state": "disabled", "changed": before is not False,
            "control": "hooks.enabled"}


def enable(root="."):
    before = prd_config.get(root, "hooks.enabled")
    prd_config.enable(root, "hooks.enabled")
    return {"state": "enabled", "changed": before is not True,
            "control": "hooks.enabled"}


def _config_path(root):
    return Path(root) / ".prd_plugin" / "config.json"


def drift(root, value=None):
    """Show or toggle the on-Stop drift check (drift.monitoring.on_stop)."""
    path = _config_path(root)
    cfg = _load(path)
    mon = cfg.setdefault("drift", {}).setdefault("monitoring", {})
    if value in ("on", "off"):
        if value == "on":
            prd_config.enable(root, "drift.monitoring.enabled")
        prd_config.set_toggle(root, "drift.monitoring.on_stop", value == "on")
        cfg = _load(path)
        mon = cfg.setdefault("drift", {}).setdefault("monitoring", {})
        return {"changed": True, "on_stop": mon["on_stop"], "enabled": mon.get("enabled", False),
                "on_stop_validators": mon.get("on_stop_validators", [])}
    return {"changed": False, "on_stop": bool(mon.get("on_stop", False)),
            "on_stop_validators": mon.get("on_stop_validators", [])}


def drift_export(root, value=None):
    """Show or toggle the drift-event export to a committed/shared feed."""
    path = _config_path(root)
    cfg = _load(path)
    mon = cfg.setdefault("drift", {}).setdefault("monitoring", {})
    export = mon.setdefault("export", {})
    if value in ("on", "off"):
        prd_config.set_toggle(root, "drift.monitoring.export.enabled", value == "on")
        cfg = _load(path)
        mon = cfg.setdefault("drift", {}).setdefault("monitoring", {})
        export = mon.setdefault("export", {})
        return {"changed": True, "export_enabled": export["enabled"],
                "export_path": export.get("path", ".prd_plugin/drift/events.jsonl")}
    return {"changed": False, "export_enabled": bool(export.get("enabled", False)),
            "export_path": export.get("path", ".prd_plugin/drift/events.jsonl")}


def main(argv=None):
    parser = argparse.ArgumentParser(description="Enable/disable/show Claude Code hooks for PRD Plugin.")
    parser.add_argument("action", choices=("status", "enable", "disable", "drift"))
    parser.add_argument("value", nargs="?", default=None,
                        help="For 'drift': on | off | status | export")
    parser.add_argument("value2", nargs="?", default=None,
                        help="For 'drift export': on | off")
    parser.add_argument("--repo-root", default=".")
    args = parser.parse_args(argv)

    if args.action == "drift":
        if args.value == "export":
            result = drift_export(args.repo_root, args.value2 if args.value2 in ("on", "off") else None)
            print(json.dumps(result))
            print(f"Drift export is {'ON' if result['export_enabled'] else 'OFF'}"
                  + f" (path: {result['export_path']})"
                  + (". Takes effect next drift run." if result["changed"] else ""))
            return 0
        result = drift(args.repo_root, args.value if args.value in ("on", "off") else None)
        print(json.dumps(result))
        print(f"On-Stop drift check is {'ON' if result['on_stop'] else 'OFF'}"
              + (f" (validators: {', '.join(result['on_stop_validators'])})" if result["on_stop_validators"] else "")
              + (". Takes effect next session." if result["changed"] else ""))
        return 0

    result = {"status": status, "enable": enable, "disable": disable}[args.action](args.repo_root)
    print(json.dumps(result))
    if args.action != "status" and result.get("changed"):
        print(f"Hooks {result['state']}. Takes effect in the next Claude Code session.")
    elif args.action == "status":
        print(f"Hooks are {result['state']}" + (f" ({', '.join(result['events'])})" if result["events"] else ""))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())