# ========== CONFIGURACIÓN COMPLETA MEJORADA - VERSIÓN CORREGIDA ==========
import os
import sys

# Silenciar TODO antes de cualquier import
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = '1'
os.environ['CUDA_LAUNCH_BLOCKING'] = '0'
os.environ['SDL_AUDIODRIVER'] = 'directsound'

# Redirigir stderr para silenciar warnings
class SilenceWarnings:
    def __enter__(self):
        self._original_stderr = sys.stderr
        sys.stderr = open(os.devnull, 'w')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        sys.stderr.close()
        sys.stderr = self._original_stderr

with SilenceWarnings():
    import warnings
    warnings.filterwarnings("ignore")
    warnings.simplefilter("ignore")

    import tkinter as tk
    from tkinter import filedialog, messagebox, scrolledtext
    import customtkinter as ctk
    import cv2
    import torch
    import pygame
    import time
    import threading
    import subprocess
    import tempfile
    import whisper
    from PIL import Image, ImageTk, ImageDraw, ImageFont
    from pathlib import Path
    import numpy as np
    import json
    from datetime import datetime
    import webbrowser

    try:
        from googletrans import Translator
        GOOGLETRANS_AVAILABLE = True
    except ImportError:
        GOOGLETRANS_AVAILABLE = False

# ========== TEMA Y CONFIGURACIÓN MODERNA CORREGIDA ==========
ctk.set_appearance_mode("Dark")
ctk.set_default_color_theme("blue")

# Colores modernos - TODOS VÁLIDOS para CustomTkinter
COLORS = {
    "primary": "#2B5B84",
    "secondary": "#1E3A5F",
    "accent": "#FF6B35",
    "success": "#27AE60",
    "warning": "#E67E22",
    "danger": "#E74C3C",
    "dark": "#1A1A1A",
    "dark_alt": "#2D2D2D",
    "light": "#ECF0F1",
    "gray": "#95A5A6"
}

LANGUAGES = {
    'Original': None,
    'English': 'en',
    'Español': 'es',
    'Français': 'fr',
    'Deutsch': 'de',
    'Italiano': 'it',
    'Português': 'pt',
    'Русский': 'ru',
    '中文': 'zh-cn',
    '日本語': 'ja',
    '한국어': 'ko'
}

WHISPER_MODELS = {
    'tiny': 'Tiny (más rápido)',
    'base': 'Base (recomendado)',
    'small': 'Small (preciso)',
    'medium': 'Medium (muy preciso)',
    'large': 'Large (máxima precisión)',
    'large-v2': 'Large v2 (máx precisión)',
    'large-v3': 'Large v3 (máx precisión)'
}

# ========== COMPONENTES MEJORADOS ==========
class ModernVideoPlayer:
    def __init__(self):
        self.cap = None
        self.fps = 30
        self.duration = 0
        self.video_width = 0
        self.video_height = 0
        self.frame_cache = {}
        self.cache_size = 100

    def load_video(self, video_path):
        try:
            if self.cap:
                self.cap.release()
                self.frame_cache.clear()

            self.cap = cv2.VideoCapture(video_path)
            if not self.cap.isOpened():
                return False

            self.fps = self.cap.get(cv2.CAP_PROP_FPS) or 30
            total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
            self.duration = total_frames / self.fps if self.fps > 0 else 0

            self.video_width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
            self.video_height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

            return True
        except Exception as e:
            print(f"❌ Error cargando video: {e}")
            return False

    def get_frame_at_time(self, time_seconds):
        if not self.cap:
            return None

        try:
            frame_pos = int(time_seconds * self.fps)

            # Usar caché para mejor rendimiento
            if frame_pos in self.frame_cache:
                return self.frame_cache[frame_pos]

            self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_pos)
            success, frame = self.cap.read()

            if success and frame is not None:
                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

                # Gestionar caché
                if len(self.frame_cache) >= self.cache_size:
                    self.frame_cache.pop(next(iter(self.frame_cache)))
                self.frame_cache[frame_pos] = frame_rgb

                return frame_rgb

        except Exception as e:
            print(f"⚠️ Error obteniendo frame: {e}")

        return None

    def release(self):
        if self.cap:
            self.cap.release()
            self.cap = None
        self.frame_cache.clear()

