"""Small model adapter interface for PhyCAD-Bench."""

import json
import os
import socket
import urllib.error
import urllib.request
from dataclasses import dataclass
from typing import Protocol
from urllib.parse import urlsplit


class ModelRequestError(ValueError):
    """The model endpoint rejected a request or returned an invalid response."""


class ModelTimeoutError(TimeoutError):
    """The model did not answer within the configured time."""


@dataclass
class ModelResponse:
    text: str
    served_model: str | None = None
    response_id: str | None = None
    finish_reason: str | None = None
    usage: dict | None = None


class ModelAdapter(Protocol):
    def generate(self, model: str, messages: list[dict], settings: dict, timeout: int) -> ModelResponse:
        """Return one model answer for the given messages."""


class OpenAICompatibleAdapter:
    def __init__(self, base_url: str, api_key_env: str | None = None):
        parsed = urlsplit(base_url)
        if parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.query or parsed.fragment:
            raise ValueError("--base-url must be an HTTP(S) API base URL")
        self.base_url = base_url.rstrip("/")
        self.api_key_env = api_key_env
        self.api_key = None
        if api_key_env:
            self.api_key = os.environ.get(api_key_env)
            if not self.api_key:
                raise ValueError(f"Set {api_key_env} before running the model")

    def generate(self, model: str, messages: list[dict], settings: dict, timeout: int) -> ModelResponse:
        headers = {"Content-Type": "application/json"}
        if self.api_key:
            headers["Authorization"] = f"Bearer {self.api_key}"
        request = urllib.request.Request(
            self.base_url + "/chat/completions",
            data=json.dumps({"model": model, "messages": messages, **settings}).encode(),
            headers=headers,
            method="POST",
        )
        try:
            with urllib.request.urlopen(request, timeout=timeout) as response:
                completion = json.load(response)
        except urllib.error.HTTPError as exc:
            raise ModelRequestError(f"Model endpoint returned HTTP {exc.code}") from None
        except (socket.timeout, TimeoutError):
            raise ModelTimeoutError(f"Model request exceeded {timeout} seconds") from None
        except urllib.error.URLError as exc:
            if isinstance(exc.reason, TimeoutError):
                raise ModelTimeoutError(f"Model request exceeded {timeout} seconds") from None
            raise ModelRequestError(f"Could not reach model endpoint: {exc.reason}") from None
        except json.JSONDecodeError:
            raise ModelRequestError("Model endpoint did not return JSON") from None

        try:
            choice = completion["choices"][0]
            content = choice["message"].get("content") or ""
            if isinstance(content, list):
                content = "".join(part.get("text", "") for part in content if isinstance(part, dict))
            if not isinstance(content, str):
                raise TypeError("Response content is not text")
            return ModelResponse(
                text=content,
                served_model=completion.get("model"),
                response_id=completion.get("id"),
                finish_reason=choice.get("finish_reason"),
                usage=completion.get("usage"),
            )
        except (KeyError, IndexError, TypeError, AttributeError) as exc:
            raise ModelRequestError(f"Model endpoint returned an invalid chat completion: {exc}") from None