# src/tab_coil.py

import tkinter as tk
from tkinter import ttk

import matplotlib
matplotlib.use("TkAgg")
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

import numpy as np
import math as m
import decimal as dec

# Importamos la función para dibujar la bobina 2D
from tabs.geometry_viewer import plot_coil_in_frame

class TabCoil:
    def __init__(self, notebook, tab_simulator):
        """
        Pestaña para representar la bobina en 2D y ajustar sus parámetros.
        Recibe:
          - notebook: el ttk.Notebook donde se añadirá
          - tab_simulator: referencia a TabSimulator, si se necesita comunicar
        """
        self.notebook = notebook
        self.tab_simulator = tab_simulator

        # Frame principal dentro del notebook
        self.frame = tk.Frame(notebook)
        self.frame.pack(fill="both", expand=True)

        # (Este add lo hace habitualmente main.py, pero se podría hacer aquí)
        # notebook.add(self.frame, text="Bobinas")

        # Layout principal: lado izq (parámetros) y lado der (dibujo)
        frame_left = tk.Frame(self.frame)
        frame_left.pack(side="left", fill="y", padx=5, pady=5)

        frame_right = tk.Frame(self.frame, bd=2, relief="groove")
        frame_right.pack(side="right", fill="both", expand=True, padx=5, pady=5)

        # Este frame contendrá el canvas/figura para la bobina en 2D
        self.frame_2d = tk.Frame(frame_right)
        self.frame_2d.pack(fill="both", expand=True)

        #
        # Sección Izquierda: parámetros de la bobina
        #
        tk.Label(frame_left, text="Parámetros de la Bobina:").pack(anchor="w")

        # Variables
        self.var_N     = tk.DoubleVar(value=500)
        self.var_e_pvc = tk.DoubleVar(value=4.04)
        self.var_r_int = tk.DoubleVar(value=12.07)
        self.var_r_ext = tk.DoubleVar(value=21.27)
        self.var_h_c   = tk.DoubleVar(value=53.12)
        self.var_d_cu  = tk.DoubleVar(value=0.8)
        
        mu_0 = 4 * m.pi * 1e-7
        mu_r = 1
        
        inductance = (self.var_N.get()**2 * mu_0 * mu_r * (2 * m.pi * (self.var_r_ext.get() * 1e-3)**2)) / (self.var_h_c.get() * 1e-3)
        self.var_L  = tk.DoubleVar(value=inductance)

        # Frame para agrupar los Entries
        self.frame_params = tk.Frame(frame_left, bd=1, relief="sunken")
        self.frame_params.pack(fill="x", pady=5)

        # Función auxiliar para añadir filas (etiqueta + entry)
        def add_param_row(label_text, var, row, width=8):
            lbl = tk.Label(self.frame_params, text=label_text)
            lbl.grid(row=row, column=0, sticky="w", padx=5, pady=2)
            ent = tk.Entry(self.frame_params, textvariable=var, width=width)
            ent.grid(row=row, column=1, padx=5, pady=2)

        # Creamos las filas
        rowcount = 0
        add_param_row("N (vueltas):",      self.var_N,     rowcount); rowcount += 1
        add_param_row("e_pvc (mm):",       self.var_e_pvc, rowcount); rowcount += 1
        add_param_row("r_int (mm):",       self.var_r_int, rowcount); rowcount += 1
        add_param_row("r_ext (mm):",       self.var_r_ext, rowcount); rowcount += 1
        add_param_row("h_c (mm):",         self.var_h_c,   rowcount); rowcount += 1
        add_param_row("d_cu (mm):",        self.var_d_cu,  rowcount); rowcount += 1
        add_param_row("L (H):",            self.var_L,     rowcount); rowcount += 1

        # Botón para actualizar la vista 2D
        btn_refrescar = tk.Button(
            frame_left, text="Refrescar Vista 2D",
            command=self.refrescar_2d
        )
        btn_refrescar.pack(pady=10)

        #
        # Creamos la figura y canvas para la bobina en 2D (opcional, 
        # pues 'plot_coil_in_frame' creará su propia Figure).
        #
        self.fig = plt.Figure(figsize=(4,3), dpi=100)
        self.ax = self.fig.add_subplot(111)
        self.canvas_2d = FigureCanvasTkAgg(self.fig, master=self.frame_2d)
        self.canvas_2d_widget = self.canvas_2d.get_tk_widget()
        self.canvas_2d_widget.pack(fill="both", expand=True)

        # Dibujamos la bobina inicial
        self.refrescar_2d()

    def refrescar_2d(self):
        """
        Lee los valores de la bobina y llama a 'plot_coil_in_frame'
        para actualizar el dibujo en 2D.
        """
        # Obtenemos valores
        N_val     = self.var_N.get()
        e_pvc_val = self.var_e_pvc.get()
        r_int_val = self.var_r_int.get()
        r_ext_val = self.var_r_ext.get()
        h_c_val   = self.var_h_c.get()
        d_cu_val  = self.var_d_cu.get()

        # Limpiamos el Axes actual (si lo usáramos)
        self.ax.clear()

        # Llamada a la función que inserta la figura en self.frame_2d
        plot_coil_in_frame(
            parent_frame=self.frame_2d,
            N=N_val,
            e_pvc=e_pvc_val,
            r_int=r_int_val,
            r_ext=r_ext_val,
            h_c=h_c_val,
            d_cu=d_cu_val
        )
