# modules/docs_site/docs_site.py
import json
import threading
import traceback
import os
import re
import time
import importlib
from pathlib import Path
from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
from urllib.parse import urlparse
from typing import Any, Dict, List, Optional, Tuple

import discord
from discord.ext import commands
from discord import app_commands

from modules.common.settings import cfg

_START_TS = time.time()

# =============================
# Safe JSON helpers
# =============================

_PRIMITIVES = (str, int, float, bool, type(None))

def _to_primitive(obj: Any, depth: int = 0) -> Any:
    if depth > 6:
        return str(obj)
    if isinstance(obj, _PRIMITIVES):
        return obj
    if isinstance(obj, (list, tuple, set)):
        return [_to_primitive(x, depth + 1) for x in obj]
    if isinstance(obj, dict):
        out = {}
        for k, v in obj.items():
            try:
                out[str(k)] = _to_primitive(v, depth + 1)
            except Exception:
                out[str(k)] = str(v)
        return out
    if hasattr(obj, "value"):
        try:
            return _to_primitive(getattr(obj, "value"), depth + 1)
        except Exception:
            pass
    return str(obj)

def _json_dumps_safe(payload: Any) -> bytes:
    return json.dumps(_to_primitive(payload), ensure_ascii=False, separators=(",", ":")).encode("utf-8")


# =============================
# Version / uptime helpers
# =============================

def _project_root() -> Path:
    return Path(__file__).resolve().parents[2]

def _read_version_from_file() -> Optional[str]:
    """Strictly parse VERSION from bot.py:  VERSION = "x.y.z"."""
    try:
        bot_py = _project_root() / "bot.py"
        if not bot_py.is_file():
            return None
        text = bot_py.read_text(encoding="utf-8", errors="ignore")
        m = re.search(r'^\s*VERSION\s*=\s*["\']([^"\']+)["\']', text, re.M)
        if m:
            return m.group(1)
    except Exception:
        traceback.print_exc()
    return None

def _get_version_from_botpy() -> Optional[str]:
    try:
        m = importlib.import_module("bot")
        v = getattr(m, "VERSION", None)
        if isinstance(v, (str, int, float)):
            return str(v)
    except Exception:
        pass
    return None

def _get_boot_state(bot: commands.Bot) -> Dict[str, Any]:
    dm = getattr(bot, "data_manager", None)
    if dm and dm.get("boot_state"):
        try:
            return (dm.get("boot_state") or [{}])[-1]
        except Exception:
            return {}
    return {}

def _status_payload(bot: commands.Bot) -> Dict[str, Any]:
    st = _get_boot_state(bot)
    now = time.time()
    boot_ts = float(st.get("last_boot_ts", 0.0)) if st else 0.0
    if boot_ts > 0:
        uptime = max(0, int(now - boot_ts))
    else:
        uptime = max(0, int(now - _START_TS))

    ver = st.get("last_version") if st else None
    if not ver:
        ver = _read_version_from_file() or _get_version_from_botpy() or os.getenv("SHAI_VERSION", "unknown")
    return {"uptime_seconds": uptime, "version": str(ver)}


# =============================
# Mod detection (heuristics)
# =============================

def _looks_like_mod_check(fn) -> bool:
    try:
        qn = getattr(fn, "__qualname__", "") or ""
        mod_names = (
            "is_moderator_member",
            "is_moderator_userid",
            "require_mod_ctx",
            "require_mod_interaction",
        )
        if any(m in qn for m in mod_names):
            return True
        mod = getattr(fn, "__module__", "") or ""
        if "mod_perms" in mod:
            return True
    except Exception:
        pass
    return False

def _is_perm_check(fn) -> Tuple[bool, List[str]]:
    perms = []
    try:
        code = getattr(fn, "__code__", None)
        if code and code.co_freevars and getattr(fn, "__closure__", None):
            for cell in fn.__closure__ or []:
                val = getattr(cell, "cell_contents", None)
                if isinstance(val, dict):
                    for k, v in val.items():
                        if v:
                            perms.append(str(k))
    except Exception:
        pass
    return (len(perms) > 0), perms


# =============================
# Introspection
# =============================

def _bot_prefix(bot: commands.Bot) -> str:
    p = getattr(bot, "command_prefix", "!")
    try:
        if callable(p):
            val = p(bot, None)
            if isinstance(val, (list, tuple)) and val:
                return str(val[0])
            return str(val)
        return str(p)
    except Exception:
        return "!"

def _is_mod_command_prefix(cmd: commands.Command) -> Tuple[bool, List[str]]:
    is_mod = False
    perms: List[str] = []
    try:
        for chk in getattr(cmd, "checks", []) or []:
            if _looks_like_mod_check(chk):
                is_mod = True
            p_flag, p_list = _is_perm_check(chk)
            if p_flag:
                perms.extend(p_list)
    except Exception:
        pass
    return is_mod, sorted(set(perms))

def _is_mod_command_slash(cmd: app_commands.Command) -> Tuple[bool, List[str]]:
    is_mod = False
    try:
        for chk in getattr(cmd, "checks", []) or []:
            if _looks_like_mod_check(chk):
                is_mod = True
        for chk in getattr(cmd, "_checks", []) or []:
            if _looks_like_mod_check(chk):
                is_mod = True
    except Exception:
        pass
    return is_mod, []

def _command_usage_prefix(cmd: commands.Command, prefix: str) -> str:
    if cmd.usage:
        return cmd.usage
    try:
        params = []
        for k, p in (cmd.clean_params or {}).items():
            if getattr(p, "kind", None) and str(p.kind).lower().startswith("var"):
                params.append(f"[{k}...]")
            elif p.default is p.empty:
                params.append(f"<{k}>")
            else:
                params.append(f"[{k}]")
        return f"{prefix}{cmd.qualified_name}" + ((" " + " ".join(params)) if params else "")
    except Exception:
        return f"{prefix}{cmd.name}"

