import customtkinter as ctk
import yaml
import threading
import google.generativeai as genai
from huggingface_utils import HuggingFaceUtils

class ConfigTab:
    def __init__(self, parent_tab, config):
        self.config = config.get('api_keys', {})
        
        # Frame principal
        self.frame = ctk.CTkFrame(parent_tab)
        self.frame.pack(fill="both", expand=True, padx=10, pady=10)
        
        # Título
        config_title = ctk.CTkLabel(
            self.frame,
            text="Configuración de APIs",
            font=("Arial", 16, "bold")
        )
        config_title.pack(pady=10)
        
        # Frame para API de HuggingFace
        hf_frame = ctk.CTkFrame(self.frame)
        hf_frame.pack(fill="x", padx=10, pady=5)
        
        hf_label = ctk.CTkLabel(hf_frame, text="🤗 HuggingFace API Token:")
        hf_label.pack(side="left", padx=5)
        
        self.hf_token_entry = ctk.CTkEntry(
            hf_frame,
            width=300,
            show="•"
        )
        self.hf_token_entry.pack(side="left", padx=5)
        self.hf_token_entry.insert(0, self.config.get('HUGGINGFACE_TOKEN', ''))
        
        # Frame para API de Google
        google_frame = ctk.CTkFrame(self.frame)
        google_frame.pack(fill="x", padx=10, pady=5)
        
        google_label = ctk.CTkLabel(google_frame, text="🔑 Google API Key:")
        google_label.pack(side="left", padx=5)
        
        self.google_key_entry = ctk.CTkEntry(
            google_frame,
            width=300,
            show="•"
        )
        self.google_key_entry.pack(side="left", padx=5)
        self.google_key_entry.insert(0, self.config.get('GOOGLE_API_KEY', ''))
        
        # Frame para ElevenLabs
        eleven_frame = ctk.CTkFrame(self.frame)
        eleven_frame.pack(fill="x", padx=10, pady=5)
        
        eleven_label = ctk.CTkLabel(eleven_frame, text="🎙️ ElevenLabs API Key:")
        eleven_label.pack(side="left", padx=5)
        
        self.eleven_key_entry = ctk.CTkEntry(
            eleven_frame,
            width=300,
            show="•"
        )
        self.eleven_key_entry.pack(side="left", padx=5)
        self.eleven_key_entry.insert(0, self.config.get('ELEVENLABS_API_KEY', ''))
        
        # Frame para botones
        button_frame = ctk.CTkFrame(self.frame)
        button_frame.pack(pady=20)
        
        # Botón para mostrar/ocultar tokens
        self.show_tokens_button = ctk.CTkButton(
            button_frame,
            text="👁️ Mostrar Tokens",
            command=self.toggle_token_visibility,
            width=120
        )
        self.show_tokens_button.pack(side="left", padx=5)
        
        # Botón para guardar
        save_button = ctk.CTkButton(
            button_frame,
            text="💾 Guardar",
            command=self.save_config,
            width=120
        )
        save_button.pack(side="left", padx=5)
        
        # Botón para probar APIs
        test_button = ctk.CTkButton(
            button_frame,
            text="🔄 Probar APIs",
            command=self.test_apis,
            width=120
        )
        test_button.pack(side="left", padx=5)
    
    def load_config(self):
        """Cargar configuración desde YAML"""
        try:
            with open('config.yaml', 'r') as file:
                return yaml.safe_load(file)
        except FileNotFoundError:
            return {'api_keys': {'HUGGINGFACE_TOKEN': '', 'GOOGLE_API_KEY': '', 'ELEVENLABS_API_KEY': ''}}
    
    def toggle_token_visibility(self):
        """Alternar visibilidad de tokens"""
        if self.hf_token_entry.cget('show') == '•':
            self.hf_token_entry.configure(show="")
            self.google_key_entry.configure(show="")
            self.eleven_key_entry.configure(show="")
            self.show_tokens_button.configure(text="🔒 Ocultar Tokens")
        else:
            self.hf_token_entry.configure(show="•")
            self.google_key_entry.configure(show="•")
            self.eleven_key_entry.configure(show="•")
            self.show_tokens_button.configure(text="👁️ Mostrar Tokens")
    
    def save_config(self):
        """Guardar configuración en YAML"""
        try:
            with open('config.yaml', 'r') as file:
                current_config = yaml.safe_load(file) or {}
            
            # Actualizar solo las claves de API
            current_config['api_keys'] = {
                'HUGGINGFACE_TOKEN': self.hf_token_entry.get(),
                'GOOGLE_API_KEY': self.google_key_entry.get(),
                'ELEVENLABS_API_KEY': self.eleven_key_entry.get()
            }
            
            with open('config.yaml', 'w') as file:
                yaml.dump(current_config, file)
            
            self.show_message("✅ Configuración guardada correctamente")
            return True
        except Exception as e:
            self.show_message(f"❌ Error guardando configuración: {e}")
            return False
    
    def test_apis(self):
        """Probar conexión con las APIs"""
        def test_in_thread():
            try:
                # Probar HuggingFace
                huggingface = HuggingFaceUtils(token=self.hf_token_entry.get())
                hf_response = huggingface.generate_response("Test", max_length=10)
                hf_ok = "✅" if hf_response else "❌"
                
                # Probar Gemini
                try:
                    genai.configure(api_key=self.google_key_entry.get())
                    model = genai.GenerativeModel('gemini-pro')
                    gemini_response = model.generate_content("Test")
                    gemini_ok = "✅" if gemini_response else "❌"
                except Exception:
                    gemini_ok = "❌"
                
                # Probar ElevenLabs
                try:
                    elevenlabs = ElevenLabsUtils(api_key=self.eleven_key_entry.get())
                    elevenlabs_response = elevenlabs.generate_response("Test")
                    elevenlabs_ok = "✅" if elevenlabs_response else "❌"
                except Exception:
                    elevenlabs_ok = "❌"
                
                self.show_message(
                    f"HuggingFace: {hf_ok}\n"
                    f"Google Gemini: {gemini_ok}\n"
                    f"ElevenLabs: {elevenlabs_ok}"
                )
            except Exception as e:
                self.show_message(f"❌ Error probando APIs: {e}")
        
        threading.Thread(target=test_in_thread, daemon=True).start()
    
    def show_message(self, message):
        """Mostrar mensaje en ventana emergente"""
        dialog = ctk.CTkInputDialog(
            text=message,
            title="Mensaje",
            button_text="OK"
        )
        dialog.get_input()