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 OpenAIProvider(AIProvider):
    """OpenAI API integration for GPT models."""

    MODELS = {
        "gpt-4o-mini": {
            "name": "GPT-4o Mini",
            "context_window": 128000,
            "input_cost_per_1m": 15000,   # $0.15 in microcents
            "output_cost_per_1m": 60000,  # $0.60 in microcents
        },
        "gpt-4o": {
            "name": "GPT-4o Omni",
            "context_window": 128000,
            "input_cost_per_1m": 250000,  # $2.50
            "output_cost_per_1m": 1000000, # $10.00
        },
        "gpt-4-turbo": {
            "name": "GPT-4 Turbo",
            "context_window": 128000,
            "input_cost_per_1m": 1000000,
            "output_cost_per_1m": 3000000,
        },
    }

    def __init__(self, default_api_key: Optional[str] = None):
        settings = get_settings()
        self.default_api_key = default_api_key or settings.OPENAI_API_KEY
        self.base_url = "https://api.openai.com/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 = "gpt-4o-mini",
        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_test_") or key.startswith("test_"):
            # Mock sandbox response for testing and offline execution
            start_t = time.time()
            last_user_msg = next((m["content"] for m in reversed(messages) if m.get("role") == "user"), "Hello")
            mock_content = f"🤖 [AI Assistant]: Thank you for your inquiry about '{last_user_msg[:40]}'. I am your dedicated Telegram bot AI assistant."
            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["gpt-4o-mini"])
            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(15, latency),
            )

        headers = {
            "Authorization": f"Bearer {key}",
            "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("openai_completion_failed", status_code=resp.status_code, text=resp.text)
                raise ValidationError(f"OpenAI 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["gpt-4o-mini"])
            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,
            )