def _command_usage_slash_like(cmd_name: str, options: Optional[List[Any]] = None) -> str:
    try:
        parts = [f"/{cmd_name}"]
        opts = []
        seq = options or []
        for opt in seq:
            n = getattr(opt, "name", None) or getattr(opt, "display_name", None) or "arg"
            req = bool(getattr(opt, "required", False))
            opts.append(f"<{n}>" if req else f"[{n}]")
        if opts:
            parts.append(" " + " ".join(opts))
        return "".join(parts)
    except Exception:
        return f"/{cmd_name}"

def _command_usage_slash(cmd: app_commands.Command) -> str:
    try:
        options = getattr(cmd, "options", None) or getattr(cmd, "parameters", None) or getattr(cmd, "_params", None)
        return _command_usage_slash_like((cmd.name or "").replace("/", " "), options)
    except Exception:
        return f"/{cmd.name}"

def _iter_all_app_commands(bot: commands.Bot):
    """Yield (scope_tag, top_level_command) including global and per-guild trees."""
    out = []
    # Global
    try:
        for cmd in bot.tree.get_commands():
            out.append(("", cmd))
    except Exception:
        pass
    # Per-guild
    for g in list(getattr(bot, "guilds", []) or []):
        try:
            cmds = bot.tree.get_commands(guild=g)
        except TypeError:
            try:
                cmds = bot.tree.get_commands(guild=discord.Object(id=g.id))
            except Exception:
                cmds = []
        except Exception:
            cmds = []
        for cmd in cmds or []:
            out.append((str(g.id), cmd))
    return out

def _gather_prefix_and_hybrid(bot: commands.Bot) -> List[Dict[str, Any]]:
    rows: List[Dict[str, Any]] = []
    seen = set()
    prefix = _bot_prefix(bot)

    for cmd in getattr(bot, "commands", []) or []:
        try:
            if getattr(cmd, "hidden", False):
                continue
            is_hybrid = isinstance(cmd, commands.HybridCommand)
            ctype = "hybrid" if is_hybrid else "prefix"

            is_mod, perms = _is_mod_command_prefix(cmd)

            usage_slash = None
            if is_hybrid:
                try:
                    app_cmd = getattr(cmd, "app_command", None)
                    if isinstance(app_cmd, app_commands.Command):
                        usage_slash = _command_usage_slash(app_cmd)
                        s_mod, _ = _is_mod_command_slash(app_cmd)
                        if s_mod:
                            is_mod = True
                        desc = (getattr(app_cmd, "description", "") or "")
                        if "[mod]" in desc.lower():
                            is_mod = True
                except Exception:
                    pass

            usage_prefix = _command_usage_prefix(cmd, prefix)

            row = {
                "type": ctype,
                "name": cmd.qualified_name,
                "display_name": cmd.qualified_name,  # bare name
                "help": (cmd.help or "").strip(),
                "brief": (cmd.brief or "").strip(),
                "usage": usage_prefix if not is_hybrid else None,
                "usage_prefix": usage_prefix,
                "usage_slash": usage_slash,
                "cog": getattr(cmd.cog, "qualified_name", None) if getattr(cmd, "cog", None) else None,
                "module": getattr(getattr(cmd, "callback", None), "__module__", None),
                "moderator_only": bool(is_mod),
                "required_permissions": perms,
            }
            key = ("px", row["name"])
            if key not in seen:
                rows.append(row)
                seen.add(key)
        except Exception:
            traceback.print_exc()
            continue
    return rows

def _walk_app_tree(node: Any, prefix: str = "") -> List[Tuple[str, app_commands.Command]]:
    out: List[Tuple[str, app_commands.Command]] = []
    if isinstance(node, app_commands.Command):
        out.append((f"{prefix}/{node.name}", node))
        return out
    if isinstance(node, app_commands.Group):
        base = f"{prefix}/{node.name}"
        for sub in list(getattr(node, "commands", []) or []):
            out.extend(_walk_app_tree(sub, base))
    return out

def _safe_extras(obj: Any) -> Optional[Dict[str, Any]]:
    d = getattr(obj, "extras", None)
    if not d:
        return None
    if not isinstance(d, dict):
        return {"value": _to_primitive(d)}
    return _to_primitive(d)

def _gather_slash(bot: commands.Bot) -> List[Dict[str, Any]]:
    rows: List[Dict[str, Any]] = []
    collected: List[Tuple[str, app_commands.Command, str]] = []
    try:
        for scope, top in _iter_all_app_commands(bot):
            for path, leaf in _walk_app_tree(top, prefix=""):
                collected.append((scope, leaf, path))
    except Exception:
        traceback.print_exc()

    seen_paths = set()
    for scope, leaf, path in collected:
        try:
            canon = path.lstrip("/")  # power/restart
            if canon in seen_paths:
                continue
            seen_paths.add(canon)

            is_mod, perms = _is_mod_command_slash(leaf)
            binding = getattr(leaf, "binding", None)
            callback = getattr(leaf, "callback", None)

            display = canon.replace("/", " ")
            options = getattr(leaf, "options", None) or getattr(leaf, "parameters", None) or getattr(leaf, "_params", None)
            usage_full = _command_usage_slash_like(display, options)

            row = {
                "type": "slash",
                "name": "/" + canon,
                "display_name": "/" + display,
                "help": (getattr(leaf, "description", "") or "").strip(),
                "brief": "",
                "usage": usage_full,
                "usage_prefix": None,
                "usage_slash": usage_full,
                "cog": binding.__class__.__name__ if binding else None,
                "module": getattr(callback, "__module__", None) if callback else None,
                "moderator_only": bool(is_mod),
                "required_permissions": perms,
                "extras": _safe_extras(leaf),
                "dm_permission": getattr(leaf, "dm_permission", None),
            }
            rows.append(row)
        except Exception:
            traceback.print_exc()
            continue
    return rows


