class BaseProvider(ABC):
    """Abstract base for all provider implementations."""

    provider_name: str = ""

    @abstractmethod
    def chat(
        self,
        messages: list[dict],
        max_tokens: int = 4096,
        temperature: float = 0.7,
        model: Optional[str] = None,
    ) -> str:
        """Send a chat completion request. Returns the assistant text."""

    @abstractmethod
    def analyze_image(
        self,
        image_bytes: bytes,
        prompt: str,
        max_tokens: int = 4096,
        model: Optional[str] = None,
    ) -> str:
        """Analyze an image with a prompt. Returns the assistant text."""

    @abstractmethod
    def transcribe_audio(
        self,
        audio_path: str | Path,
        language: Optional[str] = None,
        model: Optional[str] = None,
    ) -> dict:
        """Transcribe an audio file. Returns dict with 'text', 'segments', etc."""

    @abstractmethod
    def list_models(self) -> list[ModelInfo]:
        """Discover available models from this provider's API."""

class ModelInfo(BaseModel):
    """Information about an available model."""

    id: str = Field(description="Model identifier (e.g. gpt-4o)")
    provider: str = Field(description="Provider name (openai, anthropic, gemini)")
    display_name: str = Field(default="", description="Human-readable name")
    capabilities: List[str] = Field(
        default_factory=list, description="Model capabilities: chat, vision, audio, embedding"
    )

class OpenAICompatibleProvider(BaseProvider):
    """Base for providers using OpenAI-compatible APIs.

    Suitable for Together, Fireworks, Cerebras, xAI, Azure, and similar services.
    """

    provider_name: str = ""
    base_url: str = ""
    env_var: str = ""

    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
        from openai import OpenAI

        self._api_key = api_key or os.getenv(self.env_var, "")
        self._base_url = base_url or self.base_url
        self._client = OpenAI(api_key=self._api_key, base_url=self._base_url)
        self._last_usage = None

    def chat(
        self,
        messages: list[dict],
        max_tokens: int = 4096,
        temperature: float = 0.7,
        model: Optional[str] = None,
    ) -> str:
        model = model or "gpt-4o"
        response = self._client.chat.completions.create(
            model=model,
            messages=messages,
            max_tokens=max_tokens,
            temperature=temperature,
        )
        self._last_usage = {
            "input_tokens": getattr(response.usage, "prompt_tokens", 0) if response.usage else 0,
            "output_tokens": getattr(response.usage, "completion_tokens", 0)
            if response.usage
            else 0,
        }
        return response.choices[0].message.content or ""

    def analyze_image(
        self,
        image_bytes: bytes,
        prompt: str,
        max_tokens: int = 4096,
        model: Optional[str] = None,
    ) -> str:
        model = model or "gpt-4o"
        b64 = base64.b64encode(image_bytes).decode()
        response = self._client.chat.completions.create(
            model=model,
            messages=[
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": prompt},
                        {
                            "type": "image_url",
                            "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
                        },
                    ],
                }
            ],
            max_tokens=max_tokens,
        )
        self._last_usage = {
            "input_tokens": getattr(response.usage, "prompt_tokens", 0) if response.usage else 0,
            "output_tokens": getattr(response.usage, "completion_tokens", 0)
            if response.usage
            else 0,
        }
        return response.choices[0].message.content or ""

    def transcribe_audio(
        self,
        audio_path: str | Path,
        language: Optional[str] = None,
        model: Optional[str] = None,
    ) -> dict:
        raise NotImplementedError(f"{self.provider_name} does not support audio transcription")

    def list_models(self) -> list[ModelInfo]:
        models = []
        try:
            for m in self._client.models.list():
                mid = m.id
                caps = ["chat"]
                models.append(
                    ModelInfo(
                        id=mid,
                        provider=self.provider_name,
                        display_name=mid,
                        capabilities=caps,
                    )
                )
        except Exception as e:
            logger.warning(f"Failed to list {self.provider_name} models: {e}")
        return sorted(models, key=lambda m: m.id)

