from __future__ import annotations

from dataclasses import dataclass, field
from time import perf_counter
from typing import Any, Protocol


@dataclass(slots=True)
class ConversationTurn:
    role: str
    content: str


@dataclass(slots=True)
class ModelRequest:
    prompt: str
    context: str = ""
    task_input: str = ""
    conversation_history: tuple[ConversationTurn, ...] = ()
    max_tokens: int = 256
    temperature: float = 0.0
    seed: int | None = None


@dataclass(slots=True)
class ModelResponse:
    text: str
    model_name: str
    provider: str
    latency_ms: float
    raw_metadata: dict[str, Any] = field(default_factory=dict)


class ModelAdapter(Protocol):
    provider: str
    model_name: str

    def generate(self, request: ModelRequest) -> ModelResponse:
        ...


class BaseModelAdapter:
    provider = "base"

    def __init__(self, model_name: str) -> None:
        self.model_name = model_name

    def generate(self, request: ModelRequest) -> ModelResponse:
        started_at = perf_counter()
        text, raw_metadata = self._generate_text(request)
        latency_ms = round((perf_counter() - started_at) * 1000, 3)
        return ModelResponse(
            text=text,
            model_name=self.model_name,
            provider=self.provider,
            latency_ms=latency_ms,
            raw_metadata=raw_metadata,
        )

    def _generate_text(self, request: ModelRequest) -> tuple[str, dict[str, Any]]:
        raise NotImplementedError