"""
Sistema de resultados interactivos con tags clickeables
"""
import tkinter as tk
from tkinter import Toplevel, scrolledtext
import sympy
from typing import Any, Optional, Dict, List
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import numpy as np


class InteractiveResultManager:
    """Maneja resultados interactivos con ventanas emergentes"""
    
    def __init__(self, parent_window: tk.Tk):
        self.parent = parent_window
        self.open_windows: Dict[str, Toplevel] = {}
    
    def create_interactive_tag(self, result: Any, text_widget: tk.Text, index: str) -> Optional[str]:
        """
        Crea un tag interactivo para un resultado si es necesario
        
        Returns:
            Tag name si se creó, None si no es necesario
        """
        tag_name = None
        display_text = ""
        
        if isinstance(result, PlotResult):
            tag_name = f"plot_{id(result)}"
            display_text = f"📊 Ver {result.plot_type.title()}"
            
        elif isinstance(result, sympy.Matrix):
            tag_name = f"matrix_{id(result)}"
            rows, cols = result.shape
            display_text = f"📋 Ver Matriz {rows}×{cols}"
            
        elif isinstance(result, list) and len(result) > 5:
            tag_name = f"list_{id(result)}"
            display_text = f"📋 Ver Lista ({len(result)} elementos)"
            
        elif isinstance(result, dict) and len(result) > 3:
            tag_name = f"dict_{id(result)}"
            display_text = f"🔍 Ver Diccionario ({len(result)} entradas)"
            
        elif hasattr(result, '__dict__') and len(str(result)) > 100:
            tag_name = f"object_{id(result)}"
            display_text = f"🔍 Ver Detalles ({type(result).__name__})"
        
        if tag_name:
            # Configurar tag
            text_widget.tag_configure(
                tag_name,
                foreground="#4fc3f7",
                underline=True,
                font=("Consolas", 11, "underline")
            )
            
            # Bind click event
            text_widget.tag_bind(
                tag_name, 
                "<Button-1>", 
                lambda e, r=result: self._handle_interactive_click(r)
            )
            
            text_widget.tag_bind(
                tag_name,
                "<Enter>",
                lambda e: text_widget.config(cursor="hand2")
            )
            
            text_widget.tag_bind(
                tag_name,
                "<Leave>",
                lambda e: text_widget.config(cursor="")
            )
            
            return tag_name, display_text
        
        return None, str(result)
    
    def _handle_interactive_click(self, result: Any):
        """Maneja clicks en elementos interactivos"""
        window_key = f"{type(result).__name__}_{id(result)}"
        
        # Si ya existe la ventana, enfocarla
        if window_key in self.open_windows:
            window = self.open_windows[window_key]
            if window.winfo_exists():
                window.lift()
                window.focus_set()
                return
            else:
                del self.open_windows[window_key]
        
        # Crear nueva ventana
        if isinstance(result, PlotResult):
            self._show_plot_window(result, window_key)
        elif isinstance(result, sympy.Matrix):
            self._show_matrix_window(result, window_key)
        elif isinstance(result, list):
            self._show_list_window(result, window_key)
        elif isinstance(result, dict):
            self._show_dict_window(result, window_key)
        else:
            self._show_object_window(result, window_key)
    
    def _show_plot_window(self, plot_result: 'PlotResult', window_key: str):
        """Muestra ventana con plot matplotlib"""
        window = self._create_base_window(f"Plot - {plot_result.plot_type}", "800x600")
        self.open_windows[window_key] = window
        
        try:
            fig, ax = plt.subplots(figsize=(8, 6))
            
            if plot_result.plot_type == "plot":
                self._create_2d_plot(fig, ax, plot_result.args, plot_result.kwargs)
            elif plot_result.plot_type == "plot3d":
                self._create_3d_plot(fig, plot_result.args, plot_result.kwargs)
            
            # Embed en tkinter
            canvas = FigureCanvasTkAgg(fig, window)
            canvas.draw()
            canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
            
        except Exception as e:
            error_label = tk.Label(
                window, 
                text=f"Error generando plot: {e}",
                fg="red",
                bg="#2b2b2b"
            )
            error_label.pack(pady=20)
    
    def _create_2d_plot(self, fig, ax, args, kwargs):
        """Crea plot 2D usando SymPy"""
        if len(args) >= 1:
            expr = args[0]
            
            if len(args) >= 2:
                # Rango especificado: (variable, start, end)
                var_range = args[1]
                if isinstance(var_range, tuple) and len(var_range) == 3:
                    var, start, end = var_range
                    x_vals = np.linspace(float(start), float(end), 1000)
                    
                    # Evaluar expresión
                    f = sympy.lambdify(var, expr, 'numpy')
                    y_vals = f(x_vals)
                    
                    ax.plot(x_vals, y_vals, **kwargs)
                    ax.set_xlabel(str(var))
                    ax.set_ylabel(str(expr))
                    ax.grid(True)
                    ax.set_title(f"Plot: {expr}")
            else:
                # Rango por defecto
                free_symbols = list(expr.free_symbols)
                if free_symbols:
                    var = free_symbols[0]
                    x_vals = np.linspace(-10, 10, 1000)
                    f = sympy.lambdify(var, expr, 'numpy')
                    y_vals = f(x_vals)
                    
                    ax.plot(x_vals, y_vals, **kwargs)
                    ax.set_xlabel(str(var))
                    ax.set_ylabel(str(expr))
                    ax.grid(True)
                    ax.set_title(f"Plot: {expr}")
    
    def _create_3d_plot(self, fig, args, kwargs):
        """Crea plot 3D"""
        ax = fig.add_subplot(111, projection='3d')
        
        if len(args) >= 3:
            expr = args[0]
            x_range = args[1]  # (x, x_start, x_end)
            y_range = args[2]  # (y, y_start, y_end)
            
            if isinstance(x_range, tuple) and isinstance(y_range, tuple):
                x_var, x_start, x_end = x_range
                y_var, y_start, y_end = y_range
                
                x_vals = np.linspace(float(x_start), float(x_end), 50)
                y_vals = np.linspace(float(y_start), float(y_end), 50)
                X, Y = np.meshgrid(x_vals, y_vals)
                
                f = sympy.lambdify([x_var, y_var], expr, 'numpy')
                Z = f(X, Y)
                
                ax.plot_surface(X, Y, Z, **kwargs)
                ax.set_xlabel(str(x_var))
                ax.set_ylabel(str(y_var))
                ax.set_zlabel(str(expr))
                ax.set_title(f"3D Plot: {expr}")
    
    def _show_matrix_window(self, matrix: sympy.Matrix, window_key: str):
        """Muestra ventana con matriz formateada"""
        rows, cols = matrix.shape
        window = self._create_base_window(f"Matriz {rows}×{cols}", "600x400")
        self.open_windows[window_key] = window
        
        # Crear frame con scroll
        frame = tk.Frame(window, bg="#2b2b2b")
        frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        text_widget = scrolledtext.ScrolledText(
            frame,
            font=("Courier New", 12),
            bg="#1e1e1e",
            fg="#d4d4d4",
            insertbackground="#ffffff",
            wrap=tk.NONE
        )
        text_widget.pack(fill=tk.BOTH, expand=True)
        
        # Formatear matriz
        matrix_str = self._format_matrix(matrix)
        text_widget.insert("1.0", matrix_str)
        text_widget.config(state="disabled")
        
        # Botones de utilidad
        button_frame = tk.Frame(window, bg="#2b2b2b")
        button_frame.pack(fill=tk.X, padx=10, pady=5)
        
        det_btn = tk.Button(
            button_frame,
            text="Determinante",
            command=lambda: self._show_matrix_property(matrix, "determinante", matrix.det()),
            bg="#3c3c3c",
            fg="white"
        )
        det_btn.pack(side=tk.LEFT, padx=5)
        
        if matrix.is_square:
            inv_btn = tk.Button(
                button_frame,
                text="Inversa",
                command=lambda: self._show_matrix_property(matrix, "inversa", matrix.inv()),
                bg="#3c3c3c",
                fg="white"
            )
            inv_btn.pack(side=tk.LEFT, padx=5)
    
    def _format_matrix(self, matrix: sympy.Matrix) -> str:
        """Formatea una matriz para display"""
        rows, cols = matrix.shape
        
        # Calcular ancho máximo de elementos
        max_width = 0
        for i in range(rows):
            for j in range(cols):
                element_str = str(matrix[i, j])
                max_width = max(max_width, len(element_str))
        
        # Construir representación
        lines = []
        lines.append("┌" + " " * (max_width * cols + cols - 1) + "┐")
        
        for i in range(rows):
            line = "│"
            for j in range(cols):
                element_str = str(matrix[i, j])
                padded = element_str.center(max_width)
                line += padded
                if j < cols - 1:
                    line += " "
            line += "│"
            lines.append(line)
        
        lines.append("└" + " " * (max_width * cols + cols - 1) + "┘")
        
        return "\n".join(lines)
    
    def _show_matrix_property(self, matrix: sympy.Matrix, prop_name: str, prop_value: Any):
        """Muestra propiedad de matriz en ventana separada"""
        prop_window = self._create_base_window(f"Matriz - {prop_name.title()}", "400x300")
        
        text_widget = scrolledtext.ScrolledText(
            prop_window,
            font=("Courier New", 12),
            bg="#1e1e1e",
            fg="#d4d4d4",
            insertbackground="#ffffff"
        )
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        if isinstance(prop_value, sympy.Matrix):
            content = f"{prop_name.title()}:\n\n{self._format_matrix(prop_value)}"
        else:
            content = f"{prop_name.title()}: {prop_value}"
        
        text_widget.insert("1.0", content)
        text_widget.config(state="disabled")
    
    def _show_list_window(self, lst: list, window_key: str):
        """Muestra ventana con lista expandida"""
        window = self._create_base_window(f"Lista ({len(lst)} elementos)", "500x400")
        self.open_windows[window_key] = window
        
        text_widget = scrolledtext.ScrolledText(
            window,
            font=("Consolas", 11),
            bg="#1e1e1e",
            fg="#d4d4d4",
            insertbackground="#ffffff"
        )
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        content = "Elementos de la lista:\n\n"
        for i, item in enumerate(lst):
            content += f"[{i}] {item}\n"
        
        text_widget.insert("1.0", content)
        text_widget.config(state="disabled")
    
    def _show_dict_window(self, dct: dict, window_key: str):
        """Muestra ventana con diccionario expandido"""
        window = self._create_base_window(f"Diccionario ({len(dct)} entradas)", "500x400")
        self.open_windows[window_key] = window
        
        text_widget = scrolledtext.ScrolledText(
            window,
            font=("Consolas", 11),
            bg="#1e1e1e",
            fg="#d4d4d4",
            insertbackground="#ffffff"
        )
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        content = "Entradas del diccionario:\n\n"
        for key, value in dct.items():
            content += f"{key}: {value}\n"
        
        text_widget.insert("1.0", content)
        text_widget.config(state="disabled")
    
    def _show_object_window(self, obj: Any, window_key: str):
        """Muestra ventana con detalles de objeto"""
        window = self._create_base_window(f"Objeto - {type(obj).__name__}", "600x500")
        self.open_windows[window_key] = window
        
        text_widget = scrolledtext.ScrolledText(
            window,
            font=("Consolas", 11),
            bg="#1e1e1e",
            fg="#d4d4d4",
            insertbackground="#ffffff"
        )
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        content = f"Objeto: {type(obj).__name__}\n\n"
        content += f"Valor: {obj}\n\n"
        content += f"Representación: {repr(obj)}\n\n"
        
        if hasattr(obj, '__dict__'):
            content += "Atributos:\n"
            for attr, value in obj.__dict__.items():
                content += f"  {attr}: {value}\n"
        
        content += "\nMétodos disponibles:\n"
        for attr in dir(obj):
            if not attr.startswith('_') and callable(getattr(obj, attr, None)):
                content += f"  {attr}()\n"
        
        text_widget.insert("1.0", content)
        text_widget.config(state="disabled")
    
    def _create_base_window(self, title: str, geometry: str = "500x400") -> Toplevel:
        """Crea ventana base con estilo consistente"""
        window = Toplevel(self.parent)
        window.title(title)
        window.geometry(geometry)
        window.configure(bg="#2b2b2b")
        window.transient(self.parent)
        
        # Centrar ventana
        window.update_idletasks()
        x = (window.winfo_screenwidth() // 2) - (window.winfo_width() // 2)
        y = (window.winfo_screenheight() // 2) - (window.winfo_height() // 2)
        window.geometry(f"+{x}+{y}")
        
        return window
    
    def close_all_windows(self):
        """Cierra todas las ventanas interactivas"""
        for window in self.open_windows.values():
            if window.winfo_exists():
                window.destroy()
        self.open_windows.clear()


# Importar PlotResult desde el motor de evaluación
class PlotResult:
    """Placeholder para resultados de plotting"""
    
    def __init__(self, plot_type: str, args: tuple, kwargs: dict):
        self.plot_type = plot_type
        self.args = args
        self.kwargs = kwargs
    
    def __str__(self):
        return f"📊 Ver {self.plot_type.title()}"
    
    def __repr__(self):
        return f"PlotResult('{self.plot_type}', {self.args}, {self.kwargs})"


# Función de testing
def test_interactive_results():
    """Test del sistema de resultados interactivos"""
    root = tk.Tk()
    root.title("Test Interactive Results")
    
    manager = InteractiveResultManager(root)
    
    # Crear widget de texto de prueba
    text_widget = tk.Text(root, height=20, width=80)
    text_widget.pack(padx=10, pady=10)
    
    # Test con matriz
    matrix = sympy.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    tag, display = manager.create_interactive_tag(matrix, text_widget, "1.0")
    text_widget.insert("end", f"Matriz test: {display}\n", tag)
    
    # Test con lista
    long_list = list(range(20))
    tag, display = manager.create_interactive_tag(long_list, text_widget, "2.0")
    text_widget.insert("end", f"Lista test: {display}\n", tag)
    
    # Test con plot
    plot_result = PlotResult("plot", (sympy.sin(sympy.Symbol('x')), (sympy.Symbol('x'), -10, 10)), {})
    tag, display = manager.create_interactive_tag(plot_result, text_widget, "3.0")
    text_widget.insert("end", f"Plot test: {display}\n", tag)
    
    root.mainloop()


if __name__ == "__main__":
    test_interactive_results()