import time
from typing import Any, Optional
import httpx
from core.config import get_settings
from core.exceptions import ValidationError
from core.logging import get_logger
from modules.ai.providers.base import AICompletionResult, AIProvider

logger = get_logger(__name__)


class OpenRouterProvider(AIProvider):
    """OpenRouter API integration for multi-provider models."""

    MODELS = {
        "anthropic/claude-3.5-sonnet": {
            "name": "Claude 3.5 Sonnet",
            "context_window": 200000,
            "input_cost_per_1m": 300000,   # $3.00
            "output_cost_per_1m": 1500000, # $15.00
        },
        "google/gemini-2.0-flash-001": {
            "name": "Gemini 2.0 Flash",
            "context_window": 1000000,
            "input_cost_per_1m": 10000,    # $0.10
            "output_cost_per_1m": 40000,   # $0.40
        },
        "meta-llama/llama-3.3-70b-instruct": {
            "name": "Llama 3.3 70B Instruct",
            "context_window": 128000,
            "input_cost_per_1m": 35000,    # $0.35
            "output_cost_per_1m": 40000,   # $0.40
        },
        "deepseek/deepseek-chat": {
            "name": "DeepSeek V3",
            "context_window": 64000,
            "input_cost_per_1m": 14000,    # $0.14
            "output_cost_per_1m": 28000,   # $0.28
        },
    }

    def __init__(self, default_api_key: Optional[str] = None):
        settings = get_settings()
        self.default_api_key = default_api_key or settings.OPENROUTER_API_KEY
        self.base_url = "https://openrouter.ai/api/v1"

    def list_supported_models(self) -> list[dict[str, Any]]:
        return [
            {"id": model_id, **meta}
            for model_id, meta in self.MODELS.items()
        ]

    async def generate_completion(
        self,
        messages: list[dict[str, str]],
        model: str = "google/gemini-2.0-flash-001",
        temperature: float = 0.7,
        max_tokens: int = 1000,
        api_key: Optional[str] = None,
    ) -> AICompletionResult:
        key = api_key or self.default_api_key
        if not key or key.startswith("mock_") or key.startswith("sk-or-test") or key.startswith("test_"):
            # Mock sandbox response
            start_t = time.time()
            last_user_msg = next((m["content"] for m in reversed(messages) if m.get("role") == "user"), "Hello")
            mock_content = f"⚡ [OpenRouter / {model}]: Received '{last_user_msg[:40]}'. Processing response via high-throughput inference."
            prompt_tokens = sum(len(m.get("content", "").split()) for m in messages) * 2
            completion_tokens = len(mock_content.split()) * 2
            total_tokens = prompt_tokens + completion_tokens

            model_meta = self.MODELS.get(model, self.MODELS["google/gemini-2.0-flash-001"])
            cost = int(
                (prompt_tokens * model_meta["input_cost_per_1m"] + completion_tokens * model_meta["output_cost_per_1m"]) / 1_000_000
            )

            latency = int((time.time() - start_t) * 1000)
            return AICompletionResult(
                content=mock_content,
                model=model,
                prompt_tokens=prompt_tokens,
                completion_tokens=completion_tokens,
                total_tokens=total_tokens,
                cost_microcents=max(1, cost),
                latency_ms=max(20, latency),
            )

        headers = {
            "Authorization": f"Bearer {key}",
            "HTTP-Referer": "https://telegram-saas.platform",
            "X-Title": "Telegram Super Bot SaaS",
            "Content-Type": "application/json",
        }
        payload = {
            "model": model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens,
        }

        start_t = time.time()
        async with httpx.AsyncClient(timeout=30.0) as client:
            resp = await client.post(f"{self.base_url}/chat/completions", json=payload, headers=headers)
            if resp.status_code != 200:
                logger.error("openrouter_completion_failed", status_code=resp.status_code, text=resp.text)
                raise ValidationError(f"OpenRouter error: {resp.text}")

            data = resp.json()
            latency = int((time.time() - start_t) * 1000)
            choice = data["choices"][0]["message"]
            usage = data.get("usage", {})
            prompt_tokens = usage.get("prompt_tokens", 0)
            completion_tokens = usage.get("completion_tokens", 0)
            total_tokens = usage.get("total_tokens", prompt_tokens + completion_tokens)

            model_meta = self.MODELS.get(model, self.MODELS["google/gemini-2.0-flash-001"])
            cost = int(
                (prompt_tokens * model_meta["input_cost_per_1m"] + completion_tokens * model_meta["output_cost_per_1m"]) / 1_000_000
            )

            return AICompletionResult(
                content=choice.get("content", ""),
                model=model,
                prompt_tokens=prompt_tokens,
                completion_tokens=completion_tokens,
                total_tokens=total_tokens,
                cost_microcents=max(1, cost),
                latency_ms=latency,
            )
