from __future__ import annotations

import argparse
import json
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

import torch
from peft import PeftModel

from .common import (
    append_response_ids,
    apply_chat_template,
    build_messages,
    infer_input_device,
    move_to_device,
    tokenizer_fingerprint,
)
from .losses import response_token_logps
from .modeling import load_base_model, load_processor


class TeacherState:
    def __init__(self, args: argparse.Namespace) -> None:
        self.model_path = args.model
        self.num_views = args.num_views
        self.max_length = args.max_length
        self.processor = load_processor(args.model)
        model = load_base_model(
            args.model, attn_implementation=args.attn_implementation
        )
        if args.adapter_path:
            model = PeftModel.from_pretrained(model, args.adapter_path, is_trainable=False)
        self.model = model.cuda().eval()
        self.device = infer_input_device(self.model)
        self.fingerprint = tokenizer_fingerprint(self.processor.tokenizer)
        self.lock = threading.Lock()

    def health(self) -> dict:
        return {
            "ok": True,
            "model": self.model_path,
            "num_views": self.num_views,
            "tokenizer_size": len(self.processor.tokenizer),
            "tokenizer_sha256": self.fingerprint,
        }

    def score(self, payload: dict) -> dict:
        response_list = payload.get("response_ids")
        if not isinstance(response_list, list) or not response_list:
            raise ValueError("response_ids must be a non-empty list")
        response_ids = torch.tensor(
            [response_list], dtype=torch.long, device=self.device
        )
        messages = build_messages(
            str(payload["question"]),
            dict(payload["image_paths"]),
            self.num_views,
        )
        prompt = apply_chat_template(
            self.processor,
            messages,
            add_generation_prompt=True,
            max_length=self.max_length,
        )
        prompt = move_to_device(prompt, self.device)
        batch, prompt_len = append_response_ids(prompt, response_ids)
        if batch["input_ids"].shape[1] > self.max_length:
            raise ValueError("prompt + response exceeds teacher max_length")
        with self.lock, torch.inference_mode():
            outputs = self.model(**batch, use_cache=False)
            logps = response_token_logps(outputs.logits, response_ids, prompt_len)
        return {
            "token_logps": logps[0].float().cpu().tolist(),
            "prompt_tokens": prompt_len,
            "response_tokens": int(response_ids.shape[1]),
        }


def handler_factory(state: TeacherState):
    class Handler(BaseHTTPRequestHandler):
        def _send(self, status: int, payload: dict) -> None:
            body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
            self.send_response(status)
            self.send_header("Content-Type", "application/json; charset=utf-8")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)

        def do_GET(self) -> None:
            if self.path == "/health":
                self._send(200, state.health())
            else:
                self._send(404, {"error": "not found"})

        def do_POST(self) -> None:
            if self.path != "/score":
                self._send(404, {"error": "not found"})
                return
            try:
                length = int(self.headers.get("Content-Length", "0"))
                if length <= 0 or length > 4 * 1024 * 1024:
                    raise ValueError("invalid request size")
                payload = json.loads(self.rfile.read(length))
                self._send(200, state.score(payload))
            except Exception as exc:
                self._send(400, {"error": f"{type(exc).__name__}: {exc}"})

        def log_message(self, fmt: str, *args) -> None:
            print(f"teacher_http {self.address_string()} {fmt % args}", flush=True)

    return Handler


def main() -> None:
    parser = argparse.ArgumentParser(description="Sampled-token OPD teacher server")
    parser.add_argument("--model", required=True)
    parser.add_argument("--adapter-path", default=None)
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=18080)
    parser.add_argument("--num-views", type=int, default=6)
    parser.add_argument("--max-length", type=int, default=4096)
    parser.add_argument("--attn-implementation", default="sdpa")
    args = parser.parse_args()
    state = TeacherState(args)
    print(json.dumps(state.health(), ensure_ascii=False), flush=True)
    server = ThreadingHTTPServer((args.host, args.port), handler_factory(state))
    server.serve_forever()


if __name__ == "__main__":
    main()