# =============================
# Details loader & master JSON
# =============================

_DETAILS_DIR = _project_root() / "assets" / "docs" / "commands"
_MASTER_PATH = _DETAILS_DIR / "__commands__.json"

_DOCS_CACHE: Dict[str, Any] = {"map": {}, "sig": ""}

def _row_key_candidates(row: Dict[str, Any]) -> List[str]:
    c = str(row.get("cog") or "").strip()
    if row.get("type") == "slash":
        base = str(row.get("name", "")).lstrip("/").split("/")[-1]
    else:
        base = str(row.get("name", "")).split(" ")[0]
    keys = []
    if c:
        keys.append(f"{c}.{base}")
    if row.get("type") == "slash":
        keys.append(str(row.get("name", "")).lstrip("/"))
    keys.append(base)
    return keys

def _scan_md_files() -> Dict[str, Dict[str, Any]]:
    out: Dict[str, Dict[str, Any]] = {}
    if not _DETAILS_DIR.is_dir():
        return out
    for p in _DETAILS_DIR.glob("*.md"):
        if p.name.startswith("_"):
            continue
        try:
            out[p.stem] = {"details_md": p.read_text(encoding="utf-8")}
        except Exception:
            traceback.print_exc()
            continue
    return out

def _load_master_json() -> Dict[str, Dict[str, Any]]:
    if not _MASTER_PATH.is_file():
        return {}
    try:
        raw_text = _MASTER_PATH.read_text(encoding="utf-8")
        if not raw_text.strip():
            return {}
        raw_any = json.loads(raw_text) or {}
        out: Dict[str, Dict[str, Any]] = {}
        for k, v in raw_any.items():
            if isinstance(v, dict):
                out[str(k)] = {kk: vv for kk, vv in v.items()}
        return out
    except Exception:
        traceback.print_exc()
        return {}

def _write_master_json(mapping: Dict[str, Dict[str, Any]]) -> None:
    try:
        _DETAILS_DIR.mkdir(parents=True, exist_ok=True)
        with _MASTER_PATH.open("w", encoding="utf-8") as f:
            json.dump(mapping, f, ensure_ascii=False, indent=2)
    except Exception:
        traceback.print_exc()

def _dir_signature() -> str:
    parts = []
    if _DETAILS_DIR.is_dir():
        for p in sorted(_DETAILS_DIR.glob("*")):
            try:
                parts.append(f"{p.name}:{int(p.stat().st_mtime)}")
            except Exception:
                continue
    try:
        if _MASTER_PATH.exists():
            parts.append(f"__master__:{int(_MASTER_PATH.stat().st_mtime)}")
    except Exception:
        pass
    return "|".join(parts)

def _load_external_docs() -> Dict[str, Dict[str, Any]]:
    sig = _dir_signature()
    if _DOCS_CACHE.get("sig") == sig:
        return _DOCS_CACHE["map"]

    master = _load_master_json()
    md_map = _scan_md_files()

    merged: Dict[str, Dict[str, Any]] = {k: dict(v) for k, v in master.items()}
    for k, v in md_map.items():
        if k not in merged:
            merged[k] = {}
        merged[k]["details_md"] = v.get("details_md", "")

    _write_master_json(merged)
    _DOCS_CACHE["map"] = merged
    _DOCS_CACHE["sig"] = sig
    return merged

def _augment_with_external_docs(rows: List[Dict[str, Any]]) -> None:
    mapping = _load_external_docs()
    for r in rows:
        if not r.get("details_md") and isinstance(r.get("extras"), dict):
            dm = r["extras"].get("details_md")
            if isinstance(dm, str) and dm.strip():
                r["details_md"] = dm
        if not r.get("details_md"):
            for key in _row_key_candidates(r):
                if key in mapping and isinstance(mapping[key], dict):
                    dm = mapping[key].get("details_md")
                    if isinstance(dm, str) and dm.strip():
                        r["details_md"] = dm
                        meta = {kk: vv for kk, vv in mapping[key].items() if kk != "details_md"}
                        if meta:
                            r["doc_meta"] = meta
                        break


# =============================
# Merge hybrids with their slash twins
# =============================

def _merge_hybrid_slash(rows: List[Dict[str, Any]]) -> None:
    idx_by_hybrid: Dict[Tuple[str, str], int] = {}
    for i, r in enumerate(rows):
        if r.get("type") == "hybrid":
            cog = (r.get("cog") or "").strip()
            base = str(r.get("name") or "").split(" ")[-1].lower()
            idx_by_hybrid[(cog, base)] = i

    to_remove: List[int] = []
    for i, r in enumerate(rows):
        if r.get("type") != "slash":
            continue
        base = str(r.get("name") or "").lstrip("/").split("/")[-1].lower()
        cog = (r.get("cog") or "").strip()
        key = (cog, base)
        hi = idx_by_hybrid.get(key)
        if hi is None:
            continue
        h = rows[hi]
        if not h.get("usage_slash") and r.get("usage_slash"):
            h["usage_slash"] = r["usage_slash"]
        if not h.get("help") and r.get("help"):
            h["help"] = r["help"]
        if r.get("moderator_only"):
            h["moderator_only"] = True
        if r.get("required_permissions"):
            h["required_permissions"] = sorted(set((h.get("required_permissions") or []) + r["required_permissions"]))
        if not h.get("extras") and r.get("extras"):
            h["extras"] = r["extras"]
        if r.get("details_md") and not h.get("details_md"):
            h["details_md"] = r["details_md"]
        to_remove.append(i)

    for i in sorted(to_remove, reverse=True):
        rows.pop(i)


# =============================
# Schema builder
# =============================

