"""
Sidebar — server list with groups, search, add/edit/delete buttons, context menu.
"""

import tkinter as tk
from tkinter import messagebox
import customtkinter as ctk
from core.i18n import t
from core.icons import (
    icon_text, TYPE_COLORS, TYPE_LABELS, CTX_ICONS, icon,
    make_icon_button, reconfigure_icon_button,
)
from gui.widgets.status_badge import StatusBadge

GROUP_COLORS = [
    "#ef4444", "#f97316", "#f59e0b", "#22c55e",
    "#3b82f6", "#6366f1", "#a855f7", "#ec4899",
]

# Context menu: type → list of (i18n_key, tab_key_or_None)
_CONTEXT_ACTIONS = {
    "ssh":        [("ctx_open_terminal", "terminal"), ("ctx_browse_files", "files"), ("ctx_install_key", "keys")],
    "telnet":     [("ctx_open_terminal", "terminal")],
    "winrm":      [("ctx_open_powershell", "powershell")],
    "mariadb":    [("ctx_open_query", "query")],
    "mssql":      [("ctx_open_query", "query")],
    "postgresql":  [("ctx_open_query", "query")],
    "redis":      [("ctx_open_console", "console")],
    "grafana":    [("ctx_open_browser", None)],
    "prometheus": [("ctx_open_browser", None)],
    "rdp":        [("ctx_connect", "launch")],
    "vnc":        [("ctx_connect", "launch")],
}


