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)
            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
            )
            
            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'}