"""Minimal stdlib HTTP server for Alea-mini — Jev-shaped endpoint.

POST /v1/systemone  {state, questions} -> {model, answers{...}}
GET  /health

Usage:
  python -m alea.serve --ckpt runs/alea_v2/final.pt --port 8080
"""
import argparse
import json
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

import torch


def make_handler(model, tok, device):
    from .predict import answer

    class H(BaseHTTPRequestHandler):
        def _json(self, code, obj):
            body = json.dumps(obj).encode()
            self.send_response(code)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)

        def do_GET(self):
            if self.path == "/health":
                self._json(200, {"ok": True})
            else:
                self._json(404, {"error": "not found"})

        def do_POST(self):
            if self.path not in ("/v1/systemone", "/predict"):
                self._json(404, {"error": "not found"})
                return
            try:
                req = json.loads(self.rfile.read(
                    int(self.headers.get("Content-Length", 0))))
                t0 = time.time()
                out = answer(model, tok, req, device)
                out["elapsed_ms"] = round((time.time() - t0) * 1000, 1)
                self._json(200, out)
            except Exception as e:
                self._json(400, {"error": str(e)})

        def log_message(self, *a):
            pass

    return H


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt", required=True)
    ap.add_argument("--model", default="Qwen/Qwen3-0.6B")
    ap.add_argument("--port", type=int, default=8080)
    ap.add_argument("--host", default="127.0.0.1")
    args = ap.parse_args()

    from transformers import AutoTokenizer
    from .eval import load_model
    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    tok = AutoTokenizer.from_pretrained(args.model)
    model = load_model(args.ckpt, args.model, dev)
    print(f"serving on http://{args.host}:{args.port}  (POST /v1/systemone)")
    ThreadingHTTPServer((args.host, args.port),
                        make_handler(model, tok, dev)).serve_forever()


if __name__ == "__main__":
    main()