import openai
import requests
import logging
import os
from typing import Optional, Dict, Any

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class APIAgent:
    def __init__(self):
        self.config = {}
    
    def set_config(self, config: Dict[str, Any]):
        """Configura las claves API desde Gradio"""
        self.config = config or {}
    
    def call_openai(self, prompt: str, is_code: bool = False) -> Optional[str]:
        """Intenta llamar a OpenAI API"""
        api_key = self.config.get("openai_api_key")
        
        if not api_key:
            return None
        
        try:
            openai.api_key = api_key
            
            model = "gpt-3.5-turbo"
            max_tokens = self.config.get("max_tokens", 400)  # Reducido para HF
            temperature = self.config.get("temperature", 0.7)
            
            response = openai.ChatCompletion.create(
                model=model,
                messages=[{"role": "user", "content": prompt}],
                max_tokens=max_tokens,
                temperature=temperature,
                timeout=15  # Timeout reducido
            )
            
            return response.choices[0].message.content.strip()
            
        except Exception as e:
            logger.error(f"❌ Error llamando a OpenAI: {e}")
            return None
    
    def call_deepseek(self, prompt: str, is_code: bool = False) -> Optional[str]:
        """Intenta llamar a DeepSeek API"""
        api_key = self.config.get("deepseek_api_key")
        
        if not api_key:
            return None
        
        try:
            url = "https://api.deepseek.com/v1/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {api_key}"
            }
            
            max_tokens = self.config.get("max_tokens", 400)
            temperature = self.config.get("temperature", 0.7)
            
            data = {
                "model": "deepseek-chat",
                "messages": [{"role": "user", "content": prompt}],
                "max_tokens": max_tokens,
                "temperature": temperature,
                "stream": False
            }
            
            response = requests.post(url, json=data, headers=headers, timeout=20)
            response.raise_for_status()
            
            result = response.json()
            return result["choices"][0]["message"]["content"].strip()
            
        except Exception as e:
            logger.error(f"❌ Error llamando a DeepSeek: {e}")
            return None
    
    def generate_response(self, prompt: str, is_code: bool = False) -> Dict[str, Any]:
        """
        Intenta generar respuesta usando APIs en orden de preferencia
        Returns: dict con response y source
        """
        # Verificar si hay claves configuradas
        has_deepseek = bool(self.config.get("deepseek_api_key"))
        has_openai = bool(self.config.get("openai_api_key"))
        
        if has_deepseek:
            deepseek_response = self.call_deepseek(prompt, is_code)
            if deepseek_response:
                return {"response": deepseek_response, "source": "deepseek"}
        
        if has_openai:
            openai_response = self.call_openai(prompt, is_code)
            if openai_response:
                return {"response": openai_response, "source": "openai"}
        
        # Si no hay APIs disponibles o fallan, retornar None para usar modelo local
        return {"response": None, "source": "none"}