# Arquitectura completa cost-optimized para LLM inference
from openai import OpenAI
import redis
import hashlib
from typing import Optional, Literal
from dataclasses import dataclass
import time

client = OpenAI(api_key="tu-api-key")
redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

ComplejidadType = Literal["simple", "moderada", "compleja"]

@dataclass
class QueryRequest:
    """Request entrante con metadata."""
    user_id: str
    query: str
    feature: str  # Para tracking de costes por feature
    priority: str = "normal"  # high, normal, low

@dataclass
class QueryResponse:
    """Response con metadata de coste y rendimiento."""
    content: str
    model_used: str
    tokens_input: int
    tokens_output: int
    latency_ms: float
    cache_hit: bool
    cost_usd: float

class CostOptimizedLLMService:
    """
    Servicio LLM con todas las optimizaciones de coste implementadas.
    Capas:
    1. Request validation + rate limiting
    2. Multi-tier caching (exact + semantic)
    3. Complexity classification + routing
    4. Prompt optimization
    5. Monitoring y alertas
    """
    
    # Precios por 1M tokens (actualizar según provider)
    PRICES = {
        "gpt-4-turbo": {"input": 10.0, "output": 30.0},
        "gpt-4o": {"input": 2.5, "output": 10.0},
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
    }
    
    def __init__(self):
        self.daily_budget_usd = 500.0  # Límite diario
        self.current_spend_usd = self._get_daily_spend()
    
    def process_query(self, request: QueryRequest) -> QueryResponse:
        """Procesa query con todas las optimizaciones."""
        start_time = time.time()
        
        # 1. Budget check
        if self.current_spend_usd >= self.daily_budget_usd:
            raise Exception("Daily budget exceeded! Blocking new requests.")
        
        # 2. L1 Cache - Exact Match
        cache_key_l1 = self._generate_cache_key(request.query)
        cached_l1 = redis_client.get(cache_key_l1)
        if cached_l1:
            print("✅ L1 CACHE HIT (exact match)")
            return self._build_cached_response(cached_l1, "L1", start_time)
        
        # 3. L2 Cache - Semantic (simplificado)
        cached_l2 = self._check_semantic_cache(request.query)
        if cached_l2:
            print("✅ L2 CACHE HIT (semantic)")
            return self._build_cached_response(cached_l2, "L2", start_time)
        
        # 4. Cache miss - clasificar y procesar
        print("❌ CACHE MISS - generando respuesta...")
        complejidad = self._clasificar_complejidad(request.query)
        modelo = self._select_model(complejidad)
        
        # 5. LLM call con prompt optimization
        response = self._call_llm(
            query=request.query,
            modelo=modelo,
            max_tokens=self._calculate_max_tokens(request.feature)
        )
        
        # 6. Guardar en cache
        self._save_to_cache(request.query, response, cache_key_l1)
        
        # 7. Tracking de coste
        cost = self._calculate_cost(response, modelo)
        self.current_spend_usd += cost
        self._log_metrics(request, response, cost)
        
        latency_ms = (time.time() - start_time) * 1000
        return QueryResponse(
            content=response["content"],
            model_used=modelo,
            tokens_input=response["tokens_input"],
            tokens_output=response["tokens_output"],
            latency_ms=latency_ms,
            cache_hit=False,
            cost_usd=cost
        )
    
    def _generate_cache_key(self, query: str) -> str:
        """Genera key determinística para caching."""
        return f"cache_l1:{hashlib.md5(query.encode()).hexdigest()}"
    
    def _check_semantic_cache(self, query: str) -> Optional[str]:
        """Semantic cache con embeddings + similarity search."""
        # Simplificado - implementar con embeddings reales
        return None
    
    def _clasificar_complejidad(self, query: str) -> ComplejidadType:
        """Clasifica complejidad usando GPT-4o Mini."""
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "Clasifica: simple, moderada, compleja"},
                {"role": "user", "content": query}
            ],
            max_tokens=10,
            temperature=0
        )
        return response.choices[0].message.content.strip().lower()
    
    def _select_model(self, complejidad: ComplejidadType) -> str:
        """Routing basado en complejidad."""
        mapping = {
            "simple": "gpt-4o-mini",
            "moderada": "gpt-4o",
            "compleja": "gpt-4-turbo"
        }
        return mapping.get(complejidad, "gpt-4o")
    
    def _calculate_max_tokens(self, feature: str) -> int:
        """Límites de tokens por feature."""
        limits = {
            "chat": 500,
            "summary": 200,
            "analysis": 1000,
            "generation": 2000
        }
        return limits.get(feature, 500)
    
    def _call_llm(self, query: str, modelo: str, max_tokens: int) -> dict:
        """Llamada al LLM con prompt caching."""
        response = client.chat.completions.create(
            model=modelo,
            messages=[{"role": "user", "content": query}],
            max_tokens=max_tokens,
            temperature=0.7
        )
        return {
            "content": response.choices[0].message.content,
            "tokens_input": response.usage.prompt_tokens,
            "tokens_output": response.usage.completion_tokens
        }
    
    def _save_to_cache(self, query: str, response: dict, cache_key: str):
        """Guarda en L1 cache con TTL."""
        redis_client.setex(cache_key, 300, response["content"])  # 5 minutos
    
    def _calculate_cost(self, response: dict, modelo: str) -> float:
        """Calcula coste real de la llamada."""
        prices = self.PRICES[modelo]
        cost_input = (response["tokens_input"] / 1_000_000) * prices["input"]
        cost_output = (response["tokens_output"] / 1_000_000) * prices["output"]
        return cost_input + cost_output
    
    def _log_metrics(self, request: QueryRequest, response: dict, cost: float):
        """Envía métricas a sistema de monitoring."""
        print(f"📊 Metrics: feature={request.feature}, cost={cost:.4f}, "
              f"tokens={response['tokens_input'] + response['tokens_output']}")
    
    def _build_cached_response(self, content: str, cache_tier: str, start_time: float) -> QueryResponse:
        """Construye response desde cache."""
        return QueryResponse(
            content=content,
            model_used=f"cached-{cache_tier}",
            tokens_input=0,
            tokens_output=0,
            latency_ms=(time.time() - start_time) * 1000,
            cache_hit=True,
            cost_usd=0.0
        )
    
    def _get_daily_spend(self) -> float:
        """Obtiene gasto del día actual desde tracking system."""
        return 0.0

# Uso
service = CostOptimizedLLMService()
request = QueryRequest(
    user_id="user123",
    query="¿Cuál es la diferencia entre Python y JavaScript?",
    feature="chat",
    priority="normal"
)

response = service.process_query(request)
print(f"\n✅ Response generada:")
print(f"Contenido: {response.content[:100]}...")
print(f"Modelo: {response.model_used}")
print(f"Coste: ${response.cost_usd:.4f}")
print(f"Latency: {response.latency_ms:.0f}ms")
print(f"Cache hit: {response.cache_hit}")