class ProviderRegistry:
    """Registry for provider classes. Providers register themselves with metadata."""

    _providers: Dict[str, Dict] = {}

    @classmethod
    def register(
        cls,
        name: str,
        provider_class: type,
        env_var: str = "",
        model_prefixes: Optional[List[str]] = None,
        default_models: Optional[Dict[str, str]] = None,
    ) -> None:
        """Register a provider class with its metadata."""
        cls._providers[name] = {
            "class": provider_class,
            "env_var": env_var,
            "model_prefixes": model_prefixes or [],
            "default_models": default_models or {},
        }

    @classmethod
    def get(cls, name: str) -> type:
        """Return the provider class for a given name."""
        if name not in cls._providers:
            raise ValueError(f"Unknown provider: {name}")
        return cls._providers[name]["class"]

    @classmethod
    def get_by_model(cls, model_id: str) -> Optional[str]:
        """Return provider name for a model ID based on prefix matching."""
        for name, info in cls._providers.items():
            for prefix in info["model_prefixes"]:
                if model_id.startswith(prefix):
                    return name
        return None

    @classmethod
    def get_default_models(cls, name: str) -> Dict[str, str]:
        """Return the default models dict for a provider."""
        if name not in cls._providers:
            return {}
        return cls._providers[name].get("default_models", {})

    @classmethod
    def available(cls) -> List[str]:
        """Return names of providers whose env var is set (or have no env var requirement)."""
        result = []
        for name, info in cls._providers.items():
            env_var = info.get("env_var", "")
            if not env_var:
                # Providers without an env var (e.g. ollama) need special availability checks
                result.append(name)
            elif os.getenv(env_var, ""):
                result.append(name)
        return result

    @classmethod
    def all_registered(cls) -> Dict[str, Dict]:
        """Return all registered providers and their metadata."""
        return dict(cls._providers)

