"""
Secret Generation Frame

UI component for secret generation form.
"""

import customtkinter as ctk
from typing import List, Dict, Callable, Optional
from ui.components.unified_dropdown import UnifiedDropdown


class SecretGenerationFrame(ctk.CTkFrame):
    """Frame for secret generation form."""

    def __init__(self, parent, on_generate: Callable = None):
        """
        Initialize the secret generation frame.

        Args:
            parent: Parent widget
            on_generate: Callback function when generate button is clicked
        """
        super().__init__(parent)

        self.on_generate = on_generate

        # Configure frame
        self.configure(corner_radius=10, border_width=2)

        # Title
        self.title_label = ctk.CTkLabel(
            self,
            text="Secret Generation",
            font=ctk.CTkFont(size=18, weight="bold")
        )
        self.title_label.grid(row=0, column=0, columnspan=2, padx=20, pady=(20, 15), sticky="w")

        # Secret Description Label
        self.description_label = ctk.CTkLabel(
            self,
            text="Secret Description:",
            font=ctk.CTkFont(size=14)
        )
        self.description_label.grid(row=1, column=0, columnspan=2, padx=20, pady=(0, 5), sticky="w")

        # Secret Description Entry
        self.description_entry = ctk.CTkEntry(
            self,
            placeholder_text="e.g., Production API Key 2025",
            height=40,
            font=ctk.CTkFont(size=14)
        )
        self.description_entry.grid(row=2, column=0, columnspan=2, padx=20, pady=(0, 15), sticky="ew")

        # Key Vault Dropdown (using UnifiedDropdown)
        self.vault_dropdown = UnifiedDropdown(
            self,
            title="Select Key Vault:",
            on_selection_changed=self._on_vault_selected,
            show_count=False,
            display_format=lambda v: f"{v['name']} (RG: {v['resource_group']})",
            max_dropdown_height=300,
            button_width=600,
            button_height=40
        )
        self.vault_dropdown.grid(row=3, column=0, columnspan=2, padx=0, pady=(0, 15), sticky="ew")

        # Remove old secrets checkbox
        self.remove_old_checkbox = ctk.CTkCheckBox(
            self,
            text="Remove old secrets after creating new one",
            font=ctk.CTkFont(size=14)
        )
        self.remove_old_checkbox.grid(row=4, column=0, columnspan=2, padx=20, pady=(0, 20), sticky="w")

        # Generate button
        self.generate_button = ctk.CTkButton(
            self,
            text="Generate Secret",
            command=self._on_generate_clicked,
            height=50,
            font=ctk.CTkFont(size=16, weight="bold"),
            state="disabled"
        )
        self.generate_button.grid(row=5, column=0, columnspan=2, padx=20, pady=(0, 20), sticky="ew")

        # Configure grid
        self.grid_columnconfigure(0, weight=1)

    def set_vaults(self, vaults: List[Dict[str, str]]):
        """
        Set the list of Key Vaults.

        Args:
            vaults: List of vault dictionaries with 'name' and 'resource_group'
        """
        self.vault_dropdown.set_items(vaults)

    def _on_vault_selected(self, vault: Dict):
        """Handle vault selection."""
        # Selection is stored in dropdown - no additional action needed
        pass

    def _on_generate_clicked(self):
        """Handle generate button click."""
        if self.on_generate:
            description = self.description_entry.get().strip()
            remove_old = self.remove_old_checkbox.get()
            vault = self.get_selected_vault()

            if description and vault:
                self.on_generate(description, vault, remove_old)

    def get_selected_vault(self) -> Optional[Dict[str, str]]:
        """
        Get the currently selected Key Vault.

        Returns:
            Dict: Selected vault or None
        """
        return self.vault_dropdown.get_selected()

    def get_description(self) -> str:
        """
        Get the secret description.

        Returns:
            str: Description text
        """
        return self.description_entry.get().strip()

    def get_remove_old_secrets(self) -> bool:
        """
        Get whether to remove old secrets.

        Returns:
            bool: True if checkbox is checked
        """
        return self.remove_old_checkbox.get()

    def set_enabled(self, enabled: bool):
        """
        Enable or disable the frame.

        Args:
            enabled: Whether to enable the frame
        """
        if enabled:
            self.description_entry.configure(state="normal")
            self.vault_dropdown.set_enabled(True)
            self.remove_old_checkbox.configure(state="normal")
            self.generate_button.configure(state="normal")
        else:
            self.description_entry.configure(state="disabled")
            self.vault_dropdown.set_enabled(False)
            self.remove_old_checkbox.configure(state="disabled")
            self.generate_button.configure(state="disabled")

    def set_generating(self, generating: bool):
        """
        Set generating state.

        Args:
            generating: Whether currently generating
        """
        if generating:
            self.generate_button.configure(state="disabled", text="Generating...")
        else:
            self.generate_button.configure(state="normal", text="Generate Secret")

    def set_loading_vaults(self, loading: bool):
        """
        Set loading vaults state.

        Args:
            loading: Whether currently loading
        """
        self.vault_dropdown.set_loading(loading)

    def reset(self):
        """Reset the form to initial state."""
        self.description_entry.delete(0, 'end')
        self.remove_old_checkbox.deselect()