def build_command_schema(bot: commands.Bot) -> Dict[str, Any]:
    px = _gather_prefix_and_hybrid(bot)
    sl = _gather_slash(bot)
    all_rows = px + sl

    # Additional moderator checks & sanitization
    for row in all_rows:
        try:
            helptext = f"{row.get('help') or ''} {row.get('brief') or ''}"
            if "[mod]" in helptext.lower():
                row["moderator_only"] = True
        except Exception:
            pass
        if row.get("required_permissions"):
            row["moderator_only"] = True
        try:
            ex = row.get("extras") or {}
            if isinstance(ex, dict) and str(ex.get("category", "")).lower() in {"mod", "moderator", "staff"}:
                row["moderator_only"] = True
        except Exception:
            pass

    _augment_with_external_docs(all_rows)
    _merge_hybrid_slash(all_rows)

    mods = [r for r in all_rows if r.get("moderator_only")]
    users = [r for r in all_rows if not r.get("moderator_only")]

    return {
        "title": "ShaiWatcher Commands",
        "count": len(all_rows),
        "sections": {
            "user": users,
            "moderator": mods,
        },
        "all": all_rows,
    }


# =============================
# Static asset serving
# =============================

def _static_root() -> Path:
    return _project_root() / "assets" / "docs"

def _guess_mime(p: Path) -> str:
    ext = p.suffix.lower()
    return {
        ".svg": "image/svg+xml; charset=utf-8",
        ".png": "image/png",
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".webp": "image/webp",
        ".gif": "image/gif",
        ".css": "text/css; charset=utf-8",
        ".js": "application/javascript; charset=utf-8",
        ".json": "application/json; charset=utf-8",
        ".md": "text/markdown; charset=utf-8",
        ".txt": "text/plain; charset=utf-8",
    }.get(ext, "application/octet-stream")


# =============================
# HTTP + UI
# =============================

