#!/usr/bin/env python3
"""arq-posthog — PostHog API adapter for ARQERA mesh.

v0 verbs:
  arq-posthog project list        — list projects (org-admin scope)
  arq-posthog event count [--days N]  — event count rollup
  arq-posthog insight list        — list saved insights
"""
from __future__ import annotations
import argparse, json, os, sys, urllib.request, urllib.error
from datetime import UTC, datetime, timedelta
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent))
from _arq_provider_base import sops_extract, call_with_audit, print_json, handle_meta_flags

PROVIDER = "posthog"
REQUIRED_SCOPES: dict[str, list[str]] = {
    # PostHog Personal-API-Key scopes (2024+ scoped keys).
    "project list": ["project:read"],
    "event count": ["query:read"],
    "insight list": ["insight:read"],
}
API_BASE = "https://us.i.posthog.com"


def _api_key() -> str | None:
    return (os.environ.get("POSTHOG_API_KEY") or
            sops_extract('["arqera_twin_admin"]["posthog"]["value"]') or
            sops_extract('["posthog"]["posthog_personal_api_key"]') or
            sops_extract('["posthog"]["posthog_api_key"]'))


def _api_get(path: str, params: dict | None = None) -> tuple[int, dict | str]:
    key = _api_key()
    if not key:
        return 401, "no posthog key in env/SOPS"
    if params:
        from urllib.parse import urlencode
        path = f"{path}?{urlencode(params)}"
    req = urllib.request.Request(f"{API_BASE}{path}", headers={"Authorization": f"Bearer {key}"})
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            return resp.status, json.loads(resp.read())
    except urllib.error.HTTPError as e:
        return e.code, e.read().decode("utf-8", errors="ignore")
    except Exception as e:
        return 500, str(e)


def _cmd_project_list(args) -> int:
    code, data = _api_get("/api/projects/")
    if code != 200:
        sys.stderr.write(f"HTTP {code}: {data}\n")
        return 1
    return print_json(data)


def _cmd_event_count(args) -> int:
    end = datetime.now(UTC).date()
    start = end - timedelta(days=args.days)
    # PostHog requires project-id; use first project as default
    proj_code, proj_data = _api_get("/api/projects/")
    if proj_code != 200:
        sys.stderr.write(f"projects/ HTTP {proj_code}: {proj_data}\n")
        return 1
    if not isinstance(proj_data, dict) or not proj_data.get("results"):
        sys.stderr.write("no projects found\n")
        return 1
    pid = proj_data["results"][0]["id"]
    code, data = _api_get(f"/api/projects/{pid}/events/", {"after": start.isoformat()})
    if code != 200:
        sys.stderr.write(f"HTTP {code}: {data}\n")
        return 1
    return print_json(data)


def _cmd_insight_list(args) -> int:
    proj_code, proj_data = _api_get("/api/projects/")
    if proj_code != 200:
        sys.stderr.write(f"projects/ HTTP {proj_code}: {proj_data}\n")
        return 1
    if not isinstance(proj_data, dict) or not proj_data.get("results"):
        sys.stderr.write("no projects found\n")
        return 1
    pid = proj_data["results"][0]["id"]
    code, data = _api_get(f"/api/projects/{pid}/insights/")
    if code != 200:
        sys.stderr.write(f"HTTP {code}: {data}\n")
        return 1
    return print_json(data)


def main() -> int:
    handle_meta_flags(PROVIDER, REQUIRED_SCOPES)
    p = argparse.ArgumentParser(prog="arq-posthog")
    sub = p.add_subparsers(dest="cmd", required=True)
    s_p = sub.add_parser("project"); s_p_sub = s_p.add_subparsers(dest="action", required=True)
    s_p_l = s_p_sub.add_parser("list"); s_p_l.set_defaults(func=_cmd_project_list, verb="project list")
    s_e = sub.add_parser("event"); s_e_sub = s_e.add_subparsers(dest="action", required=True)
    s_e_c = s_e_sub.add_parser("count"); s_e_c.add_argument("--days", type=int, default=30); s_e_c.set_defaults(func=_cmd_event_count, verb="event count")
    s_i = sub.add_parser("insight"); s_i_sub = s_i.add_subparsers(dest="action", required=True)
    s_i_l = s_i_sub.add_parser("list"); s_i_l.set_defaults(func=_cmd_insight_list, verb="insight list")
    args = p.parse_args()
    return call_with_audit(PROVIDER, args.verb, args.func, args)


if __name__ == "__main__":
    sys.exit(main())