class ModernSubtitleSystem:
    def __init__(self):
        self.segments = []
        self.font_system = GiantFontSystem()
        self.max_chars_per_line = 35
        self.subtitle_style = {
            'bg_color': (0, 0, 0, 220),
            'border_color': (255, 255, 255, 180),
            'text_color': (255, 255, 255),
            'translation_color': (255, 255, 100),
            'font_size': 52,
            'border_width': 3,
            'padding': 20,
            'margin_bottom': 100
        }

    def set_segments(self, segments):
        self.segments = segments

    def get_subtitle_at_time(self, current_time):
        for segment in self.segments:
            if segment['start'] <= current_time <= segment['end']:
                return segment
        return None

    def wrap_text(self, text, max_chars=None):
        if max_chars is None:
            max_chars = self.max_chars_per_line

        words = text.split()
        lines = []
        current_line = []

        for word in words:
            test_line = ' '.join(current_line + [word])
            if len(test_line) > max_chars:
                if current_line:
                    lines.append(' '.join(current_line))
                    current_line = [word]
                else:
                    # Palabra muy larga
                    while len(word) > max_chars:
                        lines.append(word[:max_chars - 1] + "-")
                        word = word[max_chars - 1:]
                    current_line = [word]
            else:
                current_line.append(word)

        if current_line:
            lines.append(' '.join(current_line))

        return lines

    def render_subtitles(self, frame, current_time, show_translation=False):
        if frame is None:
            return frame

        subtitle = self.get_subtitle_at_time(current_time)
        if not subtitle:
            return frame

        try:
            pil_img = Image.fromarray(frame)
            draw = ImageDraw.Draw(pil_img)

            original_text = subtitle['text'].strip()
            original_lines = self.wrap_text(original_text)

            translation_text = ""
            if show_translation and subtitle.get('translation'):
                translation_text = subtitle['translation'].strip()
                translation_lines = self.wrap_text(translation_text, self.max_chars_per_line - 5)
                all_lines = original_lines + translation_lines
            else:
                all_lines = original_lines

            # Calcular dimensiones
            style = self.subtitle_style
            line_height = 60
            padding = style['padding']
            margin_bottom = style['margin_bottom']

            total_height = len(all_lines) * line_height + padding * 2
            y_position = pil_img.height - total_height - margin_bottom

            # Encontrar línea más ancha
            max_line_width = 0
            font = self.font_system.get_font(style['font_size'])
            for line in all_lines:
                bbox = draw.textbbox((0, 0), line, font=font)
                text_width = bbox[2] - bbox[0]
                max_line_width = max(max_line_width, text_width)

            # Fondo y borde
            bg_x1 = max(50, (pil_img.width - max_line_width) // 2 - padding)
            bg_x2 = min(pil_img.width - 50, bg_x1 + max_line_width + padding * 2)
            bg_y1 = max(50, y_position - padding)
            bg_y2 = min(pil_img.height - 50, bg_y1 + total_height + padding)

            # Fondo semitransparente
            draw.rectangle([bg_x1, bg_y1, bg_x2, bg_y2], fill=style['bg_color'])

            # Borde
            for i in range(style['border_width']):
                draw.rectangle([bg_x1 - i, bg_y1 - i, bg_x2 + i, bg_y2 + i],
                               outline=style['border_color'], width=1)

            # Texto
            current_y = y_position
            for i, line in enumerate(all_lines):
                if line.strip():
                    bbox = draw.textbbox((0, 0), line, font=font)
                    text_width = bbox[2] - bbox[0]
                    x_position = (pil_img.width - text_width) // 2

                    if show_translation and i >= len(original_lines):
                        color = style['translation_color']
                        # Sombra para mejor legibilidad
                        draw.text((x_position + 2, current_y + 2), line, font=font, fill=(0, 0, 0, 150))
                    else:
                        color = style['text_color']
                        # Sombra para mejor legibilidad
                        draw.text((x_position + 2, current_y + 2), line, font=font, fill=(0, 0, 0, 150))

                    draw.text((x_position, current_y), line, font=font, fill=color)
                    current_y += line_height

            return np.array(pil_img)

        except Exception as e:
            print(f"❌ Error renderizando subtítulos: {e}")
            return frame

class GiantFontSystem:
    def __init__(self):
        self.fonts = {}
        self.load_fonts()

    def load_fonts(self):
        try:
            # Fuentes para diferentes tamaños
            sizes = [36, 42, 48, 54, 60, 66, 72]
            for size in sizes:
                try:
                    self.fonts[f'regular_{size}'] = ImageFont.truetype("arial.ttf", size)
                    self.fonts[f'bold_{size}'] = ImageFont.truetype("arialbd.ttf", size)
                except:
                    try:
                        self.fonts[f'regular_{size}'] = ImageFont.truetype("C:/Windows/Fonts/arial.ttf", size)
                        self.fonts[f'bold_{size}'] = ImageFont.truetype("C:/Windows/Fonts/arialbd.ttf", size)
                    except:
                        pass

            if not self.fonts:
                self.fonts['regular_54'] = ImageFont.load_default()

        except Exception as e:
            print(f"⚠️ Error cargando fuentes: {e}")
            self.fonts['regular_54'] = ImageFont.load_default()

    def get_font(self, size=54, bold=False):
        key = f"{'bold' if bold else 'regular'}_{size}"
        return self.fonts.get(key, self.fonts.get('regular_54'))

# ========== APLICACIÓN PRINCIPAL MEJORADA Y CORREGIDA ==========
class ModernTranscriberApp:
    def __init__(self, root):
        self.root = root
        self.root.title("🎬 TRANSCRIPTOR PRO - Edición Profesional")
        self.root.geometry("1400x900")
        self.root.minsize(1200, 800)

        # Estado de la aplicación
        self.setup_state()
        self.setup_theming()
        self.setup_components()
        self.setup_ui()
        self.start_main_loop()
        self.setup_bindings()

    def setup_state(self):
        """Configurar estado inicial"""
        self.video_player = ModernVideoPlayer()
        self.subtitle_system = ModernSubtitleSystem()
        self.transcriber = None
        self.translator = Translator() if GOOGLETRANS_AVAILABLE else None

        self.video_path = None
        self.audio_path = None
        self.segments = []
        self.is_playing = False
        self.current_time = 0
        self.current_model = "base"
        self.show_translation = False
        self.ui_visible = True
        self.volume = 0.7
        self.last_volume = 0.7

        # Audio
        self.audio_player = None
        self.init_audio()

        # Variables de UI
        self.status_var = tk.StringVar(value="👋 Bienvenido a Transcriptor Pro - Carga un video para comenzar")
        self.progress_var = tk.DoubleVar(value=0)
        self.time_var = tk.StringVar(value="00:00 / 00:00")
        self.volume_var = tk.DoubleVar(value=self.volume * 100)

    def setup_theming(self):
        """Configurar tema visual"""
        self.current_theme = "dark"
        self.accent_color = COLORS["accent"]

    def setup_components(self):
        """Inicializar componentes del sistema"""
        self.load_config()

    def setup_ui(self):
        """Construir interfaz de usuario moderna"""
        self.root.grid_columnconfigure(1, weight=1)
        self.root.grid_rowconfigure(0, weight=1)

        self.setup_sidebar()
        self.setup_main_area()
        self.setup_status_bar()

    # ... (el resto del código de la clase ModernTranscriberApp se mantiene igual)

# ========== EJECUCIÓN MEJORADA ==========
def main():
    print("🚀 INICIANDO TRANSCRIPTOR PRO - EDICIÓN PROFESIONAL")
    print("✅ Interfaz moderna y profesional")
    print("✅ Rendimiento optimizado")
    print("✅ Funcionalidades completas")
    print("✅ Experiencia de usuario mejorada")

    try:
        root = ctk.CTk()
        app = ModernTranscriberApp(root)

        def on_closing():
            app.cleanup()
            root.destroy()

        root.protocol("WM_DELETE_WINDOW", on_closing)
        root.mainloop()

    except Exception as e:
        print(f"❌ ERROR CRÍTICO: {e}")
        messagebox.showerror("Error Crítico", f"Error al iniciar la aplicación:\n{str(e)}")

if __name__ == "__main__":
    main()

Guía de Instalación Rápida