_HTML = """<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width">
<title>__TITLE__</title>
<style>
  :root { --bg:#0b0f14; --panel:#121922; --muted:#6b7280; --fg:#e5e7eb; --accent:#60a5fa; --good:#34d399; --warn:#f59e0b; --sticky-top: 8px; --header-h: 56px; }
  * { box-sizing:border-box; font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Inter, Arial; }
  body { margin:0; background:var(--bg); color:var(--fg); }
  header { padding:16px 20px; background:#0f172a; border-bottom:1px solid #223; position:sticky; top:0; z-index:3; }
  header h1 { margin:0; font-size:20px; }
  main { max-width:1200px; margin:20px auto; padding:0 16px 40px; }
  .row { display:flex; gap:16px; flex-wrap:wrap; }
  .col { flex:1 1 560px; min-width:320px; }
  .panel { background:var(--panel); border:1px solid #1f2937; border-radius:12px; padding:16px; }
  .toolbar { margin-bottom:16px; position:sticky; top: var(--header-h); z-index:2; }
  .search { width:100%; padding:10px 12px; border-radius:8px; border:1px solid #1f2937; background:#0b1220; color:var(--fg); }
  .list { margin-top:12px; display:flex; flex-direction:column; gap:10px; transition: filter .2s ease; }
  .card { border:1px solid #233; border-radius:10px; padding:10px 12px; background:#0c1522; cursor:default; scroll-margin-top: calc(var(--sticky-top) + 12px); }
  .name { font-weight:600; display:flex; align-items:center; gap:8px; }
  .meta { font-size:12px; color:var(--muted); display:flex; gap:10px; flex-wrap:wrap; margin-top:4px; }
  .pill { display:inline-block; padding:2px 8px; border-radius:999px; font-size:12px; border:1px solid #2b4; }
  .pill.mod { border-color:#ef4444; color:#fecaca; }
  .pill.slash { border-color:#60a5fa; }
  .pill.prefix { border-color:#f59e0b; }
  .pill.hybrid { border-color:#34d399; }
  .usage { position:relative; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size:12px; background:#0a1220; border:1px dashed #1f2937; padding:6px 8px; border-radius:6px; margin-top:6px; word-break:break-word; }
  .help { margin-top:6px; color:#cbd5e1; }
  .btn { padding:4px 8px; border:1px solid #334155; border-radius:8px; background:#0b1220; color:#e5e7eb; cursor:pointer; font-size:12px; }
  .btn:hover { background:#0f172a; }
  .btn-icon { width:28px; height:28px; display:inline-flex; align-items:center; justify-content:center; padding:0; }
  .btn-row { display:flex; gap:8px; align-items:center; }
  .detailsbox { margin-top:12px; position: sticky; top: var(--sticky-top); min-height: 280px; z-index:1; transition: transform .25s ease; }
  .flag-emoji { height:1em; width:auto; vertical-align:-0.18em; border-radius:2px; display:inline-block; }
  footer { margin-top:16px; color:var(--muted); font-size:12px; text-align:center; }
  footer .line { margin:4px 0; }
  footer a { color: var(--fg); text-decoration: none; border-bottom: 1px dotted #334155; }
  footer a:hover { text-decoration: underline; }


  /* Copy modal */
  #copyModal { position: fixed; inset: 0; display:none; align-items:center; justify-content:center; z-index: 10; }
  #copyModal.open { display:flex; }
  #copyModal .overlay { position:absolute; inset:0; background:rgba(0,0,0,.4); }
  #copyModal .sheet { position:relative; z-index:1; min-width: min(520px, 92vw); background:var(--panel); border:1px solid #1f2937; border-radius:12px; padding:16px; box-shadow: 0 20px 60px rgba(0,0,0,.45); }
  #copyModal .close { position:absolute; right:10px; top:10px; }

  /* Copy button inside usage */
  .usage .copybtn { position:absolute; right:6px; top:6px; }
  @media (max-width: 900px) {
    .usage .copybtn { right:6px; top:6px; }
    .btn-icon { width:auto; padding:4px 10px; } /* larger tap target on mobile */
  }

  /* Blur veil under the toolbar */
  .veil {
    position: sticky;
    top: var(--header-h);
    height: var(--veil-h, 16px);
    pointer-events: none;
    z-index: 2;
    backdrop-filter: blur(4px);
    -webkit-backdrop-filter: blur(4px);
    mask-image: linear-gradient(to bottom, rgba(0,0,0,0), rgba(0,0,0,1));
    -webkit-mask-image: linear-gradient(to bottom, rgba(0,0,0,0), rgba(0,0,0,1));
  }

  /* Mobile sheet behavior */
  @media (max-width: 900px) {
    .row { display:block; }
    .detailsbox {
      position: fixed;
      right: 0; top: var(--sticky-top);
      width: 96vw; max-width: 720px;
      height: calc(100vh - var(--sticky-top) - 16px);
      overflow:auto;
      transform: translateX(100%);
      box-shadow: -12px 0 30px rgba(0,0,0,.4);
      z-index: 4;
    }
    .detailsbox.open { transform: translateX(0); }
    #backdrop {
      position: fixed; inset: var(--sticky-top) 0 0 0;
      background: rgba(0,0,0,.35);
      display:none; z-index:3;
    }
    #backdrop.open { display:block; }
    #list.blur { filter: blur(2px); }
    #backdrop::before {
      content: "‹";
      position:absolute; left: 10px; top: 50%;
      transform: translateY(-50%);
      font-size: 48px; line-height:1; color: #e5e7eb; opacity:.8;
    }
  }
</style>
</head>
<body>
<header><h1>__TITLE__</h1></header>
<main>
  <!-- Top toolbar -->
  <div class="panel toolbar" id="toolbar">
    <input id="q" class="search" placeholder="Search name/description…">
    <div style="margin-top:8px; font-size:12px; color:var(--muted)">
      Sections: <a href="#user">User</a> · <a href="#moderator">Moderator</a> · <a href="#all">All</a>
      <span id="counts" style="margin-left:10px"></span>
      <span id="alerts" style="margin-left:10px; color:#fbbf24"></span>
    </div>
  </div>

  <!-- Gradual blur veil under the toolbar -->
  <div class="veil" id="veil"></div>

  <div class="row">
    <!-- Left: command list -->
    <div class="col">
      <div id="list" class="list"></div>
    </div>

    <!-- Right: details panel (sticky / mobile sheet) -->
    <div class="col">
      <div class="panel detailsbox" id="details"></div>
    </div>
  </div>

<footer id="footer">
  <div class="line" id="copyright"></div>
  <div class="line" id="statusline">Uptime: — · Version: v—</div>
  <div class="line" id="coffee" style="display:__SUPPORT_VIS__">
    <a id="supportLink" href="__SUPPORT_URL__" target="_blank" rel="noopener noreferrer">__SUPPORT_LABEL__</a>
  </div>
</footer>

  <!-- Copy/share modal -->
  <div id="copyModal" aria-hidden="true">
    <div class="overlay" data-close="1"></div>
    <div class="sheet">
      <button class="btn btn-icon close" title="Close" data-close="1">✕</button>
      <div id="copyText" style="word-break:break-all; font-family: ui-monospace, monospace;"></div>
      <div style="margin-top:10px" class="btn-row">
        <button id="copyAction" class="btn">Copy</button>
        <span id="copyHint" style="font-size:12px;color:#9ca3af">Tap outside to dismiss.</span>
      </div>
    </div>
  </div>

  <div id="backdrop"></div>
</main>
<script>
function computeStickyTop() {
  const header = document.querySelector('header');
  const toolbar = document.getElementById('toolbar');
  const headerH = header ? header.offsetHeight : 0;
  const veilH = 16;
  document.documentElement.style.setProperty('--header-h', headerH + 'px');
  const toolbarH = toolbar ? toolbar.offsetHeight : 0;
  const stickyTop = headerH + toolbarH + 8;
  document.documentElement.style.setProperty('--sticky-top', stickyTop + 'px');
  const veil = document.getElementById('veil');
  if (veil) {
    veil.style.top = headerH + 'px';
    veil.style.height = veilH + 'px';
  }
}

window.addEventListener('resize', computeStickyTop);
window.addEventListener('load', computeStickyTop);

window.addEventListener('error', function(e){
  var list = document.getElementById('alerts');
  if (list) list.textContent = 'JS error: ' + (e && e.message);
});
window.addEventListener('unhandledrejection', function(e){
  var list = document.getElementById('alerts');
  var msg = e && (e.reason && (e.reason.message || e.reason) || e);
  if (list) list.textContent = 'Promise error: ' + msg;
});

// Minimal markdown renderer
function renderMD(src) {
  if (!src) return "";
  let s = String(src).replace(/\\r\\n/g, "\\n");
  s = s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
  s = s.replace(/```([\\s\\S]*?)```/g, (m, p1) => "<pre><code>" + p1 + "</code></pre>");
  s = s.replace(/^###\\s+(.*)$/gm, "<h3>$1</h3>");
  s = s.replace(/^##\\s+(.*)$/gm, "<h2>$1</h2>");
  s = s.replace(/^#\\s+(.*)$/gm, "<h1>$1</h1>");
  s = s.replace(/\\*\\*(.+?)\\*\\*/g, "<strong>$1</strong>");
  s = s.replace(/\\*(.+?)\\*/g, "<em>$1</em>");
  s = s.replace(/`([^`]+?)`/g, "<code>$1</code>");
  s = s.replace(/^(\\s*)-\\s+(.+)$/gm, "$1<li>$2</li>");
  s = s.replace(/(<li>.*<\\/li>\\n?)+/g, (m) => "<ul>" + m + "</ul>");
  s = s.replace(/^(?!<h\\d|<ul>|<pre>|<li>)([^\\n][^\\n]*)$/gm, "<p>$1</p>");
  return s;
}

// --------- Linking helpers ---------
function rowAnchor(r) {
  // Stable anchor: "<cog-or-nocog>-<path with slashes -> dashes>"
  const cog = (r.cog || 'nocog').toLowerCase();
  let base = (r.name || '').toLowerCase();
  base = base.replace(/^\\//, '');      // remove leading "/"
  base = base.replace(/\\s+/g, '-');    // spaces to dash
  base = base.replace(/\\//g, '-');     // slashes to dash
  return `${cog}-${base}`;
}
function getFilterFromHash() {
  const h = (location.hash || '#user').slice(1);
  // support legacy "cmd=" in hash too
  const parts = h.split('&').map(s => s.trim());
  const filt = parts.find(p => p === 'user' || p === 'moderator' || p === 'all') || 'user';
  let cmd = null;
  const cmdPart = parts.find(p => p.startsWith('cmd='));
  if (cmdPart) cmd = cmdPart.slice(4);
  // also check query
  const sp = new URLSearchParams(location.search);
  const qcmd = sp.get('cmd');
  if (!cmd && qcmd) cmd = qcmd;
  return { filter: filt, cmd };
}
function buildLink(anchor) {
  const url = new URL(window.location.href);
  url.searchParams.set('cmd', anchor);
  url.hash = location.hash || '#user';
  return url.toString();
}
function replaceURLFor(anchor) {
  try {
    const url = new URL(window.location.href);
    url.searchParams.set('cmd', anchor);
    history.replaceState(null, '', url.toString());
  } catch {}
}
async function copyText(s) {
  try {
    await navigator.clipboard.writeText(s);
    return true;
  } catch {
    return false;
  }
}
function openCopyModal(text) {
  const modal = document.getElementById('copyModal');
  const sheet = modal.querySelector('.sheet');
  document.getElementById('copyText').textContent = text;
  const action = document.getElementById('copyAction');
  const closeables = modal.querySelectorAll('[data-close]');
  const close = () => { modal.classList.remove('open'); action.onclick = null; closeables.forEach(el => el.onclick = null); };
  closeables.forEach(el => el.onclick = close);
  action.onclick = async () => { const ok = await copyText(text); if (ok) close(); };
  modal.classList.add('open');
}

// --------- App ---------
(function() {
  if (!location.hash) location.hash = '#user';
  let data = (window.__DATA__ || null);

  const listEl = document.getElementById('list');
  const qEl = document.getElementById('q');
  const countsEl = document.getElementById('counts');
  const detailsEl = document.getElementById('details');
  const backdrop = document.getElementById('backdrop');

  function shownName(r) {
    const n = (r.display_name || r.name || '');
    return n.replace(/^\\//, '');
  }
  function helpSansMod(r) {
    return (r.help || '').replace(/^\\s*\\[MOD\\]\\s*/i, '');
  }
  function moduleSansPrefix(r) {
    const m = r.module || '';
    return m.replace(/^modules?\./, '').replace(/^discord\.ext\./, '');
  }

  async function shareFor(r) {
    const anchor = rowAnchor(r);
    const url = buildLink(anchor);
    const ok = await copyText(url);
    if (!ok) openCopyModal(url);
  }

  function usageBlockHTML(text) {
    if (!text) return '';
    const esc = String(text).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
    return `
      <div class="usage">
        ${esc}
        <button class="btn btn-icon copybtn" title="Copy usage" data-copy="${esc}">📋</button>
      </div>
    `;
  }

  function wireUsageCopy(container) {
    container.querySelectorAll('[data-copy]').forEach(btn => {
      btn.addEventListener('click', async (ev) => {
        ev.stopPropagation();
        const t = btn.getAttribute('data-copy').replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&');
        const ok = await copyText(t);
        if (!ok) openCopyModal(t);
      });
    });
  }

  function openDetails(r) {
    const anchor = rowAnchor(r);
    replaceURLFor(anchor); // keep URL synced

    let html = `
      <div class="name" style="margin-bottom:6px">
        <span class="pill ${r.type}">${r.type}</span>
        ${r.moderator_only ? '<span class="pill mod">mod</span>' : ''}
        <span>${shownName(r)}</span>
        <span style="flex:1"></span>
        <div class="btn-row">
          <button class="btn btn-icon" title="Copy link" id="shareDetails">🔗</button>
          <button class="btn" id="closeDetails" style="display:none">Close</button>
        </div>
      </div>
      <div class="meta">
        ${r.cog ? `<span>cog: ${r.cog}</span>` : '' }
        ${r.module ? `<span>module: ${moduleSansPrefix(r)}</span>` : '' }
        ${r.required_permissions && r.required_permissions.length ? `<span>perms: ${r.required_permissions.join(', ')}</span>` : '' }
      </div>
      ${usageBlockHTML(r.usage_prefix)}
      ${usageBlockHTML(r.usage_slash)}
      ${helpSansMod(r) ? `<div class="help">${helpSansMod(r)}</div>` : ''}
    `;
    if (r.details_md) {
      html += `<div class="md" style="margin-top:10px">${renderMD(r.details_md)}</div>`;
    } else {
      html += `
        <div class="md" style="margin-top:10px">
          <p style="color:#9ca3af;font-size:14px;margin:0 0 6px 0">No custom documentation yet.</p>
          <details><summary>Extras</summary><pre style="white-space:pre-wrap">${r.extras ? JSON.stringify(r.extras, null, 2) : '—'}</pre></details>
        </div>
      `;
    }
    detailsEl.innerHTML = html;

    // Wire share + copy buttons
    const shareBtn = document.getElementById('shareDetails');
    if (shareBtn) shareBtn.onclick = (e) => { e.stopPropagation(); shareFor(r); };
    wireUsageCopy(detailsEl);

    // Mobile sheet open
    if (window.matchMedia('(max-width: 900px)').matches) {
      detailsEl.classList.add('open');
      listEl.classList.add('blur');
      backdrop.classList.add('open');
      const closeBtn = document.getElementById('closeDetails');
      if (closeBtn) closeBtn.style.display = 'inline-block';
      backdrop.onclick = closeDetails;
      closeBtn && (closeBtn.onclick = closeDetails);
    }
  }

  function closeDetails() {
    detailsEl.classList.remove('open');
    listEl.classList.remove('blur');
    backdrop.classList.remove('open');
  }

  function card(r) {
    const c = document.createElement('div');
    const anchor = rowAnchor(r);
    c.className = 'card';
    c.id = 'card-' + anchor;
    c.dataset.anchor = anchor;
    c.dataset.search = [shownName(r), helpSansMod(r), r.brief, r.usage, r.usage_prefix, r.usage_slash, r.cog, r.module, r.details_md || ""].join(' ').toLowerCase();

    const usageHTML = (r.type === 'hybrid')
      ? `${usageBlockHTML(r.usage_prefix)}${usageBlockHTML(r.usage_slash)}`
      : `${usageBlockHTML(r.usage)}`;

    c.innerHTML = `
      <div class="name">
        <span class="pill ${r.type}">${r.type}</span>
        ${r.moderator_only ? '<span class="pill mod">mod</span>' : ''}
        <span>${shownName(r)}</span>
        <div class="btn-row">
          <button class="btn btn-icon" title="Copy link" data-share="1">🔗</button>
          <button class="btn" data-details="1">Details</button>
        </div>
      </div>
      <div class="meta">
        ${r.cog ? `<span>cog: ${r.cog}</span>` : '' }
        ${r.module ? `<span>module: ${moduleSansPrefix(r)}</span>` : '' }
        ${r.required_permissions && r.required_permissions.length ? `<span>perms: ${r.required_permissions.join(', ')}</span>` : '' }
      </div>
      ${usageHTML}
      ${helpSansMod(r) ? `<div class="help">${helpSansMod(r)}</div>` : ''}
    `;

    c.querySelector('[data-details]').addEventListener('click', (ev) => {
      ev.stopPropagation();
      openDetails(r);
    });
    c.querySelector('[data-share]').addEventListener('click', async (ev) => {
      ev.stopPropagation();
      await shareFor(r);
    });
    c.addEventListener('click', () => openDetails(r));

    // Wire usage copy buttons within card
    wireUsageCopy(c);
    return c;
  }

  function render(target, rows) {
    target.innerHTML = '';
    rows.forEach(r => target.appendChild(card(r)));
  }

  function applyFilter(selectAnchorIfPresent=true) {
    if (!data) return;
    const all = data.all || [];
    const mods = (data.sections && data.sections.moderator) || [];
    const users = (data.sections && data.sections.user) || [];

    // Counts order: User · Moderator · Total
    const ct = `User: ${users.length} · Moderator: ${mods.length} · Total: ${all.length}`;
    countsEl.textContent = ct;

    const q = (qEl.value || '').toLowerCase();
    const { filter, cmd } = getFilterFromHash();
    const src = filter === 'moderator' ? mods : (filter === 'all' ? all : users);
    const rows = !q ? src : src.filter(r => (
      [shownName(r), helpSansMod(r), r.brief, r.usage, r.usage_prefix, r.usage_slash, r.cog, r.module, r.details_md || ""]
        .join(' ').toLowerCase().includes(q)
    ));
    render(listEl, rows);

    // Auto-select first or anchor target
    let sel = rows[0];
    if (selectAnchorIfPresent && cmd) {
      const hit = rows.find(r => rowAnchor(r) === cmd);
      if (hit) sel = hit;
      // Also scroll the specific card into view smoothly
      const cardEl = document.getElementById('card-' + cmd);
      if (cardEl) cardEl.scrollIntoView({behavior:'smooth', block:'start'});
    }
    if (sel) openDetails(sel);
  }

  async function boot() {
    computeStickyTop();
    try {
      if (!data) {
        const res = await fetch('/api/commands', {cache: 'no-store'});
        if (!res.ok) throw new Error('HTTP ' + res.status);
        data = await res.json();
      }
      window.addEventListener('hashchange', () => applyFilter(false));
      qEl.addEventListener('input', () => applyFilter(false));
      applyFilter(true);
    } catch (e) {
      document.getElementById('alerts').textContent = 'Failed to load.';
    }

    // Footer
    const fromYear = 2025;
    const now = new Date();
    const flagSvg = '<img class="flag-emoji" alt="NO" src="/assets/docs/no.svg">';
    document.getElementById('copyright').innerHTML =
      `© OokamiKunTV ${fromYear}–${now.getFullYear()} — Made in ${flagSvg} with ❤️`;

    try {
      const s = await fetch('/api/status', {cache:'no-store'});
      if (s.ok) {
        const js = await s.json();
        document.getElementById('statusline').textContent =
          `Uptime: ${fmtDuration(js.uptime_seconds||0)} · Version: v${js.version||'unknown'}`;
      }
    } catch {}
  }

  function fmtDuration(s) {
    s = Math.max(0, Math.floor(+s||0));
    const d = Math.floor(s/86400); s%=86400;
    const h = Math.floor(s/3600); s%=3600;
    const m = Math.floor(s/60); const sec = s%60;
    const parts = [];
    if (d) parts.push(d+'d');
    if (h || d) parts.push(h+'h');
    if (m || h || d) parts.push(m+'m');
    parts.push(sec+'s');
    return parts.join(' ');
  }

  boot();
})();
</script>
</body>
</html>
"""

