#!/usr/bin/env python3
"""Static site server + a tiny /api/chat endpoint for the EY interview feed's question forum.

Zero dependencies (stdlib only). Serves ROOT like `python3 -m http.server`, plus:
  GET  /api/health  -> {"ok": true|false, "reason": ...}   ok only when an API key is configured
  POST /api/chat    -> {"text": "..."}   body: {rules, context, history:[{q,a}], question}

The key is read from ANTHROPIC_API_KEY or from ~/.config/ey-interview/anthropic.key (chmod 600).
Without a key the server still serves the site; /api/chat answers 503 {"error":"no_api_key"} and the
page shows "no model connected here". Binds to 0.0.0.0 by default so the LAN and tailnet reach it;
the chat endpoint itself only ever talks to api.anthropic.com.

Model: claude-opus-5 (thinking is adaptive by default on Opus 5; no thinking param is sent).
"""
import argparse, json, os, re, sys, urllib.request, urllib.error
from http.server import ThreadingHTTPServer, SimpleHTTPRequestHandler
from functools import partial

MODEL = "claude-opus-5"
API_URL = "https://api.anthropic.com/v1/messages"
KEY_FILE = os.path.expanduser("~/.config/ey-interview/anthropic.key")


def api_key():
    k = os.environ.get("ANTHROPIC_API_KEY", "").strip()
    if k:
        return k
    try:
        with open(KEY_FILE) as f:
            return f.read().strip()
    except OSError:
        return ""


def call_claude(rules, context, history, question):
    messages = [{"role": "user", "content": context}]
    for h in history or []:
        q, a = (h.get("q") or "").strip(), (h.get("a") or "").strip()
        if q and a:
            messages.append({"role": "user", "content": q})
            messages.append({"role": "assistant", "content": a})
    messages.append({"role": "user", "content": question})
    body = {
        "model": MODEL,
        "max_tokens": 6000,
        "system": [{"type": "text", "text": rules, "cache_control": {"type": "ephemeral"}}],
        "messages": messages,
    }
    req = urllib.request.Request(
        API_URL,
        data=json.dumps(body).encode("utf-8"),
        headers={
            "content-type": "application/json",
            "x-api-key": api_key(),
            "anthropic-version": "2023-06-01",
        },
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=180) as resp:
        data = json.loads(resp.read().decode("utf-8"))
    if data.get("stop_reason") == "refusal":
        return "Claude declined to answer this one."
    return "\n".join(b.get("text", "") for b in data.get("content", []) if b.get("type") == "text").strip()


class Handler(SimpleHTTPRequestHandler):
    def log_message(self, fmt, *args):  # quieter log, same format as http.server
        sys.stderr.write("%s - - [%s] %s\n" % (self.address_string(), self.log_date_time_string(), fmt % args))

    def _json(self, code, obj):
        payload = json.dumps(obj).encode("utf-8")
        self.send_response(code)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(payload)))
        self.send_header("Cache-Control", "no-store")
        self.end_headers()
        self.wfile.write(payload)

    def do_GET(self):
        path = self.path.split("?", 1)[0]
        if path.endswith("/api/health"):
            ok = bool(api_key())
            return self._json(200, {"ok": ok, "reason": None if ok else "no_api_key", "model": MODEL})
        if (self.headers.get("Range") or "").startswith("bytes="):
            return self._range(path, self.headers["Range"])
        return super().do_GET()

    def _range(self, path, rng):
        """Byte-range GET for audio/video: Safari will not play media from a server that cannot answer 206."""
        fpath = self.translate_path(path)
        if not os.path.isfile(fpath):
            return self.send_error(404)
        size = os.path.getsize(fpath)
        m = re.match(r"bytes=(\d*)-(\d*)$", rng)
        if not m or not (m.group(1) or m.group(2)):
            return self.send_error(416)
        start = int(m.group(1)) if m.group(1) else max(0, size - int(m.group(2)))
        end = min(int(m.group(2)), size - 1) if (m.group(1) and m.group(2)) else size - 1
        if start >= size or start > end:
            self.send_response(416)
            self.send_header("Content-Range", "bytes */%d" % size)
            self.end_headers()
            return
        self.send_response(206)
        self.send_header("Content-Type", self.guess_type(fpath))
        self.send_header("Content-Range", "bytes %d-%d/%d" % (start, end, size))
        self.send_header("Content-Length", str(end - start + 1))
        self.send_header("Accept-Ranges", "bytes")
        self.end_headers()
        with open(fpath, "rb") as f:
            f.seek(start)
            remaining = end - start + 1
            while remaining > 0:
                chunk = f.read(min(1 << 16, remaining))
                if not chunk:
                    break
                self.wfile.write(chunk)
                remaining -= len(chunk)

    def do_POST(self):
        path = self.path.split("?", 1)[0]
        if not path.endswith("/api/chat"):
            return self._json(404, {"error": "not_found"})
        # Requests that arrive through Tailscale Funnel (public internet) carry X-Forwarded-For but no
        # Tailscale identity header; tailnet users get Tailscale-User-Login. Never spend the API key for the public.
        if self.headers.get("X-Forwarded-For") and not self.headers.get("Tailscale-User-Login"):
            return self._json(403, {"error": "tailnet_only", "message": "Questions can only be asked from the tailnet, not the public URL."})
        if not api_key():
            return self._json(503, {"error": "no_api_key", "message": "The local server has no API key yet. Put one in ~/.config/ey-interview/anthropic.key or set ANTHROPIC_API_KEY."})
        try:
            n = int(self.headers.get("Content-Length") or 0)
            req = json.loads(self.rfile.read(n).decode("utf-8") or "{}")
            question = (req.get("question") or "").strip()
            if not question:
                return self._json(400, {"error": "bad_request", "message": "question is required"})
            text = call_claude(req.get("rules") or "", req.get("context") or "", req.get("history") or [], question)
            return self._json(200, {"text": text, "model": MODEL})
        except urllib.error.HTTPError as e:
            detail = e.read().decode("utf-8", "replace")[:400]
            return self._json(502, {"error": "upstream_%d" % e.code, "message": "Anthropic API returned %d: %s" % (e.code, detail)})
        except Exception as e:  # network, JSON, timeout
            return self._json(500, {"error": "server_error", "message": str(e)[:300]})


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--root", default=os.path.expanduser("~/sites"))
    ap.add_argument("--port", type=int, default=8731)
    ap.add_argument("--bind", default="0.0.0.0")
    a = ap.parse_args()
    handler = partial(Handler, directory=a.root)
    srv = ThreadingHTTPServer((a.bind, a.port), handler)
    sys.stderr.write("serving %s on %s:%d (chat %s)\n" % (a.root, a.bind, a.port, "enabled" if api_key() else "disabled: no API key"))
    srv.serve_forever()


if __name__ == "__main__":
    main()
