"""
Calculadora MAV CAS Híbrida - Aplicación principal
"""
import tkinter as tk
from tkinter import scrolledtext, messagebox, Menu, filedialog
import tkinter.font as tkFont
import json
import os
import threading
from typing import List, Dict, Any, Optional
import re

# Importar componentes del CAS híbrido
from main_evaluation import HybridEvaluationEngine, EvaluationResult
from tl_popup import InteractiveResultManager
from ip4_type import HybridIP4 as IP4
from hex_type import HybridHex as Hex
from bin_type import HybridBin as Bin
from dec_type import HybridDec as Dec
from chr_type import HybridChr as Chr
import sympy
from sympy_helper import Helper as SympyHelper


class HybridCalculatorApp:
    """Aplicación principal del CAS híbrido"""
    
    SETTINGS_FILE = "hybrid_calc_settings.json"
    HISTORY_FILE = "hybrid_calc_history.txt"
    
    HELPERS = [
        IP4.Helper,
        Hex.Helper,
        Bin.Helper,
        Dec.Helper,
        Chr.Helper,
        SympyHelper,
    ]
    
    def __init__(self, root: tk.Tk):
        self.root = root
        self.root.title("Calculadora MAV - CAS Híbrido")
        
        # Cargar configuración
        self.settings = self._load_settings()
        self.root.geometry(self.settings.get("window_geometry", "1000x700"))
        self.root.configure(bg="#2b2b2b")
        
        # Configurar ícono
        self._setup_icon()
        
        # Componentes principales
        self.engine = HybridEvaluationEngine()
        self.interactive_manager = None  # Se inicializa después de crear widgets
        
        # Estado de la aplicación
        self._debounce_job = None
        self._syncing_yview = False
        self._cached_input_font = None
        self.output_buffer = []
        
        # Crear interfaz
        self.create_widgets()
        self.setup_interactive_manager()
        self.load_history()
        
        # Configurar eventos de cierre
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)
    
    def _setup_icon(self):
        """Configura el ícono de la aplicación"""
        try:
            self.app_icon = tk.PhotoImage(file="icon.png")
            self.root.iconphoto(True, self.app_icon)
        except tk.TclError:
            print("Advertencia: No se pudo cargar 'icon.png' como ícono.")
    
    def _load_settings(self) -> Dict[str, Any]:
        """Carga configuración de la aplicación"""
        if os.path.exists(self.SETTINGS_FILE):
            try:
                with open(self.SETTINGS_FILE, "r", encoding="utf-8") as f:
                    return json.load(f)
            except (IOError, json.JSONDecodeError):
                return {}
        return {}
    
    def _save_settings(self):
        """Guarda configuración de la aplicación"""
        self.settings["window_geometry"] = self.root.winfo_geometry()
        if hasattr(self, "paned_window"):
            try:
                sash_x_pos = self.paned_window.sash_coord(0)[0]
                self.settings["sash_pos_x"] = sash_x_pos
            except tk.TclError:
                pass
        
        try:
            with open(self.SETTINGS_FILE, "w", encoding="utf-8") as f:
                json.dump(self.settings, f, indent=4)
        except IOError:
            messagebox.showwarning("Error", "No se pudieron guardar los ajustes.")
    
    def create_widgets(self):
        """Crea la interfaz gráfica"""
        # Frame principal
        main_frame = tk.Frame(self.root, bg="#2b2b2b", bd=0)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=0, pady=0)
        
        # Panel dividido
        self.paned_window = tk.PanedWindow(
            main_frame, orient=tk.HORIZONTAL, bg="#2b2b2b",
            sashrelief=tk.FLAT, sashwidth=4, bd=0,
            showhandle=False, opaqueresize=True,
        )
        self.paned_window.pack(fill=tk.BOTH, expand=True, padx=0, pady=0)
        
        # Panel de entrada
        initial_input_width = self.settings.get("sash_pos_x", 450)
        
        self.input_text = scrolledtext.ScrolledText(
            self.paned_window, 
            font=("Consolas", 11), 
            bg="#1e1e1e", 
            fg="#d4d4d4",
            insertbackground="#ffffff", 
            selectbackground="#264f78", 
            undo=True,
            wrap=tk.NONE, 
            borderwidth=0, 
            highlightthickness=0, 
            relief=tk.FLAT,
        )
        self.paned_window.add(
            self.input_text, 
            width=initial_input_width, 
            stretch="always", 
            minsize=200
        )
        
        # Panel de salida
        self.output_text = scrolledtext.ScrolledText(
            self.paned_window, 
            font=("Consolas", 11), 
            bg="#0f0f0f", 
            fg="#00ff00",
            state="disabled", 
            wrap=tk.NONE, 
            borderwidth=0,
            highlightthickness=0, 
            relief=tk.FLAT,
        )
        self.paned_window.add(
            self.output_text, 
            stretch="always", 
            minsize=200
        )
        
        # Configurar eventos
        self.input_text.bind("<KeyRelease>", self.on_key_release)
        self.input_text.bind("<Button-3>", lambda e: self._show_context_menu(e, "input"))
        self.output_text.bind("<Button-3>", lambda e: self._show_context_menu(e, "output"))
        
        # Configurar scroll sincronizado
        self.setup_scroll_sync()
        
        # Configurar tags de salida
        self.setup_output_tags()
        
        # Crear menú
        self.create_menu()
    
    def setup_interactive_manager(self):
        """Configura el gestor de resultados interactivos"""
        self.interactive_manager = InteractiveResultManager(self.root)
    
    def create_menu(self):
        """Crea el menú de la aplicación"""
        menubar = Menu(self.root)
        self.root.config(menu=menubar)
        
        # Menú Archivo
        file_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Archivo", menu=file_menu)
        file_menu.add_command(label="Nuevo", command=self.new_session)
        file_menu.add_separator()
        file_menu.add_command(label="Cargar...", command=self.load_file)
        file_menu.add_command(label="Guardar como...", command=self.save_file)
        file_menu.add_separator()
        file_menu.add_command(label="Salir", command=self.on_close)
        
        # Menú Editar
        edit_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Editar", menu=edit_menu)
        edit_menu.add_command(label="Limpiar entrada", command=self.clear_input)
        edit_menu.add_command(label="Limpiar salida", command=self.clear_output)
        edit_menu.add_separator()
        edit_menu.add_command(label="Limpiar variables", command=self.clear_variables)
        edit_menu.add_command(label="Limpiar ecuaciones", command=self.clear_equations)
        edit_menu.add_command(label="Limpiar todo", command=self.clear_all)
        
        # Menú CAS
        cas_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="CAS", menu=cas_menu)
        cas_menu.add_command(label="Mostrar variables", command=self.show_variables)
        cas_menu.add_command(label="Mostrar ecuaciones", command=self.show_equations)
        cas_menu.add_separator()
        cas_menu.add_command(label="Resolver sistema", command=self.solve_system)
        
        # Menú Ayuda
        help_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Ayuda", menu=help_menu)
        help_menu.add_command(label="Guía rápida", command=self.show_quick_guide)
        help_menu.add_command(label="Sintaxis", command=self.show_syntax_help)
        help_menu.add_command(label="Funciones SymPy", command=self.show_sympy_functions)
        help_menu.add_separator()
        help_menu.add_command(label="Acerca de", command=self.show_about)
    
    def setup_scroll_sync(self):
        """Configura scroll sincronizado entre paneles"""
        def _yscroll_input_command(*args):
            self.input_text.vbar.set(*args)
            if not self._syncing_yview:
                self._syncing_yview = True
                self.output_text.yview_moveto(args[0])
                self._syncing_yview = False
        
        def _yscroll_output_command(*args):
            self.output_text.vbar.set(*args)
            if not self._syncing_yview:
                self._syncing_yview = True
                self.input_text.yview_moveto(args[0])
                self._syncing_yview = False
        
        def _unified_mouse_wheel(event):
            if self._syncing_yview:
                return "break"
            if hasattr(event, "widget") and event.widget:
                event.widget.yview_scroll(int(-1 * (event.delta / 120)), "units")
            return "break"
        
        self.input_text.config(yscrollcommand=_yscroll_input_command)
        self.output_text.config(yscrollcommand=_yscroll_output_command)
        self.input_text.bind("<MouseWheel>", _unified_mouse_wheel)
        self.output_text.bind("<MouseWheel>", _unified_mouse_wheel)
    
    def setup_output_tags(self):
        """Configura tags para coloreado de salida"""
        self.output_text.tag_configure("error", foreground="#ff6b6b", font=("Consolas", 11, "bold"))
        self.output_text.tag_configure("result", foreground="#abdbe3")
        self.output_text.tag_configure("symbolic", foreground="#82aaff")
        self.output_text.tag_configure("numeric", foreground="#c3e88d")
        self.output_text.tag_configure("equation", foreground="#c792ea")
        self.output_text.tag_configure("info", foreground="#ffcb6b")
        self.output_text.tag_configure("comment", foreground="#546e7a")
        self.output_text.tag_configure("type_hint", foreground="#6a6a6a")
        
        # Tags para tipos especializados
        self.output_text.tag_configure("hex", foreground="#f9a825")
        self.output_text.tag_configure("bin", foreground="#4fc3f7")
        self.output_text.tag_configure("ip", foreground="#fff176")
        self.output_text.tag_configure("date", foreground="#ff8a80")
        self.output_text.tag_configure("chr_type", foreground="#80cbc4")
    
    def on_key_release(self, event=None):
        """Maneja eventos de teclado"""
        if self._debounce_job:
            self.root.after_cancel(self._debounce_job)
        
        # Autocompletado con punto
        if event and event.char == '.' and self.input_text.focus_get() == self.input_text:
            self._handle_dot_autocomplete()
        
        # Evaluación con debounce
        self._debounce_job = self.root.after(300, self._evaluate_and_update)
    
    def _handle_dot_autocomplete(self):
        self._close_autocomplete_popup()
        cursor_index_str = self.input_text.index(tk.INSERT)
        line_num_str, char_num_str = cursor_index_str.split('.')
        current_line_num = int(line_num_str)
        char_idx_of_dot = int(char_num_str)
        obj_expr_str = self.input_text.get(f"{current_line_num}.0", f"{current_line_num}.{char_idx_of_dot -1}").strip()
        if not obj_expr_str:
            return

        # Preprocesar para convertir sintaxis de corchetes a llamada de clase
        # Ejemplo: Hex[FF] -> Hex('FF')
        bracket_match = re.match(r"([A-Za-z_][A-Za-z0-9_]*)\[(.*)\]$", obj_expr_str)
        if bracket_match:
            class_name, arg = bracket_match.groups()
            # Si el argumento es un número, no poner comillas
            if arg.isdigit():
                obj_expr_str = f"{class_name}({arg})"
            else:
                obj_expr_str = f"{class_name}('{arg}')"

        eval_context = self.engine._get_full_context() if hasattr(self.engine, '_get_full_context') else {}
        obj = None
        try:
            obj = eval(obj_expr_str, eval_context)
        except Exception:
            return
        if obj is not None and hasattr(obj, 'PopupFunctionList'):
            methods = obj.PopupFunctionList()
            if methods:
                self._show_autocomplete_popup(methods)

    def _show_autocomplete_popup(self, suggestions):
        # suggestions: lista de tuplas (nombre, hint)
        cursor_bbox = self.input_text.bbox(tk.INSERT)
        if not cursor_bbox:
            return
        x, y, _, height = cursor_bbox
        popup_x = self.input_text.winfo_rootx() + x
        popup_y = self.input_text.winfo_rooty() + y + height + 2
        self._autocomplete_popup = tk.Toplevel(self.root)
        self._autocomplete_popup.wm_overrideredirect(True)
        self._autocomplete_popup.wm_geometry(f"+{popup_x}+{popup_y}")
        self._autocomplete_popup.attributes('-topmost', True)
        self.root.after(100, lambda: self._autocomplete_popup.attributes('-topmost', False) if self._autocomplete_popup else None)
        self._autocomplete_listbox = tk.Listbox(
            self._autocomplete_popup, bg="#3c3f41", fg="#bbbbbb",
            selectbackground="#007acc", selectforeground="white",
            borderwidth=1, relief="solid", exportselection=False, activestyle="none"
        )
        for name, hint in suggestions:
            self._autocomplete_listbox.insert(tk.END, f"{name}    — {hint}")
        if suggestions:
            self._autocomplete_listbox.select_set(0)
            self._autocomplete_listbox.pack(expand=True, fill=tk.BOTH)
            self._autocomplete_listbox.bind("<Return>", self._on_autocomplete_select)
            self._autocomplete_listbox.bind("<Escape>", lambda e: self._close_autocomplete_popup())
            self._autocomplete_listbox.bind("<Double-Button-1>", self._on_autocomplete_select)
            self._autocomplete_listbox.focus_set()
            self._autocomplete_listbox.bind("<Up>", lambda e: self._navigate_autocomplete(e, -1))
            self._autocomplete_listbox.bind("<Down>", lambda e: self._navigate_autocomplete(e, 1))
            self.input_text.bind("<FocusOut>", lambda e: self._close_autocomplete_popup(), add=True)
            self.input_text.bind("<Button-1>", lambda e: self._close_autocomplete_popup(), add=True)
            self.root.bind("<Button-1>", lambda e: self._close_autocomplete_popup(), add=True)
            self.input_text.bind("<Key>", lambda e: self._close_autocomplete_popup(), add=True)
            max_len = max(len(name) for name, _ in suggestions) if suggestions else 10
            width = max(15, min(max_len + 10, 50))
            height = min(len(suggestions), 10)
            self._autocomplete_listbox.config(width=width, height=height)
        else:
            self._close_autocomplete_popup()

    def _navigate_autocomplete(self, event, direction):
        if not hasattr(self, '_autocomplete_listbox') or not self._autocomplete_listbox:
            return "break"
        current_selection = self._autocomplete_listbox.curselection()
        if not current_selection:
            new_idx = 0 if direction == 1 else self._autocomplete_listbox.size() -1
        else:
            idx = current_selection[0]
            new_idx = idx + direction
        if 0 <= new_idx < self._autocomplete_listbox.size():
            if current_selection:
                self._autocomplete_listbox.select_clear(current_selection[0])
            self._autocomplete_listbox.select_set(new_idx)
            self._autocomplete_listbox.activate(new_idx)
            self._autocomplete_listbox.see(new_idx)
        return "break"

    def _on_autocomplete_select(self, event):
        if not hasattr(self, '_autocomplete_listbox') or not self._autocomplete_listbox:
            return "break"
        selection = self._autocomplete_listbox.curselection()
        if not selection:
            self._close_autocomplete_popup()
            return "break"
        selected = self._autocomplete_listbox.get(selection[0])
        method_name = selected.split()[0]
        self.input_text.insert(tk.INSERT, method_name + "()")
        self.input_text.mark_set(tk.INSERT, f"{tk.INSERT}-1c")  # Cursor dentro de los paréntesis
        self._close_autocomplete_popup()
        self.input_text.focus_set()
        self.on_key_release()  # Trigger re-evaluation
        return "break"

    def _close_autocomplete_popup(self):
        if hasattr(self, '_autocomplete_popup') and self._autocomplete_popup:
            self._autocomplete_popup.destroy()
            self._autocomplete_popup = None
            self._autocomplete_listbox = None
    
    def _evaluate_and_update(self):
        """Evalúa todas las líneas y actualiza la salida"""
        try:
            input_content = self.input_text.get("1.0", tk.END)
            if not input_content.strip():
                self._clear_output()
                return
            
            lines = input_content.splitlines()
            self._evaluate_lines(lines)
            
        except Exception as e:
            self._show_error(f"Error durante evaluación: {e}")
    
    def _evaluate_lines(self, lines: List[str]):
        """Evalúa múltiples líneas de código"""
        output_data = []
        
        for line_num, line in enumerate(lines, 1):
            line = line.strip()
            
            # Líneas vacías o comentarios
            if not line or line.startswith('#'):
                if line:
                    output_data.append([("comment", line)])
                else:
                    output_data.append([("", "")])
                continue
            
            # Evaluar línea
            result = self.engine.evaluate_line(line)
            line_output = self._process_evaluation_result(result)
            output_data.append(line_output)
        
        self._display_output(output_data)
    
    def _process_evaluation_result(self, result: EvaluationResult) -> List[tuple]:
        """Procesa el resultado de evaluación para display"""
        output_parts = []
        
        if result.is_error:
            ayuda = self.obtener_ayuda(result.original_line)
            if ayuda:
                output_parts.append(("helper", ayuda))
            else:
                output_parts.append(("error", f"Error: {result.error}"))
        elif result.result_type == "comment":
            output_parts.append(("comment", result.original_line))
        elif result.result_type == "equation_added":
            output_parts.append(("equation", result.symbolic_result))
        elif result.result_type == "assignment":
            output_parts.append(("info", result.symbolic_result))
        else:
            # Resultado normal
            if result.result is not None:
                # Determinar tag basado en tipo
                tag = self._get_result_tag(result.result)
                
                # Verificar si es resultado interactivo
                if self.interactive_manager and result.is_interactive:
                    interactive_tag, display_text = self.interactive_manager.create_interactive_tag(
                        result.result, self.output_text, "1.0"
                    )
                    if interactive_tag:
                        output_parts.append((interactive_tag, display_text))
                    else:
                        output_parts.append((tag, str(result.result)))
                else:
                    output_parts.append((tag, str(result.result)))
                
                # Mostrar evaluación numérica si existe
                if result.numeric_result is not None and result.numeric_result != result.result:
                    output_parts.append(("numeric", f" ≈ {result.numeric_result}"))
                
                # Mostrar información adicional
                if result.info:
                    output_parts.append(("info", f" ({result.info})"))
        
        return output_parts
    
    def _get_result_tag(self, result: Any) -> str:
        """Determina el tag de color para un resultado"""
        if isinstance(result, Hex):
            return "hex"
        elif isinstance(result, Bin):
            return "bin" 
        elif isinstance(result, IP4):
            return "ip"
        elif isinstance(result, Chr):
            return "chr_type"
        elif isinstance(result, sympy.Basic):
            return "symbolic"
        else:
            return "result"
    
    def _display_output(self, output_data: List[List[tuple]]):
        """Muestra los datos de salida en el widget"""
        self.output_text.config(state="normal")
        self.output_text.delete("1.0", tk.END)
        
        for line_idx, line_parts in enumerate(output_data):
            # Línea vacía
            if not line_parts or (len(line_parts) == 1 and line_parts[0][0] == "" and line_parts[0][1] == ""):
                pass
            else:
                # Mostrar partes de la línea
                first_part = True
                for tag, content in line_parts:
                    if not first_part and content:
                        self.output_text.insert(tk.END, " ; ")
                    
                    if content:
                        self.output_text.insert(tk.END, str(content), tag)
                        first_part = False
            
            # Añadir nueva línea excepto para la última línea
            if line_idx < len(output_data) - 1:
                self.output_text.insert(tk.END, "\n")
        
        self.output_text.config(state="disabled")
    
    def _clear_output(self):
        """Limpia el panel de salida"""
        self.output_text.config(state="normal")
        self.output_text.delete("1.0", tk.END)
        self.output_text.config(state="disabled")
    
    def _show_error(self, error_msg: str):
        """Muestra un error en el panel de salida"""
        self.output_text.config(state="normal")
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert("1.0", error_msg, "error")
        self.output_text.config(state="disabled")
    
    def _show_context_menu(self, event, panel_type: str):
        """Muestra menú contextual"""
        context_menu = Menu(
            self.root, tearoff=0, bg="#3c3c3c", fg="white",
            activebackground="#007acc", activeforeground="white",
            relief=tk.FLAT, bd=1,
        )
        
        if panel_type == "input":
            context_menu.add_command(label="Cortar", command=lambda: self.input_text.event_generate("<<Cut>>"))
            context_menu.add_command(label="Copiar", command=lambda: self.input_text.event_generate("<<Copy>>"))
            context_menu.add_command(label="Pegar", command=lambda: self.input_text.event_generate("<<Paste>>"))
            context_menu.add_separator()
            context_menu.add_command(label="Limpiar entrada", command=self.clear_input)
            context_menu.add_separator()
            context_menu.add_command(label="Insertar ejemplo", command=self.insert_example)
        elif panel_type == "output":
            context_menu.add_command(label="Copiar todo", command=self.copy_output)
            context_menu.add_command(label="Limpiar salida", command=self.clear_output)
        
        context_menu.add_separator()
        context_menu.add_command(label="Ayuda", command=self.show_quick_guide)
        
        try:
            context_menu.tk_popup(event.x_root, event.y_root)
        finally:
            context_menu.grab_release()
    
    # Métodos de menú y comandos
    def new_session(self):
        """Inicia nueva sesión"""
        self.clear_input()
        self.clear_output()
        self.engine.clear_all()
    
    def load_file(self):
        """Carga archivo en el editor"""
        filepath = filedialog.askopenfilename(
            title="Cargar archivo",
            filetypes=[
                ("Archivos de texto", "*.txt"),
                ("Archivos Python", "*.py"), 
                ("Todos los archivos", "*.*")
            ]
        )
        
        if filepath:
            try:
                with open(filepath, "r", encoding="utf-8") as f:
                    content = f.read()
                
                self.input_text.delete("1.0", tk.END)
                self.input_text.insert("1.0", content)
                self._evaluate_and_update()
                
            except Exception as e:
                messagebox.showerror("Error", f"No se pudo cargar el archivo:\n{e}")
    
    def save_file(self):
        """Guarda contenido del editor"""
        filepath = filedialog.asksaveasfilename(
            title="Guardar archivo",
            defaultextension=".txt",
            filetypes=[
                ("Archivos de texto", "*.txt"),
                ("Archivos Python", "*.py"),
                ("Todos los archivos", "*.*")
            ]
        )
        
        if filepath:
            try:
                content = self.input_text.get("1.0", tk.END)
                with open(filepath, "w", encoding="utf-8") as f:
                    f.write(content)
                
                messagebox.showinfo("Éxito", "Archivo guardado correctamente.")
                
            except Exception as e:
                messagebox.showerror("Error", f"No se pudo guardar el archivo:\n{e}")
    
    def clear_input(self):
        """Limpia panel de entrada"""
        self.input_text.delete("1.0", tk.END)
        self._clear_output()
    
    def clear_output(self):
        """Limpia panel de salida"""
        self._clear_output()
    
    def clear_variables(self):
        """Limpia variables del motor"""
        self.engine.clear_variables()
        self._evaluate_and_update()
    
    def clear_equations(self):
        """Limpia ecuaciones del motor"""
        self.engine.clear_equations()
        self._evaluate_and_update()
    
    def clear_all(self):
        """Limpia variables y ecuaciones"""
        self.engine.clear_all()
        self._evaluate_and_update()
    
    def copy_output(self):
        """Copia contenido de salida al clipboard"""
        content = self.output_text.get("1.0", tk.END).strip()
        if content:
            self.root.clipboard_clear()
            self.root.clipboard_append(content)
    
    def insert_example(self):
        """Inserta código de ejemplo"""
        example = """# Calculadora MAV - CAS Híbrido
# Sintaxis nueva con corchetes

# Tipos especializados
Hex[FF] + 1
IP4[192.168.1.100/24].NetworkAddress[]
Bin[1010] * 2

# Matemáticas simbólicas
x + 2*y
diff(x**2 + sin(x), x)
integrate(x**2, x)

# Ecuaciones (detección automática)
x**2 + 2*x - 8 = 0
3*a + b = 10

# Resolver ecuaciones
solve(x**2 + 2*x - 8, x)
a=?

# Variables automáticas
z = 5
w = z**2 + 3

# Plotting interactivo
plot(sin(x), (x, -2*pi, 2*pi))

# Matrices
Matrix([[1, 2], [3, 4]])
"""
        self.input_text.delete("1.0", tk.END)
        self.input_text.insert("1.0", example)
        self._evaluate_and_update()
    
    def show_variables(self):
        """Muestra ventana con variables definidas"""
        variables = self.engine.symbol_table
        
        window = tk.Toplevel(self.root)
        window.title("Variables Definidas")
        window.geometry("500x400")
        window.configure(bg="#2b2b2b")
        
        text_widget = scrolledtext.ScrolledText(
            window,
            font=("Consolas", 11),
            bg="#1e1e1e",
            fg="#d4d4d4"
        )
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        if variables:
            content = "Variables definidas:\n\n"
            for name, value in variables.items():
                content += f"{name} = {value}\n"
        else:
            content = "No hay variables definidas."
        
        text_widget.insert("1.0", content)
        text_widget.config(state="disabled")
    
    def show_equations(self):
        """Muestra ventana con ecuaciones definidas"""
        equations = self.engine.equations
        
        window = tk.Toplevel(self.root)
        window.title("Ecuaciones Definidas")
        window.geometry("500x400")
        window.configure(bg="#2b2b2b")
        
        text_widget = scrolledtext.ScrolledText(
            window,
            font=("Consolas", 11),
            bg="#1e1e1e",
            fg="#d4d4d4"
        )
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        if equations:
            content = "Ecuaciones en el sistema:\n\n"
            for i, eq in enumerate(equations, 1):
                content += f"{i}. {eq}\n"
        else:
            content = "No hay ecuaciones en el sistema."
        
        text_widget.insert("1.0", content)
        text_widget.config(state="disabled")
    
    def solve_system(self):
        """Resuelve el sistema de ecuaciones"""
        try:
            if not self.engine.equations:
                messagebox.showinfo("Info", "No hay ecuaciones para resolver.")
                return
            
            solutions = self.engine.solve_system()
            
            window = tk.Toplevel(self.root)
            window.title("Soluciones del Sistema")
            window.geometry("500x400")
            window.configure(bg="#2b2b2b")
            
            text_widget = scrolledtext.ScrolledText(
                window,
                font=("Consolas", 11),
                bg="#1e1e1e",
                fg="#d4d4d4"
            )
            text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
            
            content = "Soluciones del sistema:\n\n"
            if isinstance(solutions, dict):
                for var, value in solutions.items():
                    content += f"{var} = {value}\n"
            else:
                content += str(solutions)
            
            text_widget.insert("1.0", content)
            text_widget.config(state="disabled")
            
        except Exception as e:
            messagebox.showerror("Error", f"Error resolviendo sistema:\n{e}")
    
    def show_quick_guide(self):
        """Muestra guía rápida"""
        guide = """# Calculadora MAV - CAS Híbrido

## Sintaxis Nueva con Corchetes
- IP4[192.168.1.1/24] en lugar de IP4("192.168.1.1/24")
- Hex[FF], Bin[1010], Dec[10.5], Chr[A]

## Ecuaciones Automáticas
- x**2 + 2*x = 8  (detectado automáticamente)
- a + b = 10      (agregado al sistema)
- variable=?      (atajo para solve(variable))

## Funciones SymPy Disponibles
- solve(), diff(), integrate(), limit(), series()
- sin(), cos(), tan(), exp(), log(), sqrt()
- Matrix(), plot(), plot3d()

## Resultados Interactivos
- 📊 Ver Plot     (click para ventana matplotlib)
- 📋 Ver Matriz   (click para vista expandida)
- 📋 Ver Lista    (click para contenido completo)

## Variables Automáticas
- Todas las variables son símbolos SymPy
- x = 5 crea Symbol('x') con valor 5
- Evaluación simbólica + numérica automática
"""
        
        self._show_help_window("Guía Rápida", guide)
    
    def show_syntax_help(self):
        """Muestra ayuda de sintaxis"""
        syntax = """# Sintaxis del CAS Híbrido

## Clases Especializadas (solo corchetes)
IP4[dirección/prefijo]    # IP4[192.168.1.1/24]
Hex[valor]                # Hex[FF], Hex[255]
Bin[valor]                # Bin[1010], Bin[10]
Dec[valor]                # Dec[10.5], Dec[10]
Chr[carácter]             # Chr[A], Chr[Hello]

## Métodos Disponibles
IP4[...].NetworkAddress[]
IP4[...].BroadcastAddress[]
IP4[...].Nodes()
Hex[...].toDecimal()

## Ecuaciones (detección automática)
expresión = expresión     # Ecuación simple
expresión == expresión    # Igualdad SymPy
expresión > expresión     # Desigualdad SymPy

## Resolver
solve(ecuación, variable)
variable=?               # Atajo para solve(variable)

## Variables SymPy Puras
x = valor               # Crea Symbol('x')
expresión               # Evaluación simbólica automática
"""
        
        self._show_help_window("Sintaxis", syntax)
    
    def show_sympy_functions(self):
        """Muestra funciones SymPy disponibles"""
        functions = """# Funciones SymPy Disponibles

## Matemáticas Básicas
sin(x), cos(x), tan(x)
asin(x), acos(x), atan(x)
sinh(x), cosh(x), tanh(x)
exp(x), log(x), sqrt(x)
abs(x), sign(x), factorial(x)

## Cálculo
diff(expr, var)          # Derivada
integrate(expr, var)     # Integral indefinida
integrate(expr, (var, a, b))  # Integral definida
limit(expr, var, punto)  # Límite
series(expr, var, punto, n)   # Serie de Taylor

## Álgebra
solve(ecuación, variable)
simplify(expr), expand(expr)
factor(expr), collect(expr, var)
cancel(expr), apart(expr, var)

## Álgebra Lineal
Matrix([[a, b], [c, d]])
det(matrix), inv(matrix)

## Plotting
plot(expr, (var, inicio, fin))
plot3d(expr, (x, x1, x2), (y, y1, y2))

## Constantes
pi, E, I (imaginario), oo (infinito)
"""
        
        self._show_help_window("Funciones SymPy", functions)
    
    def show_about(self):
        """Muestra información sobre la aplicación"""
        about = """Calculadora MAV - CAS Híbrido

Versión: 2.0
Motor: SymPy + Clases Especializadas

Características:
• Motor algebraico completo (SymPy)
• Sintaxis simplificada con corchetes
• Detección automática de ecuaciones
• Resultados interactivos clickeables
• Tipos especializados (IP4, Hex, Bin, etc.)
• Variables SymPy puras
• Plotting integrado

Desarrollado para cálculo matemático avanzado
con soporte especializado para redes, 
programación y análisis numérico.
"""
        
        messagebox.showinfo("Acerca de", about)
    
    def _show_help_window(self, title: str, content: str):
        """Muestra ventana de ayuda"""
        window = tk.Toplevel(self.root)
        window.title(title)
        window.geometry("700x500")
        window.configure(bg="#2b2b2b")
        
        text_widget = scrolledtext.ScrolledText(
            window,
            font=("Consolas", 10),
            bg="#1e1e1e",
            fg="#d4d4d4",
            wrap=tk.WORD
        )
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        text_widget.insert("1.0", content)
        text_widget.config(state="disabled")
    
    def load_history(self):
        """Carga historial de entrada"""
        try:
            if os.path.exists(self.HISTORY_FILE):
                with open(self.HISTORY_FILE, "r", encoding="utf-8") as f:
                    content = f.read()
                
                if content.strip():
                    self.input_text.insert("1.0", content)
                    self.root.after_idle(self._evaluate_and_update)
                    return
        except Exception as e:
            print(f"Error cargando historial: {e}")
        
        # Cargar ejemplo por defecto si no hay historial
        self.insert_example()
    
    def save_history(self):
        """Guarda historial de entrada"""
        try:
            content = self.input_text.get("1.0", tk.END).rstrip("\n")
            if content:
                with open(self.HISTORY_FILE, "w", encoding="utf-8") as f:
                    f.write(content)
            elif os.path.exists(self.HISTORY_FILE):
                os.remove(self.HISTORY_FILE)
        except Exception as e:
            print(f"Error guardando historial: {e}")
    
    def on_close(self):
        """Maneja cierre de la aplicación"""
        self.save_history()
        self._save_settings()
        
        if self.interactive_manager:
            self.interactive_manager.close_all_windows()
        
        self.root.destroy()

    def obtener_ayuda(self, input_str):
        for helper in self.HELPERS:
            ayuda = helper(input_str)
            if ayuda:
                return ayuda
        return None


def main():
    """Función principal"""
    root = tk.Tk()
    app = HybridCalculatorApp(root)
    
    try:
        root.iconname("Calculadora MAV CAS")
    except tk.TclError:
        pass
    
    root.mainloop()


if __name__ == "__main__":
    main()