# FlightMonitor/gui/panels/function_notebook_panel.py
"""
Panel managing the area profiles, data logging controls, BBox input,
and the function notebooks (Live, Historical, etc.).
"""
import tkinter as tk
from tkinter import ttk, messagebox, font as tkFont
from typing import Dict, Any, Optional, Tuple
import os

try:
    from PIL import Image, ImageTk

    PIL_AVAILABLE = True
except ImportError:
    PIL_AVAILABLE = False

from flightmonitor.utils.logger import get_logger
from flightmonitor.data import config as app_config
from flightmonitor.map.map_utils import _is_valid_bbox_dict
from flightmonitor.data.area_profile_manager import DEFAULT_PROFILE_NAME
from flightmonitor.gui.panels.historical_download_panel import HistoricalDownloadPanel
from flightmonitor.gui.panels.data_logging_panel import DataLoggingPanel
from flightmonitor.gui.panels.playback_panel import PlaybackPanel

module_logger = get_logger(__name__)

ICON_PATH = os.path.join(os.path.dirname(__file__), "..", "..", "assets", "icons")
PLAY_ICON_PATH = os.path.join(ICON_PATH, "play_icon.png")
STOP_ICON_PATH = os.path.join(ICON_PATH, "stop_icon.png")

COLOR_START_BG = "#28a745"
COLOR_START_ACTIVE = "#218838"
COLOR_STOP_BG = "#dc3545"
COLOR_STOP_ACTIVE = "#c82333"
COLOR_DISABLED_BG = "#e0e0e0"
COLOR_DISABLED_FG = "#a0a0a0"
COLOR_TEXT = "white"


