import requests
import json
import os
from dotenv import load_dotenv
from ..config import Config

load_dotenv()

class GeminiService:
    def __init__(self):
        self.config = Config()
        self.api_key = os.getenv('GEMINI_API_KEY')
        self.models = {
            "gemini-2.0-flash": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent",
            "gemini-2.0-pro": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-pro:generateContent",
            "gemini-2.5-flash": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent",
            "gemini-2.5-pro": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent",
            "gemini": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent"  # default
        }
        
    def generate_response(self, message, system_prompt=None, temperature=0.7, max_tokens=2000, top_p=0.9, model="gemini-2.5-flash"):
        """
        Generate a response using the Gemini API.
        
        Args:
            message (str): The user's message
            system_prompt (str, optional): System prompt to guide the model
            temperature (float): Controls randomness (0.0 to 1.0)
            max_tokens (int): Maximum number of tokens to generate
            top_p (float): Controls diversity via nucleus sampling
            
        Returns:
            dict: Response containing the generated text and metadata
        """
        try:
            headers = {
                'Content-Type': 'application/json'
            }
            
            full_prompt = f"{system_prompt}\n\n{message}" if system_prompt else message
            
            # Get API URL based on model
            api_url = self.models.get(model, self.models["gemini-2.5-flash"])
            
            data = {
                "contents": [
                    {
                        "parts": [
                            {
                                "text": full_prompt
                            }
                        ]
                    }
                ],
                "generationConfig": {
                    "temperature": temperature,
                    "maxOutputTokens": max_tokens,
                    "topP": top_p
                }
            }
            
            response = requests.post(
                f"{api_url}?key={self.api_key}",
                headers=headers,
                json=data
            )
            
            response.raise_for_status()
            result = response.json()
            
            # Log resposta completa para debug
            print(f"[DEBUG GEMINI] Resposta completa da API: {json.dumps(result, indent=2)}")
            
            # Validar estrutura da resposta
            if 'candidates' not in result or len(result['candidates']) == 0:
                # Checar se há erro de safety/bloqueio
                if 'promptFeedback' in result:
                    feedback = result['promptFeedback']
                    block_reason = feedback.get('blockReason', 'UNKNOWN')
                    safety_ratings = feedback.get('safetyRatings', [])
                    raise Exception(f"Gemini bloqueou o prompt. Razão: {block_reason}. Safety: {json.dumps(safety_ratings, indent=2)}")
                raise Exception(f"No candidates in Gemini response: {json.dumps(result, indent=2)}")
            
            candidate = result['candidates'][0]
            
            # Checar finish_reason
            finish_reason = candidate.get('finishReason', 'UNKNOWN')
            if finish_reason in ['SAFETY', 'RECITATION', 'OTHER']:
                safety_ratings = candidate.get('safetyRatings', [])
                raise Exception(f"Gemini finalizou por '{finish_reason}'. Safety: {json.dumps(safety_ratings, indent=2)}")
            
            if 'content' not in candidate:
                raise Exception(f"No content in candidate: {json.dumps(candidate, indent=2)}")
            
            content = candidate['content']
            if 'parts' not in content or len(content['parts']) == 0:
                raise Exception(f"Content sem 'parts' (possível bloqueio). Candidate: {json.dumps(candidate, indent=2)}")
            
            part = content['parts'][0]
            if 'text' not in part:
                raise Exception(f"No text in part: {json.dumps(part, indent=2)}")
            
            generated_text = part['text']
            return {
                "response": generated_text,
                "context": [], 
                "done": True
            }
                
        except requests.exceptions.RequestException as e:
            from src.discord.discord_webhook import send_discord_audit_log
            send_discord_audit_log(
                action="Falha de integração externa",
                user_id=None,
                object_type="Gemini",
                details=f"Erro ao comunicar com Gemini API: {str(e)}",
                ip_address=None
            )
            raise Exception(f"Error communicating with Gemini API: {str(e)}")
        except Exception as e:
            from src.discord.discord_webhook import send_discord_audit_log
            send_discord_audit_log(
                action="Falha de integração externa",
                user_id=None,
                object_type="Gemini",
                details=f"Erro inesperado com Gemini API: {str(e)}",
                ip_address=None
            )
            raise Exception(f"Unexpected error with Gemini API: {str(e)}")

gemini_service = GeminiService()