class Sidebar(ctk.CTkFrame):
    def __init__(self, master, store, on_select=None, session_pool=None):
        super().__init__(master, width=250, corner_radius=0)
        self.store = store
        self.on_select = on_select
        self.session_pool = session_pool
        self._selected_alias: str | None = None
        self._server_frames: dict[str, ctk.CTkFrame] = {}
        self._badges: dict[str, StatusBadge] = {}
        self._session_indicators: dict[str, ctk.CTkLabel] = {}
        self._group_headers: dict[str, ctk.CTkFrame] = {}

        self.pack_propagate(False)

        # Title
        self.title_label = ctk.CTkLabel(self, text=t("servers"), font=ctk.CTkFont(size=18, weight="bold"))
        self.title_label.pack(padx=15, pady=(15, 5))

        # Search + Add Group button
        search_frame = ctk.CTkFrame(self, fg_color="transparent")
        search_frame.pack(fill="x", padx=10, pady=(5, 10))

        self.search_var = ctk.StringVar()
        self.search_var.trace_add("write", lambda *_: self._refresh_list())
        self.search_entry = ctk.CTkEntry(search_frame, placeholder_text=t("search"), textvariable=self.search_var)
        self.search_entry.pack(side="left", fill="x", expand=True)

        self._add_group_btn = ctk.CTkButton(
            search_frame, text="+", width=30, height=30,
            font=ctk.CTkFont(size=14, weight="bold"),
            command=self._on_add_group,
        )
        self._add_group_btn.pack(side="right", padx=(5, 0))

        # Server list
        self.list_frame = ctk.CTkScrollableFrame(self, fg_color="transparent")
        self.list_frame.pack(fill="both", expand=True, padx=5, pady=0)

        # Active sessions label
        self._sessions_label = ctk.CTkLabel(
            self, text="", font=ctk.CTkFont(size=10),
            text_color="#6b7280", anchor="w"
        )
        self._sessions_label.pack(fill="x", padx=15, pady=(0, 2))

        # Buttons
        btn_frame = ctk.CTkFrame(self, fg_color="transparent")
        btn_frame.pack(fill="x", padx=10, pady=10)
        self.add_btn = make_icon_button(btn_frame, "add", t("add"), width=70, height=30, command=self._on_add)
        self.add_btn.pack(side="left", padx=(0, 3))
        self.edit_btn = make_icon_button(btn_frame, "edit", t("edit"), width=70, height=30, fg_color="#6b7280", command=self._on_edit)
        self.edit_btn.pack(side="left", padx=3)
        self.del_btn = make_icon_button(btn_frame, "delete", t("delete"), width=70, height=30, fg_color="#ef4444", hover_color="#dc2626", command=self._on_delete)
        self.del_btn.pack(side="right", padx=(3, 0))

        # Callbacks — set by app.py
        self.add_callback = None
        self.edit_callback = None
        self.delete_callback = None
        self.add_group_callback = None
        self.open_tab_callback = None       # (alias, tab_key) → select server + switch tab
        self.check_status_callback = None   # (alias) → check single server
        self.open_browser_callback = None   # (alias) → open server URL in browser

        # Subscribe to store changes
        self.store.subscribe(self._refresh_list)
        self._refresh_list()

    def update_language(self):
        self.title_label.configure(text=t("servers"))
        self.search_entry.configure(placeholder_text=t("search"))
        reconfigure_icon_button(self.add_btn, "add", t("add"))
        reconfigure_icon_button(self.edit_btn, "edit", t("edit"))
        reconfigure_icon_button(self.del_btn, "delete", t("delete"))
        self._update_sessions_label()

    # ── Refresh / Render ──────────────────────────────

    def _refresh_list(self):
        # Clear
        for widget in self.list_frame.winfo_children():
            widget.destroy()
        self._server_frames.clear()
        self._badges.clear()
        self._session_indicators.clear()
        self._group_headers.clear()

        active_aliases = self._get_active_aliases()
        search = self.search_var.get().lower()
        groups = self.store.get_groups()

        if not groups:
            # No groups — flat list (backward compatible)
            self._render_server_list(self.store.get_all(), search, active_aliases)
        else:
            # Grouped layout
            for group in groups:
                group_servers = self.store.get_servers_in_group(group["id"])
                filtered = self._filter_servers(group_servers, search)

                # Skip empty groups when searching
                if search and not filtered:
                    continue

                self._render_group_header(group, len(group_servers))

                # Show servers if not collapsed (or always when searching)
                if not group.get("collapsed") or search:
                    self._render_server_list(filtered, search, active_aliases, indent=True)

            # Ungrouped servers
            ungrouped = self.store.get_servers_in_group(None)
            filtered_ungrouped = self._filter_servers(ungrouped, search)
            if filtered_ungrouped:
                self._render_ungrouped_header(len(ungrouped))
                self._render_server_list(filtered_ungrouped, search, active_aliases, indent=True)

        self._highlight_selected()
        self._update_sessions_label()

    def _get_active_aliases(self) -> set:
        if self.session_pool:
            return set(self.session_pool.get_active_sessions())
        return set()

    def _filter_servers(self, servers: list[dict], search: str) -> list[dict]:
        if not search:
            return servers
        return [s for s in servers
                if search in s["alias"].lower() or search in s.get("ip", "").lower()]

    def _render_group_header(self, group: dict, total_count: int):
        """Render a collapsible group header."""
        frame = ctk.CTkFrame(self.list_frame, height=32,
                             fg_color=("gray90", "gray17"), cursor="hand2")
        frame.pack(fill="x", padx=2, pady=(6, 1))
        frame.pack_propagate(False)

        # Collapse arrow
        arrow_text = "\u25bc" if not group.get("collapsed") else "\u25b6"
        arrow = ctk.CTkLabel(frame, text=arrow_text, width=16,
                             font=ctk.CTkFont(size=10), text_color="#9ca3af")
        arrow.pack(side="left", padx=(8, 2))

        # Color dot
        color_dot = ctk.CTkLabel(frame, text="\u25cf", width=14,
                                 font=ctk.CTkFont(size=12),
                                 text_color=group.get("color", "#6b7280"))
        color_dot.pack(side="left", padx=(0, 4))

        # Group name
        name_label = ctk.CTkLabel(frame, text=group["name"],
                                  font=ctk.CTkFont(size=12, weight="bold"),
                                  anchor="w")
        name_label.pack(side="left", fill="x", expand=True)

        # Count badge
        count_label = ctk.CTkLabel(frame, text=f"({total_count})",
                                   font=ctk.CTkFont(size=10),
                                   text_color="#6b7280", width=30)
        count_label.pack(side="right", padx=(0, 8))

        # Click handlers
        gid = group["id"]
        for widget in [frame, arrow, color_dot, name_label, count_label]:
            widget.bind("<Button-1>", lambda e, g=gid: self._toggle_group(g))
            widget.bind("<Button-3>", lambda e, g=gid: self._show_group_context_menu(e, g))

        self._group_headers[gid] = frame

    def _render_ungrouped_header(self, total_count: int):
        """Render a non-collapsible 'Ungrouped' header."""
        frame = ctk.CTkFrame(self.list_frame, height=28,
                             fg_color="transparent")
        frame.pack(fill="x", padx=2, pady=(6, 1))
        frame.pack_propagate(False)

        ctk.CTkLabel(frame, text=t("ungrouped"),
                     font=ctk.CTkFont(size=11), text_color="#6b7280",
                     anchor="w").pack(side="left", padx=(10, 0))
        ctk.CTkLabel(frame, text=f"({total_count})",
                     font=ctk.CTkFont(size=10), text_color="#6b7280",
                     width=30).pack(side="right", padx=(0, 8))

    def _render_server_list(self, servers: list[dict], search: str,
                            active_aliases: set, indent: bool = False):
        """Render server items. If indent=True, add left padding for group nesting."""
        pad_left = 12 if indent else 2

        for server in servers:
            alias = server["alias"]
            ip = server.get("ip", "")
            stype = server.get("type", "ssh")

            frame = ctk.CTkFrame(self.list_frame, cursor="hand2", height=45)
            frame.pack(fill="x", padx=(pad_left, 2), pady=2)
            frame.pack_propagate(False)

            # Status badge
            badge = StatusBadge(frame, status=self.store.get_status(alias))
            badge.pack(side="left", padx=(10, 5), pady=10)
            self._badges[alias] = badge

            # Type badge (colored short label)
            type_color = TYPE_COLORS.get(stype, "#6b7280")
            type_label_text = TYPE_LABELS.get(stype, stype.upper()[:3])
            type_badge = ctk.CTkLabel(
                frame, text=type_label_text,
                font=ctk.CTkFont(size=9, weight="bold"),
                text_color=type_color, width=30
            )
            type_badge.pack(side="left", padx=(0, 2), pady=10)

            # Active session indicator (right side)
            session_ind = ctk.CTkLabel(
                frame, text="", width=12, height=12,
                font=ctk.CTkFont(size=8)
            )
            session_ind.pack(side="right", padx=(0, 8), pady=10)
            if alias in active_aliases:
                session_ind.configure(text="\u25cf", text_color="#22c55e")
            self._session_indicators[alias] = session_ind

            # Info
            info = ctk.CTkFrame(frame, fg_color="transparent")
            info.pack(side="left", fill="both", expand=True, padx=5)

            name_label = ctk.CTkLabel(info, text=alias,
                                      font=ctk.CTkFont(size=13, weight="bold"),
                                      anchor="w")
            name_label.pack(fill="x")
            detail_label = ctk.CTkLabel(info, text=ip,
                                        font=ctk.CTkFont(size=10),
                                        text_color="#9ca3af", anchor="w")
            detail_label.pack(fill="x")

            # Click handlers
            for widget in [frame, info, name_label, detail_label, badge, type_badge, session_ind]:
                widget.bind("<Button-1>", lambda e, a=alias: self._select(a))
                widget.bind("<Button-3>", lambda e, a=alias: self._show_context_menu(e, a))

            self._server_frames[alias] = frame

    # ── Group operations ──────────────────────────────

    def _toggle_group(self, group_id: str):
        """Toggle collapse/expand for a group."""
        group = self.store.get_group(group_id)
        if group:
            self.store.update_group(group_id, collapsed=not group.get("collapsed", False))

    def _on_add_group(self):
        """Open GroupDialog to create a new group."""
        if self.add_group_callback:
            self.add_group_callback()

    def _show_group_context_menu(self, event, group_id: str):
        """Right-click context menu for a group header."""
        group = self.store.get_group(group_id)
        if not group:
            return

        menu = tk.Menu(self, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
                       activebackground="#44447a", activeforeground="#ffffff",
                       font=("Segoe UI", 10))

        menu.add_command(label=t("rename_group"),
                         command=lambda: self._rename_group(group_id))

        # Color submenu
        color_menu = tk.Menu(menu, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
                             activebackground="#44447a", activeforeground="#ffffff",
                             font=("Segoe UI", 10))
        for color in GROUP_COLORS:
            # Show colored dot + hex
            color_menu.add_command(
                label=f"\u25cf  {color}",
                command=lambda c=color: self.store.update_group(group_id, color=c),
            )
        menu.add_cascade(label=t("change_color"), menu=color_menu)

        menu.add_separator()

        groups = self.store.get_groups()
        idx = next((i for i, g in enumerate(groups) if g["id"] == group_id), -1)
        if idx > 0:
            menu.add_command(label=t("move_up"),
                             command=lambda: self._move_group(group_id, -1))
        if idx < len(groups) - 1:
            menu.add_command(label=t("move_down"),
                             command=lambda: self._move_group(group_id, 1))

        menu.add_separator()

        menu.add_command(label=t("delete_group"),
                         command=lambda: self._delete_group(group_id),
                         foreground="#ef4444")

        try:
            menu.tk_popup(event.x_root, event.y_root)
        finally:
            menu.grab_release()

    def _rename_group(self, group_id: str):
        """Open GroupDialog in edit mode."""
        from gui.group_dialog import GroupDialog
        group = self.store.get_group(group_id)
        if group:
            dialog = GroupDialog(self.winfo_toplevel(), self.store, group=group)
            self.winfo_toplevel().wait_window(dialog)

    def _delete_group(self, group_id: str):
        """Delete group after confirmation."""
        group = self.store.get_group(group_id)
        if not group:
            return
        msg = t("delete_group_confirm").format(name=group["name"])
        if messagebox.askyesno(t("delete_group"), msg):
            self.store.remove_group(group_id)

    def _move_group(self, group_id: str, direction: int):
        """Move group up (-1) or down (+1)."""
        groups = self.store.get_groups()
        ids = [g["id"] for g in groups]
        idx = ids.index(group_id)
        new_idx = idx + direction
        if 0 <= new_idx < len(ids):
            ids[idx], ids[new_idx] = ids[new_idx], ids[idx]
            self.store.reorder_groups(ids)

    # ── Server selection ──────────────────────────────

    def _select(self, alias: str):
        self._selected_alias = alias
        self._highlight_selected()
        if self.on_select:
            self.on_select(alias)

    def _highlight_selected(self):
        for alias, frame in self._server_frames.items():
            if alias == self._selected_alias:
                frame.configure(fg_color=("#3b82f6", "#1d4ed8"))
            else:
                frame.configure(fg_color=("gray85", "gray20"))

    def get_selected(self) -> str | None:
        return self._selected_alias

    # ── Status / sessions ─────────────────────────────

    def update_statuses(self):
        for alias, badge in self._badges.items():
            badge.set_status(self.store.get_status(alias))

    def update_session_indicators(self):
        if not self.session_pool:
            return
        active_aliases = set(self.session_pool.get_active_sessions())
        for alias, ind in self._session_indicators.items():
            if alias in active_aliases:
                ind.configure(text="\u25cf", text_color="#22c55e")
            else:
                ind.configure(text="")
        self._update_sessions_label()

    def _update_sessions_label(self):
        if self.session_pool:
            count = len(self.session_pool.get_active_sessions())
            if count > 0:
                self._sessions_label.configure(text=t("active_sessions").format(count=count))
            else:
                self._sessions_label.configure(text="")
        else:
            self._sessions_label.configure(text="")

    # ── Buttons ───────────────────────────────────────

    def _on_add(self):
        if self.add_callback:
            self.add_callback()

    def _on_edit(self):
        if self.edit_callback and self._selected_alias:
            self.edit_callback(self._selected_alias)

    def _on_delete(self):
        if self.delete_callback and self._selected_alias:
            self.delete_callback(self._selected_alias)

    # ── Context menu (server) ─────────────────────────

    def _show_context_menu(self, event, alias: str):
        """Show right-click context menu for a server item."""
        self._select(alias)

        server = self.store.get_server(alias)
        if not server:
            return
        stype = server.get("type", "ssh")

        menu = tk.Menu(self, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
                       activebackground="#44447a", activeforeground="#ffffff",
                       font=("Segoe UI", 10))

        # Type-specific actions
        actions = _CONTEXT_ACTIONS.get(stype, [])
        for label_key, tab_key in actions:
            ctx_icon = icon(CTX_ICONS.get(label_key, ""))
            label_text = f"{ctx_icon} {t(label_key)}" if ctx_icon else t(label_key)
            if tab_key:
                menu.add_command(
                    label=label_text,
                    command=lambda a=alias, tk=tab_key: (
                        self.open_tab_callback(a, tk) if self.open_tab_callback else None
                    ),
                )
            else:
                menu.add_command(
                    label=label_text,
                    command=lambda a=alias: (
                        self.open_browser_callback(a) if self.open_browser_callback else None
                    ),
                )

        if actions:
            menu.add_separator()

        # "Move to Group" submenu
        groups = self.store.get_groups()
        if groups:
            move_menu = tk.Menu(menu, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
                                activebackground="#44447a", activeforeground="#ffffff",
                                font=("Segoe UI", 10))
            for g in groups:
                move_menu.add_command(
                    label=f"\u25cf {g['name']}",
                    command=lambda a=alias, gid=g["id"]: self.store.set_server_group(a, gid),
                )
            move_menu.add_separator()
            move_menu.add_command(
                label=t("no_group"),
                command=lambda a=alias: self.store.set_server_group(a, None),
            )
            menu.add_cascade(label=t("move_to_group"), menu=move_menu)
            menu.add_separator()

        # Universal actions
        menu.add_command(
            label=icon_text("status_check", t("ctx_check_status")),
            command=lambda: (
                self.check_status_callback(alias) if self.check_status_callback else None
            ),
        )
        menu.add_command(
            label=icon_text("copy", t("ctx_copy_alias")),
            command=lambda: self._copy_alias(alias),
        )

        menu.add_separator()

        # Management
        menu.add_command(
            label=icon_text("edit", t("edit")),
            command=lambda: self.edit_callback(alias) if self.edit_callback else None,
        )
        menu.add_command(
            label=icon_text("delete", t("delete")),
            command=lambda: self.delete_callback(alias) if self.delete_callback else None,
            foreground="#ef4444",
        )

        try:
            menu.tk_popup(event.x_root, event.y_root)
        finally:
            menu.grab_release()

    def _copy_alias(self, alias: str):
        """Copy server alias to clipboard."""
        self.clipboard_clear()
        self.clipboard_append(alias)