class FunctionNotebookPanel:
    """
    Manages the combined Area Profiles, Data Logging, BBox,
    and Function Notebooks panel.
    """

    def __init__(self, parent_frame: ttk.Frame, controller: Any):
        self.parent_frame = parent_frame
        self.controller = controller

        self.historical_panel: Optional[HistoricalDownloadPanel] = None
        self.data_logging_panel: Optional[DataLoggingPanel] = None
        self.playback_panel: Optional[PlaybackPanel] = None

        self.play_icon: Optional[ImageTk.PhotoImage] = None
        self.stop_icon: Optional[ImageTk.PhotoImage] = None

        self.lat_min_var = tk.StringVar()
        self.lon_min_var = tk.StringVar()
        self.lat_max_var = tk.StringVar()
        self.lon_max_var = tk.StringVar()
        self.selected_profile_var = tk.StringVar()

        self._build_ui()
        self.update_profile_list()

        self.set_selected_profile(DEFAULT_PROFILE_NAME)

        module_logger.debug("FunctionNotebookPanel (container) initialized.")

    def _load_icons(self):
        if not PIL_AVAILABLE:
            return
        try:
            icon_size = (24, 24)
            play_img = Image.open(PLAY_ICON_PATH).resize(
                icon_size, Image.Resampling.LANCZOS
            )
            self.play_icon = ImageTk.PhotoImage(play_img)

            stop_img = Image.open(STOP_ICON_PATH).resize(
                icon_size, Image.Resampling.LANCZOS
            )
            self.stop_icon = ImageTk.PhotoImage(stop_img)
        except Exception as e:
            module_logger.warning(
                f"Could not load icons: {e}. Buttons will be text-only."
            )

    def _build_ui(self):
        """
        Builds the UI by creating and packing the Area, Logging, and Function Notebook panels.
        """
        self._load_icons()
        button_font = tkFont.Font(family="Helvetica", size=10, weight="bold")

        area_frame = ttk.LabelFrame(
            self.parent_frame, text="Area Profiles & BBox", padding=10
        )
        area_frame.pack(side=tk.TOP, fill=tk.X, expand=False, padx=2, pady=(0, 0))
        area_frame.columnconfigure(1, weight=1)
        area_frame.columnconfigure(3, weight=1)

        profile_controls_frame = ttk.Frame(area_frame)
        profile_controls_frame.grid(
            row=0, column=0, columnspan=4, sticky="ew", pady=(0, 10)
        )
        profile_controls_frame.columnconfigure(0, weight=1)
        self.profile_combobox = ttk.Combobox(
            profile_controls_frame,
            textvariable=self.selected_profile_var,
            state="readonly",
        )
        self.profile_combobox.grid(row=0, column=0, sticky="ew", padx=(0, 5))
        self.profile_combobox.bind("<<ComboboxSelected>>", self._on_profile_selected)
        new_button = ttk.Button(
            profile_controls_frame, text="New", command=self._on_new_profile, width=5
        )
        new_button.grid(row=0, column=1, padx=(0, 2))
        save_button = ttk.Button(
            profile_controls_frame, text="Save", command=self._on_save_profile, width=5
        )
        save_button.grid(row=0, column=2, padx=(0, 2))
        delete_button = ttk.Button(
            profile_controls_frame,
            text="Delete",
            command=self._on_delete_profile,
            width=7,
        )
        delete_button.grid(row=0, column=3)
        ttk.Label(area_frame, text="Lat Min:").grid(
            row=1, column=0, padx=(0, 2), pady=2, sticky=tk.W
        )
        self.lat_min_entry = ttk.Entry(area_frame, textvariable=self.lat_min_var)
        self.lat_min_entry.grid(row=1, column=1, padx=(0, 5), pady=2, sticky=tk.EW)
        ttk.Label(area_frame, text="Lon Min:").grid(
            row=1, column=2, padx=(5, 2), pady=2, sticky=tk.W
        )
        self.lon_min_entry = ttk.Entry(area_frame, textvariable=self.lon_min_var)
        self.lon_min_entry.grid(row=1, column=3, padx=(0, 0), pady=2, sticky=tk.EW)
        ttk.Label(area_frame, text="Lat Max:").grid(
            row=2, column=0, padx=(0, 2), pady=2, sticky=tk.W
        )
        self.lat_max_entry = ttk.Entry(area_frame, textvariable=self.lat_max_var)
        self.lat_max_entry.grid(row=2, column=1, padx=(0, 5), pady=2, sticky=tk.EW)
        ttk.Label(area_frame, text="Lon Max:").grid(
            row=2, column=2, padx=(5, 2), pady=2, sticky=tk.W
        )
        self.lon_max_entry = ttk.Entry(area_frame, textvariable=self.lon_max_var)
        self.lon_max_entry.grid(row=2, column=3, padx=(0, 0), pady=2, sticky=tk.EW)

        self.data_logging_panel = DataLoggingPanel(self.parent_frame, self.controller)

        self.function_notebook = ttk.Notebook(self.parent_frame)
        self.function_notebook.pack(
            side=tk.TOP, fill=tk.BOTH, expand=True, padx=2, pady=2
        )

        live_tab_frame = ttk.Frame(self.function_notebook, padding=(10, 10, 10, 10))
        self.function_notebook.add(live_tab_frame, text="Live Monitor")

        button_container = ttk.Frame(live_tab_frame)
        button_container.pack(side=tk.TOP, fill=tk.X, expand=False, anchor="n")
        button_container.columnconfigure(0, weight=1)
        button_container.columnconfigure(3, weight=1)

        self.start_live_button = tk.Button(
            button_container,
            text="Start Live",
            image=self.play_icon,
            compound=tk.LEFT,
            command=self._on_start_live_monitoring,
            font=button_font,
            bg=COLOR_START_BG,
            fg=COLOR_TEXT,
            activebackground=COLOR_START_ACTIVE,
            activeforeground=COLOR_TEXT,
            relief=tk.RAISED,
            borderwidth=2,
            padx=10,
            pady=5,
        )
        self.start_live_button.grid(row=0, column=1, padx=15, pady=5)

        self.stop_live_button = tk.Button(
            button_container,
            text="Stop Live",
            image=self.stop_icon,
            compound=tk.LEFT,
            command=self._on_stop_live_monitoring,
            font=button_font,
            bg=COLOR_DISABLED_BG,
            fg=COLOR_DISABLED_FG,
            activebackground=COLOR_DISABLED_BG,
            activeforeground=COLOR_DISABLED_FG,
            state=tk.DISABLED,
            relief=tk.RAISED,
            borderwidth=2,
            padx=10,
            pady=5,
        )
        self.stop_live_button.grid(row=0, column=2, padx=15, pady=5)

        download_tab_frame = ttk.Frame(self.function_notebook)
        self.function_notebook.add(download_tab_frame, text="Historical Download")
        self.historical_panel = HistoricalDownloadPanel(
            download_tab_frame, self.controller
        )

        playback_tab_frame = ttk.Frame(self.function_notebook)
        self.function_notebook.add(playback_tab_frame, text="Playback")
        self.playback_panel = PlaybackPanel(playback_tab_frame, self.controller)

        self.function_notebook.bind("<<NotebookTabChanged>>", self._on_tab_change)

    def set_monitoring_button_states(self, is_monitoring_active: bool):
        if is_monitoring_active:
            self.start_live_button.config(
                state=tk.DISABLED, bg=COLOR_DISABLED_BG, fg=COLOR_DISABLED_FG
            )
            self.stop_live_button.config(
                state=tk.NORMAL, bg=COLOR_STOP_BG, fg=COLOR_TEXT
            )
        else:
            self.start_live_button.config(
                state=tk.NORMAL, bg=COLOR_START_BG, fg=COLOR_TEXT
            )
            self.stop_live_button.config(
                state=tk.DISABLED, bg=COLOR_DISABLED_BG, fg=COLOR_DISABLED_FG
            )

    def set_controls_state(self, enabled: bool):
        state = tk.NORMAL if enabled else tk.DISABLED
        readonly_state = "readonly" if enabled else tk.DISABLED
        self.profile_combobox.config(state=readonly_state)
        for entry in [
            self.lat_min_entry,
            self.lon_min_entry,
            self.lat_max_entry,
            self.lon_max_entry,
        ]:
            if entry.winfo_exists():
                entry.config(state=state)
        for child in self.profile_combobox.master.winfo_children():
            if isinstance(child, ttk.Button):
                child.config(state=state)

    def set_logging_controls_state(self, enabled: bool):
        if self.data_logging_panel:
            state = tk.NORMAL if enabled else tk.DISABLED
            for child in self.data_logging_panel.parent_frame.winfo_children():
                if hasattr(child, "configure"):
                    child.configure(state=state)

    def get_logging_panel_settings(self) -> Optional[Dict[str, Any]]:
        if self.data_logging_panel:
            return {
                "enabled": self.data_logging_panel.is_logging_enabled(),
                "directory": self.data_logging_panel.get_log_directory(),
            }
        return None

    def clear_all_panel_data(self):
        if self.data_logging_panel:
            self.data_logging_panel.clear_summary_table()

    def update_logging_panel_settings(self, settings: Dict[str, Any]):
        if self.data_logging_panel:
            self.data_logging_panel.update_settings(
                enabled=settings.get("enabled", False),
                directory=settings.get("directory", ""),
            )

    def _on_start_live_monitoring(self):
        if self.controller:
            self.controller.start_live_monitoring()

    def _on_stop_live_monitoring(self):
        if self.controller:
            self.controller.stop_live_monitoring()

    def _on_profile_selected(self, event=None):
        selected_name = self.selected_profile_var.get()
        if selected_name and self.controller:
            self.controller.load_area_profile(selected_name)

    def _on_new_profile(self):
        self.selected_profile_var.set("")
        self.update_bbox_gui_fields({})

    def _on_save_profile(self):
        if self.controller:
            self.controller.save_current_area_as_profile()

    def _on_delete_profile(self):
        profile_to_delete = self.selected_profile_var.get()
        if not profile_to_delete or profile_to_delete == DEFAULT_PROFILE_NAME:
            messagebox.showerror(
                "Delete Error",
                "Cannot delete the default profile or no profile selected.",
                parent=self.parent_frame,
            )
            return
        if messagebox.askyesno(
            "Confirm Delete",
            f"Delete profile '{profile_to_delete}'?",
            parent=self.parent_frame,
        ):
            if self.controller:
                self.controller.delete_area_profile(profile_to_delete)

    def _on_tab_change(self, event=None):
        if self.function_notebook:
            try:
                tab_text = self.function_notebook.tab(
                    self.function_notebook.index("current"), "text"
                )
                if self.controller:
                    self.controller.on_function_tab_changed(tab_text)
            except tk.TclError:
                pass

    def update_profile_list(self):
        if self.controller:
            profile_names = self.controller.get_profile_names()
            self.profile_combobox["values"] = profile_names
            self.set_selected_profile(
                self.selected_profile_var.get() or DEFAULT_PROFILE_NAME
            )

    def set_selected_profile(self, profile_name: str):
        if (
            self.profile_combobox["values"]
            and profile_name in self.profile_combobox["values"]
        ):
            self.selected_profile_var.set(profile_name)
        elif self.profile_combobox["values"]:
            self.selected_profile_var.set(self.profile_combobox["values"][0])

    def get_bounding_box_input(self):
        try:
            bbox_candidate = {
                "lat_min": float(self.lat_min_var.get()),
                "lon_min": float(self.lon_min_var.get()),
                "lat_max": float(self.lat_max_var.get()),
                "lon_max": float(self.lon_max_var.get()),
            }
            return bbox_candidate if _is_valid_bbox_dict(bbox_candidate) else None
        except (ValueError, TypeError):
            return None

    def update_bbox_gui_fields(self, bbox_dict: Dict[str, float]):
        if bbox_dict and _is_valid_bbox_dict(bbox_dict):
            decimals = getattr(app_config, "COORDINATE_DECIMAL_PLACES", 5)
            self.lat_min_var.set(f"{bbox_dict['lat_min']:.{decimals}f}")
            self.lon_min_var.set(f"{bbox_dict['lon_min']:.{decimals}f}")
            self.lat_max_var.set(f"{bbox_dict['lat_max']:.{decimals}f}")
            self.lon_max_var.set(f"{bbox_dict['lon_max']:.{decimals}f}")
        else:
            self.lat_min_var.set(""), self.lon_min_var.set(""), self.lat_max_var.set(
                ""
            ), self.lon_max_var.set("")