class ProviderManager:
    """
    Routes API calls to the best available provider/model.

    Supports explicit model selection or auto-routing based on
    discovered available models.
    """

    def __init__(
        self,
        vision_model: Optional[str] = None,
        chat_model: Optional[str] = None,
        transcription_model: Optional[str] = None,
        provider: Optional[str] = None,
        auto: bool = True,
    ):
        """
        Initialize the ProviderManager.

        Parameters
        ----------
        vision_model : override model for vision tasks (e.g. 'gpt-4o')
        chat_model : override model for chat/LLM tasks
        transcription_model : override model for transcription
        provider : force all tasks to a single provider ('openai', 'anthropic', 'gemini')
        auto : if True and no model specified, pick the best available
        """
        _ensure_providers_registered()
        self.auto = auto
        self._providers: dict[str, BaseProvider] = {}
        self._available_models: Optional[list[ModelInfo]] = None
        self.usage = UsageTracker()

        # If a single provider is forced, apply it
        if provider:
            self.vision_model = vision_model or self._default_for_provider(provider, "vision")
            self.chat_model = chat_model or self._default_for_provider(provider, "chat")
            self.transcription_model = transcription_model or self._default_for_provider(
                provider, "audio"
            )
        else:
            self.vision_model = vision_model
            self.chat_model = chat_model
            self.transcription_model = transcription_model

        self._forced_provider = provider

    @staticmethod
    def _default_for_provider(provider: str, capability: str) -> str:
        """Return the default model for a provider/capability combo."""
        defaults = ProviderRegistry.get_default_models(provider)
        if defaults:
            return defaults.get(capability, "")
        # Fallback for unregistered providers
        return ""

    def _get_provider(self, provider_name: str) -> BaseProvider:
        """Lazily initialize and cache a provider instance."""
        if provider_name not in self._providers:
            _ensure_providers_registered()
            provider_class = ProviderRegistry.get(provider_name)
            self._providers[provider_name] = provider_class()
        return self._providers[provider_name]

    def _provider_for_model(self, model_id: str) -> str:
        """Infer the provider from a model id."""
        _ensure_providers_registered()
        # Check registry prefix matching first
        provider_name = ProviderRegistry.get_by_model(model_id)
        if provider_name:
            return provider_name
        # Try discovery (exact match, then prefix match for ollama name:tag format)
        models = self._get_available_models()
        for m in models:
            if m.id == model_id:
                return m.provider
        for m in models:
            if m.id.startswith(model_id + ":"):
                return m.provider
        raise ValueError(f"Cannot determine provider for model: {model_id}")

    def _get_available_models(self) -> list[ModelInfo]:
        if self._available_models is None:
            self._available_models = discover_available_models()
        return self._available_models

    def _resolve_model(
        self, explicit: Optional[str], capability: str, preferences: list[tuple[str, str]]
    ) -> tuple[str, str]:
        """
        Resolve which (provider, model) to use for a capability.

        Returns (provider_name, model_id).
        """
        if explicit:
            prov = self._provider_for_model(explicit)
            return prov, explicit

        if self.auto:
            # Try preference order, picking the first provider that has an API key
            for prov, model in preferences:
                try:
                    self._get_provider(prov)
                    return prov, model
                except (ValueError, ImportError):
                    continue

            # Fallback: try Ollama if available (no API key needed)
            try:
                from video_processor.providers.ollama_provider import OllamaProvider

                if OllamaProvider.is_available():
                    provider = self._get_provider("ollama")
                    models = provider.list_models()
                    for m in models:
                        if capability in m.capabilities:
                            return "ollama", m.id
            except Exception:
                pass

        raise RuntimeError(
            f"No provider available for capability '{capability}'. "
            "Set an API key for at least one provider, or start Ollama."
        )

    def _track(self, provider: BaseProvider, prov_name: str, model: str) -> None:
        """Record usage from the last API call on a provider."""
        last = getattr(provider, "_last_usage", None)
        if last:
            self.usage.record(
                provider=prov_name,
                model=model,
                input_tokens=last.get("input_tokens", 0),
                output_tokens=last.get("output_tokens", 0),
            )
            provider._last_usage = None

    # --- Public API ---

    def chat(
        self,
        messages: list[dict],
        max_tokens: int = 4096,
        temperature: float = 0.7,
    ) -> str:
        """Send a chat completion to the best available provider."""
        prov_name, model = self._resolve_model(self.chat_model, "chat", _CHAT_PREFERENCES)
        logger.info(f"Chat: using {prov_name}/{model}")
        provider = self._get_provider(prov_name)
        result = provider.chat(
            messages, max_tokens=max_tokens, temperature=temperature, model=model
        )
        self._track(provider, prov_name, model)
        return result

    def analyze_image(
        self,
        image_bytes: bytes,
        prompt: str,
        max_tokens: int = 4096,
    ) -> str:
        """Analyze an image using the best available vision provider."""
        prov_name, model = self._resolve_model(self.vision_model, "vision", _VISION_PREFERENCES)
        logger.info(f"Vision: using {prov_name}/{model}")
        provider = self._get_provider(prov_name)
        result = provider.analyze_image(image_bytes, prompt, max_tokens=max_tokens, model=model)
        self._track(provider, prov_name, model)
        return result

    def transcribe_audio(
        self,
        audio_path: str | Path,
        language: Optional[str] = None,
        speaker_hints: Optional[list[str]] = None,
    ) -> dict:
        """Transcribe audio using local Whisper if available, otherwise API."""
        # Prefer local Whisper — no file size limits, no API costs
        if not self.transcription_model or self.transcription_model.startswith("whisper-local"):
            try:
                from video_processor.providers.whisper_local import WhisperLocal

                if WhisperLocal.is_available():
                    # Parse model size from "whisper-local:large" or default to "large"
                    size = "large"
                    if self.transcription_model and ":" in self.transcription_model:
                        size = self.transcription_model.split(":", 1)[1]
                    if not hasattr(self, "_whisper_local"):
                        self._whisper_local = WhisperLocal(model_size=size)
                    logger.info(f"Transcription: using local whisper-{size}")
                    # Pass speaker names as initial prompt hint for Whisper
                    whisper_kwargs = {"language": language}
                    if speaker_hints:
                        whisper_kwargs["initial_prompt"] = (
                            "Speakers: " + ", ".join(speaker_hints) + "."
                        )
                    result = self._whisper_local.transcribe(audio_path, **whisper_kwargs)
                    duration = result.get("duration") or 0
                    self.usage.record(
                        provider="local",
                        model=f"whisper-{size}",
                        audio_minutes=duration / 60 if duration else 0,
                    )
                    return result
            except ImportError:
                pass

        # Fall back to API-based transcription
        prov_name, model = self._resolve_model(
            self.transcription_model, "audio", _TRANSCRIPTION_PREFERENCES
        )
        logger.info(f"Transcription: using {prov_name}/{model}")
        provider = self._get_provider(prov_name)
        # Build transcription kwargs, passing speaker hints where supported
        transcribe_kwargs: dict = {"language": language, "model": model}
        if speaker_hints:
            if prov_name == "openai":
                # OpenAI Whisper supports a 'prompt' parameter for hints
                transcribe_kwargs["prompt"] = "Speakers: " + ", ".join(speaker_hints) + "."
            else:
                transcribe_kwargs["speaker_hints"] = speaker_hints
        result = provider.transcribe_audio(audio_path, **transcribe_kwargs)
        duration = result.get("duration") or 0
        self.usage.record(
            provider=prov_name,
            model=model,
            audio_minutes=duration / 60 if duration else 0,
        )
        return result

    def get_models_used(self) -> dict[str, str]:
        """Return a dict mapping capability to 'provider/model' for tracking."""
        result = {}
        for cap, explicit, prefs in [
            ("vision", self.vision_model, _VISION_PREFERENCES),
            ("chat", self.chat_model, _CHAT_PREFERENCES),
            ("transcription", self.transcription_model, _TRANSCRIPTION_PREFERENCES),
        ]:
            try:
                prov, model = self._resolve_model(explicit, cap, prefs)
                result[cap] = f"{prov}/{model}"
            except RuntimeError:
                pass
        return result