class _DocsHandler(BaseHTTPRequestHandler):
    bot: commands.Bot = None
    title: str = "ShaiWatcher Commands"
    force_ready: bool = False

    def _set(self, code=200, content_type="text/html; charset=utf-8"):
        self.send_response(code)
        self.send_header("Content-Type", content_type)
        self.send_header("Cache-Control", "no-store")
        self.end_headers()

    def log_message(self, fmt, *args):
        return

    def do_GET(self):
        try:
            ready = bool(self.force_ready) or (getattr(self, "bot", None) and self.bot.is_ready())
            if not ready:
                self._set(503, "text/plain; charset=utf-8")
                self.wfile.write(b"warming up")
                return

            path = urlparse(self.path).path

            # Serve static assets from /assets/docs/*
            if path.startswith("/assets/docs/"):
                try:
                    root = _static_root().resolve()
                    rel = path[len("/assets/docs/"):]
                    fs_path = (root / rel).resolve()
                    try:
                        if not fs_path.is_relative_to(root):
                            raise ValueError("outside root")
                    except AttributeError:
                        if str(root) not in str(fs_path):
                            raise ValueError("outside root")
                    if fs_path.is_file():
                        mime = _guess_mime(fs_path)
                        self.send_response(200)
                        self.send_header("Content-Type", mime)
                        self.send_header("Cache-Control", "public, max-age=86400, immutable")
                        self.end_headers()
                        with fs_path.open("rb") as f:
                            self.wfile.write(f.read())
                        return
                    self._set(404, "text/plain; charset=utf-8")
                    self.wfile.write(b"not found")
                    return
                except Exception:
                    traceback.print_exc()
                    self._set(500, "text/plain; charset=utf-8")
                    self.wfile.write(b"internal error")
                    return

            if path == "/":
                self._set()
                html = _HTML.replace("__TITLE__", self.title)
                try:
                    schema = build_command_schema(self.bot)
                    inline = json.dumps(_to_primitive(schema), ensure_ascii=False, separators=(",", ":"))
                    html = html.replace("</head>", f"<script>window.__DATA__={inline};</script></head>")

                    # Inject support link + visibility
                    support_url = getattr(_DocsHandler, "support_url", "") or ""
                    support_label = getattr(_DocsHandler, "support_label", "Buy me a ☕")
                    vis = "block" if support_url else "none"

                    html = (html
                        .replace("__SUPPORT_URL__", support_url)
                        .replace("__SUPPORT_LABEL__", support_label)
                        .replace("__SUPPORT_VIS__", vis)
                    )

                    # Fallback to values stored on the cog (we’ll wire them below in _start_server)
                    support_url = support_url or getattr(_DocsHandler, "support_url", "")
                    support_label = support_label or getattr(_DocsHandler, "support_label", "Buy me a ☕")
                    vis = "block" if support_url else "none"

                    html = (html
                        .replace("__SUPPORT_URL__", support_url)
                        .replace("__SUPPORT_LABEL__", support_label)
                        .replace("__SUPPORT_VIS__", vis)
                    )
                except Exception:
                    traceback.print_exc()
                self.wfile.write(html.encode("utf-8"))
                return

            if path == "/api/status":
                payload = _status_payload(self.bot)
                self._set(200, "application/json; charset=utf-8")
                self.wfile.write(_json_dumps_safe(payload))
                return

            if path == "/healthz":
                self._set(200, "text/plain; charset=utf-8")
                self.wfile.write(b"ok")
                return

            if path == "/api/commands":
                schema = build_command_schema(self.bot)
                payload = _json_dumps_safe(schema)
                self._set(200, "application/json; charset=utf-8")
                self.wfile.write(payload)
                return

            self._set(404, "text/plain; charset=utf-8")
            self.wfile.write(b"not found")
        except Exception:
            traceback.print_exc()
            try:
                self._set(500, "text/plain; charset=utf-8")
                self.wfile.write(b"internal error")
            except Exception:
                pass

def _start_server(bot: commands.Bot, host: str, port: int, title: str):
    _DocsHandler.bot = bot
    _DocsHandler.title = title
    _DocsHandler.support_url = getattr(bot, "docs_support_url", None)
    _DocsHandler.support_label = getattr(bot, "docs_support_label", None)
    _DocsHandler.force_ready = os.getenv("SHAI_OFFLINE", "").lower() in {"1", "true", "yes"}
    httpd = ThreadingHTTPServer((host, port), _DocsHandler)

    def _run():
        try:
            httpd.serve_forever(poll_interval=0.5)
        except Exception:
            traceback.print_exc()

    t = threading.Thread(target=_run, name="DocsSite", daemon=True)
    t.start()
    print(f"[DocsSite] Listening on http://{host}:{port} (title='{title}', offline={_DocsHandler.force_ready})")

class DocsSite(commands.Cog):
    """Tiny Swagger-like docs site for bot commands."""

    def __init__(self, bot: commands.Bot):
        self.bot = bot
        r = cfg(bot)

        self.host = r.get("docs_host", "0.0.0.0")     # SHAI_DOCS_HOST
        self.port = r.int("docs_port", 8910)          # SHAI_DOCS_PORT
        self.title = r.get("docs_title", "ShaiWatcher Commands")  # SHAI_DOCS_TITLE

        # Support link config
        self.support_url = r.get("docs_support_url", "https://throne.com/ookamikuntv/item/39590391-c582-4c5d-8795-fe6f1925eaae")
        self.support_label = r.get("docs_support_label", "Buy me a ☕")

        # Expose to handler via bot (read in _start_server)
        self.bot.docs_support_url = self.support_url
        self.bot.docs_support_label = self.support_label

        _start_server(self.bot, self.host, self.port, self.title)

    def force_ready(self, value: bool = True):
        _DocsHandler.force_ready = bool(value)

async def setup(bot: commands.Bot):
    await bot.add_cog(DocsSite(bot))