"""Các hộp thoại: đăng nhập, thiết bị, quét mạng, rollback, chi tiết kết quả."""
from __future__ import annotations

import re
import threading
import tkinter as tk
from tkinter import messagebox, ttk
from typing import Optional

from core import scanner
from core.importer import validate_host
from core.security import AuthError
from drivers.sim_catalog import Choice, build_choices, filter_choices, find_choice
from drivers.vendors import VENDORS, vendor_labels
from .widgets import ScrollableFrame, clear_tree, fit_dialog, make_text, make_tree, scaled_geometry, set_text


def _grab(top: tk.Toplevel) -> None:
    try:
        top.wait_visibility()
        top.grab_set()
    except tk.TclError:
        pass


def _modal(top: tk.Toplevel, parent: tk.Misc) -> None:
    top.transient(parent)
    _grab(top)
    top.focus_set()
    parent.wait_window(top)


def _center(top: tk.Toplevel, parent: tk.Misc, w: int = 0, h: int = 0) -> None:
    """Để cửa sổ tự co theo nội dung (không ép kích thước), rồi căn giữa."""
    top.update_idletasks()
    try:
        rw, rh = int(top.winfo_reqwidth()), int(top.winfo_reqheight())
        sw, sh = int(top.winfo_screenwidth()), int(top.winfo_screenheight())
        rw, rh = min(rw + 24, sw - 60), min(rh + 24, sh - 110)
        try:
            visible = bool(parent.winfo_viewable())
        except tk.TclError:
            visible = False
        if visible:
            x = parent.winfo_rootx() + max(0, (parent.winfo_width() - rw) // 2)
            y = parent.winfo_rooty() + max(0, (parent.winfo_height() - rh) // 3)
        else:   # cửa sổ gốc đang ẩn (lúc đăng nhập) -> căn giữa màn hình
            x, y = max(0, (sw - rw) // 2), max(0, (sh - rh) // 3)
        top.geometry(f"{rw}x{rh}+{max(0, x)}+{max(0, y)}")
        top.minsize(rw, rh)
    except (TypeError, ValueError, tk.TclError):
        pass


# ---------------------------------------------------------------------------
class LoginDialog:
    """Đăng nhập, hoặc tạo tài khoản Admin ở lần chạy đầu tiên."""

    def __init__(self, root: tk.Tk, vault):
        self.vault, self.root, self.user = vault, root, None
        self.first = not vault.initialized()
        top = self.top = tk.Toplevel(root)
        top.title("Tạo tài khoản quản trị" if self.first else "Đăng nhập")
        top.protocol("WM_DELETE_WINDOW", self._cancel)
        frm = ttk.Frame(top, padding=26)
        frm.pack(fill="both", expand=True)
        ttk.Label(frm, text="NetAutoConfig", style="Title.TLabel").grid(row=0, column=0, columnspan=2, sticky="w")
        ttk.Label(frm, style="Muted.TLabel", wraplength=420, justify="left", text=(
            "Lần đầu sử dụng: hãy tạo tài khoản quản trị. Mật khẩu này dùng để mã hóa mật khẩu các thiết bị - "
            "KHÔNG thể khôi phục nếu quên." if self.first else "Đăng nhập để tiếp tục.")
        ).grid(row=1, column=0, columnspan=2, sticky="w", pady=(2, 14))
        self.u, self.p, self.p2 = tk.StringVar(value="admin"), tk.StringVar(), tk.StringVar()
        ttk.Label(frm, text="Tên đăng nhập").grid(row=2, column=0, sticky="w", pady=4)
        eu = ttk.Entry(frm, textvariable=self.u, width=32)
        eu.grid(row=2, column=1, pady=4)
        ttk.Label(frm, text="Mật khẩu").grid(row=3, column=0, sticky="w", pady=4)
        ep = ttk.Entry(frm, textvariable=self.p, show="*", width=32)
        ep.grid(row=3, column=1, pady=4)
        if self.first:
            ttk.Label(frm, text="Nhập lại mật khẩu").grid(row=4, column=0, sticky="w", pady=4)
            e2 = ttk.Entry(frm, textvariable=self.p2, show="*", width=32)
            e2.grid(row=4, column=1, pady=4)
            e2.bind("<Return>", lambda _e: self._ok())
            ttk.Label(frm, text="Tối thiểu 8 ký tự.", style="Muted.TLabel").grid(row=5, column=1, sticky="w")
        ep.bind("<Return>", lambda _e: self._ok())
        self.msg = ttk.Label(frm, text="", foreground="#dc2626")
        self.msg.grid(row=6, column=0, columnspan=2, sticky="w", pady=(8, 0))
        bar = ttk.Frame(frm)
        bar.grid(row=7, column=0, columnspan=2, sticky="e", pady=(12, 0))
        ttk.Button(bar, text="Thoát", command=self._cancel).pack(side="right", padx=(6, 0))
        ttk.Button(bar, text="Tạo tài khoản" if self.first else "Đăng nhập", style="Accent.TButton",
                   command=self._ok).pack(side="right")
        (ep if not self.first else eu).focus_set()
        _center(top, root)
        _grab(top)

    def _ok(self) -> None:
        try:
            if self.first:
                if self.p.get() != self.p2.get():
                    raise AuthError("Hai mật khẩu không khớp.")
                self.user = self.vault.initialize(self.u.get(), self.p.get())
            else:
                self.user = self.vault.login(self.u.get(), self.p.get())
            self.top.destroy()
        except AuthError as e:
            self.msg.configure(text=str(e))
            self.p.set("")

    def _cancel(self) -> None:
        self.user = None
        self.top.destroy()

    def run(self) -> Optional[dict]:
        self.root.wait_window(self.top)
        return self.user


# ---------------------------------------------------------------------------
SIM_NOTES = {
    "ios": "Cấu hình thụt lề, khối interface/vlan, phủ định bằng 'no'", "nxos": "Như IOS, thêm 'feature' và khối hsrp lồng nhau",
    "cisco_ap": "Cisco IOS cho AP (dot11 ssid, Dot11Radio)", "junos": "Lệnh set/delete, áp dụng toàn bộ hoặc không (như commit)",
    "aruba_os": "Cú pháp ArubaOS-Switch (hostname \"x\", vlan N untagged...)", "comware": "Khối interface/vlan, phủ định bằng 'undo', quit",
    "huawei": "VRP: sysname, port default vlan, phủ định bằng 'undo'", "mikrotik": "/đường-dẫn add|set|remove, xuất theo nhánh",
    "openwrt": "Lệnh uci set / uci commit / wifi reload", "fortinet": "Khối config / edit / set / next / end",
    "tplink": "JetStream: vlan N, interface gigabitEthernet", "generic": "Mô phỏng kiểu IOS (chưa có bộ mô phỏng riêng)",
}


class DeviceDialog:
    """Thêm/sửa thiết bị. Ô 'Hãng / dòng thiết bị' gộp cả thiết bị thật và các thiết bị giả lập (🧪) trong một danh sách."""

    def __init__(self, app, device: Optional[dict] = None, preset: Optional[dict] = None):
        self.app, self.device, self.result = app, device, None
        top = self.top = tk.Toplevel(app.root)
        top.title("Sửa thiết bị" if device else "Thêm thiết bị")
        footer = ttk.Frame(top, padding=(22, 6, 22, 14))          # nút Lưu/Hủy luôn ghim ở đáy cửa sổ
        footer.pack(side="bottom", fill="x")
        self.scroll = ScrollableFrame(top, app.theme.c["bg"])
        self.scroll.pack(fill="both", expand=True)
        frm = ttk.Frame(self.scroll.body, padding=(22, 18, 22, 6))
        frm.pack(fill="both", expand=True)
        d = device or preset or {}
        self.choices = build_choices()
        self.by_label = {c.label: c for c in self.choices}
        cur = find_choice(self.choices, d.get("vendor", "cisco_ios"), bool(d.get("simulated", 0)), d.get("model", "") or "")
        self.choice_var = tk.StringVar(value=cur.label)
        self._last_label = cur.label
        self._auto = {"name": "", "ip": ""}
        self.filter = tk.StringVar()
        self.v = {
            "name": tk.StringVar(value=d.get("name", "")), "ip": tk.StringVar(value=d.get("ip", "")),
            "protocol": tk.StringVar(value=d.get("protocol", "ssh")), "port": tk.StringVar(value=str(d.get("port", 22))),
            "username": tk.StringVar(value=d.get("username", "")), "password": tk.StringVar(),
            "secret": tk.StringVar(), "site": tk.StringVar(value=d.get("site", "")),
            "tags": tk.StringVar(value=d.get("tags", "")),
        }
        r = 0
        ttk.Label(frm, text="Tìm trong danh sách").grid(row=r, column=0, sticky="w", pady=4, padx=(0, 12))
        fe = ttk.Entry(frm, textvariable=self.filter, width=55)
        fe.grid(row=r, column=1, sticky="ew", pady=4)
        self.filter.trace_add("write", lambda *_: self._apply_filter())
        r += 1
        ttk.Label(frm, text="Hãng / dòng thiết bị *").grid(row=r, column=0, sticky="w", pady=4, padx=(0, 12))
        self.cb = ttk.Combobox(frm, textvariable=self.choice_var, values=[c.label for c in self.choices], state="readonly",
                               width=60, height=22)
        self.cb.grid(row=r, column=1, sticky="ew", pady=4)
        self.cb.bind("<<ComboboxSelected>>", lambda _e: self._on_choice())
        r += 1
        self.mode_lbl = ttk.Label(frm, text="", wraplength=470, justify="left")
        self.mode_lbl.grid(row=r, column=1, sticky="w", pady=(0, 6))
        r += 1
        rows = [("Tên thiết bị *", "name", None), ("Địa chỉ IP / hostname *", "ip", None), ("Giao thức", "protocol", "proto"),
                ("Cổng (port)", "port", None), ("Tài khoản", "username", None), ("Mật khẩu", "password", "pw"),
                ("Enable secret (nếu có)", "secret", "pw"), ("Site / chi nhánh", "site", None),
                ("Tags (cách nhau dấu phẩy)", "tags", None)]
        for label, key, kind in rows:
            ttk.Label(frm, text=label).grid(row=r, column=0, sticky="w", pady=4, padx=(0, 12))
            if kind == "proto":
                cb = ttk.Combobox(frm, textvariable=self.v[key], values=["ssh", "telnet"], state="readonly", width=12)
                cb.grid(row=r, column=1, sticky="w", pady=4)
                cb.bind("<<ComboboxSelected>>", lambda _e: self.v["port"].set("22" if self.v["protocol"].get() == "ssh" else "23"))
            else:
                ttk.Entry(frm, textvariable=self.v[key], width=63, show="*" if kind == "pw" else "").grid(
                    row=r, column=1, sticky="ew", pady=4)
            r += 1
        hint = "Để trống mật khẩu = giữ nguyên mật khẩu cũ." if device else "Mật khẩu được mã hóa trước khi lưu."
        ttk.Label(frm, text=hint, style="Muted.TLabel").grid(row=r, column=1, sticky="w")
        r += 1
        self.msg = ttk.Label(footer, text="", foreground="#dc2626", wraplength=520, justify="left")
        self.msg.pack(side="top", anchor="w", pady=(0, 6))
        bar = ttk.Frame(footer)
        bar.pack(side="top", fill="x")
        ttk.Button(bar, text="Hủy", command=top.destroy).pack(side="right", padx=(6, 0))
        ttk.Button(bar, text="Lưu", style="Accent.TButton", command=self._save).pack(side="right")
        frm.columnconfigure(1, weight=1)
        self._update_mode()
        fit_dialog(top, self.scroll, footer, app.root)

    # ---- danh sách gộp ----
    def current(self) -> Choice:
        c = self.by_label.get(self.choice_var.get())
        return c if c and not c.header else self.by_label[self._last_label]

    def _apply_filter(self) -> None:
        shown = filter_choices(self.choices, self.filter.get())
        self.cb.configure(values=[c.label for c in shown])

    def _on_choice(self) -> None:
        c = self.by_label.get(self.choice_var.get())
        if c is None or c.header:                       # bấm nhầm dòng tiêu đề nhóm -> giữ lựa chọn cũ
            self.choice_var.set(self._last_label)
            return
        self._last_label = c.label
        if c.simulated:                                  # điền sẵn tên + IP gợi ý (không đè lên nội dung người dùng tự gõ)
            if self.v["name"].get().strip() in ("", self._auto["name"]):
                self._auto["name"] = "SIM-" + re.sub(r"[^A-Za-z0-9]+", "-", c.model).strip("-")[:20]
                self.v["name"].set(self._auto["name"])
            if self.v["ip"].get().strip() in ("", self._auto["ip"]):
                used = {x["ip"] for x in self.app.ctx.db.list_devices()}
                self._auto["ip"] = next(f"10.99.0.{i}" for i in range(1, 255) if f"10.99.0.{i}" not in used)
                self.v["ip"].set(self._auto["ip"])
        self._update_mode()

    def _update_mode(self) -> None:
        c = self.current()
        if c.simulated:
            note = SIM_NOTES.get(VENDORS[c.vendor].family, "")
            self.mode_lbl.configure(text=f"🧪 GIẢ LẬP: {note}. IP/tài khoản nhập gì cũng được. "
                                         "Tên chứa 'fail'/'timeout'/'badcmd' để mô phỏng lỗi.", foreground="#b45309")
        else:
            self.mode_lbl.configure(text="Thiết bị thật: cần IP, tài khoản và mật khẩu đúng.", foreground=self.app.theme.c["fg"])

    def _save(self) -> None:
        v = {k: x.get().strip() for k, x in self.v.items()}
        c = self.current()
        if not v["name"]:
            return self.msg.configure(text="Hãy nhập tên thiết bị.")
        if not v["ip"] or not validate_host(v["ip"]):
            return self.msg.configure(text="IP/hostname không hợp lệ.")
        try:
            port = int(v["port"])
            if not 1 <= port <= 65535:
                raise ValueError
        except ValueError:
            return self.msg.configure(text="Cổng phải là số từ 1-65535.")
        vault = self.app.ctx.vault
        data = dict(name=v["name"], ip=v["ip"], vendor=c.vendor, protocol=v["protocol"], port=port, username=v["username"],
                    site=v["site"], tags=v["tags"], simulated=int(c.simulated))
        if c.simulated:
            data["model"] = c.model
        if v["password"] or not self.device:
            data["password_enc"] = vault.encrypt(v["password"])
        if v["secret"] or not self.device:
            data["secret_enc"] = vault.encrypt(v["secret"])
        self.result = data
        self.top.destroy()

    def run(self) -> Optional[dict]:
        _modal(self.top, self.app.root)
        return self.result


# ---------------------------------------------------------------------------
class ScanDialog:
    """Quét dải IP tìm thiết bị và thêm vào danh sách."""

    def __init__(self, app):
        self.app = app
        self.cancel = threading.Event()
        self.found: dict[str, dict] = {}
        top = self.top = tk.Toplevel(app.root)
        top.title("Quét mạng tìm thiết bị")
        top.geometry(scaled_geometry(top, 900, 640))
        top.protocol("WM_DELETE_WINDOW", self._close)
        frm = ttk.Frame(top, padding=14)
        frm.pack(fill="both", expand=True)
        frm.columnconfigure(1, weight=1)
        self.targets = tk.StringVar(value="192.168.1.0/24")
        self.community = tk.StringVar(value="public")
        self.use_snmp = tk.BooleanVar(value=True)
        self.user = tk.StringVar()
        self.pw = tk.StringVar()
        labels = vendor_labels(include_mock=False)
        self.key_by_label = {lbl: k for k, lbl in labels}
        self.default_vendor = tk.StringVar(value=dict(labels)["cisco_ios"])
        ttk.Label(frm, text="Dải IP cần quét").grid(row=0, column=0, sticky="w", pady=3)
        ttk.Entry(frm, textvariable=self.targets).grid(row=0, column=1, columnspan=3, sticky="ew", pady=3)
        ttk.Label(frm, text="VD: 192.168.1.0/24  |  10.0.0.10-10.0.0.50  |  10.0.0.5, 10.0.0.9", style="Muted.TLabel").grid(
            row=1, column=1, columnspan=3, sticky="w")
        ttk.Checkbutton(frm, text="Dùng SNMP để nhận diện hãng (community:)", variable=self.use_snmp).grid(
            row=2, column=0, sticky="w", pady=3)
        ttk.Entry(frm, textvariable=self.community, width=18).grid(row=2, column=1, sticky="w", pady=3)
        ttk.Label(frm, text="Tài khoản chung khi thêm").grid(row=3, column=0, sticky="w", pady=3)
        ttk.Entry(frm, textvariable=self.user, width=18).grid(row=3, column=1, sticky="w", pady=3)
        ttk.Entry(frm, textvariable=self.pw, width=18, show="*").grid(row=3, column=2, sticky="w", pady=3, padx=6)
        ttk.Label(frm, text="Hãng mặc định (nếu không nhận ra)").grid(row=4, column=0, sticky="w", pady=3)
        ttk.Combobox(frm, textvariable=self.default_vendor, values=list(self.key_by_label), state="readonly",
                     width=44).grid(row=4, column=1, columnspan=3, sticky="w", pady=3)
        bar = ttk.Frame(frm)
        bar.grid(row=5, column=0, columnspan=4, sticky="ew", pady=8)
        self.btn_scan = ttk.Button(bar, text="Bắt đầu quét", style="Accent.TButton", command=self._start)
        self.btn_scan.pack(side="left")
        self.btn_stop = ttk.Button(bar, text="Dừng", command=self.cancel.set, state="disabled")
        self.btn_stop.pack(side="left", padx=6)
        self.prog = ttk.Progressbar(bar, mode="determinate", length=260)
        self.prog.pack(side="left", padx=10)
        self.status = ttk.Label(bar, text="", style="Muted.TLabel")
        self.status.pack(side="left")
        cols = [("ip", "IP", 120), ("name", "Tên (SNMP)", 160), ("vendor", "Hãng đoán", 170), ("ports", "Cổng mở", 70),
                ("descr", "Mô tả / banner", 300)]
        tf, self.tree = make_tree(frm, cols, height=14)
        tf.grid(row=6, column=0, columnspan=4, sticky="nsew")
        frm.rowconfigure(6, weight=1)
        ttk.Label(frm, text="Chọn các thiết bị (Ctrl/Shift để chọn nhiều) rồi bấm 'Thêm'. Quét chỉ kiểm tra cổng 22/23 và SNMP.",
                  style="Muted.TLabel").grid(row=7, column=0, columnspan=4, sticky="w", pady=(6, 0))
        b2 = ttk.Frame(frm)
        b2.grid(row=8, column=0, columnspan=4, sticky="e", pady=(8, 0))
        ttk.Button(b2, text="Đóng", command=self._close).pack(side="right", padx=(6, 0))
        ttk.Button(b2, text="Thêm thiết bị đã chọn", style="Accent.TButton", command=self._add).pack(side="right")
        ttk.Button(b2, text="Chọn tất cả", command=lambda: self.tree.selection_set(self.tree.get_children())).pack(
            side="right", padx=6)

    def _start(self) -> None:
        try:
            targets = scanner.expand_targets(self.targets.get())
        except ValueError as e:
            return messagebox.showerror("Dải IP không hợp lệ", str(e), parent=self.top)
        self.cancel.clear()
        clear_tree(self.tree)
        self.found.clear()
        self.btn_scan.configure(state="disabled")
        self.btn_stop.configure(state="normal")
        self.prog.configure(maximum=len(targets), value=0)
        self.status.configure(text=f"Đang quét {len(targets)} địa chỉ...")
        community, use_snmp = self.community.get().strip() or "public", self.use_snmp.get()

        def progress(done: int, total: int) -> None:
            self.app.call_soon(lambda: self._progress(done, total))

        self.app.run_bg(lambda: scanner.scan(targets, community, use_snmp, progress=progress, cancel=self.cancel),
                        self._done)

    def _progress(self, done: int, total: int) -> None:
        if self.top.winfo_exists():
            self.prog.configure(value=done)
            self.status.configure(text=f"{done}/{total}")

    def _done(self, result, exc) -> None:
        if not self.top.winfo_exists():
            return
        self.btn_scan.configure(state="normal")
        self.btn_stop.configure(state="disabled")
        if exc:
            return messagebox.showerror("Lỗi quét", str(exc), parent=self.top)
        for r in result:
            self.found[r["ip"]] = r
            vendor = VENDORS[r["vendor"]].label if r["vendor"] in VENDORS else "(chưa rõ)"
            exists = self.app.ctx.db.find_device_by_ip(r["ip"])
            self.tree.insert("", "end", iid=r["ip"], tags=("muted",) if exists else (), values=(
                r["ip"], r["name"] + ("  [đã có]" if exists else ""), vendor, r["ports"], r["sysdescr"] or r["banner"]))
        self.status.configure(text=f"Xong: tìm thấy {len(result)} thiết bị")

    def _add(self) -> None:
        sel = self.tree.selection()
        if not sel:
            return messagebox.showinfo("Thêm thiết bị", "Hãy chọn ít nhất một dòng.", parent=self.top)
        db, vault = self.app.ctx.db, self.app.ctx.vault
        added = 0
        for ip in sel:
            if db.find_device_by_ip(ip):
                continue
            r = self.found[ip]
            vendor = r["vendor"] or self.key_by_label[self.default_vendor.get()]
            db.add_device(name=r["name"] if r["name"] != ip else f"dev-{ip.replace('.', '-')}", ip=ip, vendor=vendor,
                          protocol=r["protocol"], port=22 if r["protocol"] == "ssh" else 23, username=self.user.get(),
                          password_enc=vault.encrypt(self.pw.get()), site="", tags="quet-mang")
            added += 1
        db.audit(vault.user["username"], "scan_add", f"{added} thiết bị")
        self.app.notify_devices_changed()
        messagebox.showinfo("Thêm thiết bị", f"Đã thêm {added} thiết bị.\nHãy kiểm tra lại hãng (nếu đoán sai) bằng 'Dò hãng' hoặc 'Sửa'.",
                            parent=self.top)

    def _close(self) -> None:
        self.cancel.set()
        self.top.destroy()


# ---------------------------------------------------------------------------
class RollbackDialog:
    def __init__(self, app, dev: dict, backup_id: int, cmds: list[str], warns: list[str], diff: str):
        self.app, self.ok = app, False
        top = self.top = tk.Toplevel(app.root)
        top.title(f"Khôi phục {dev['name']} về backup #{backup_id}")
        top.geometry(scaled_geometry(top, 920, 660))
        frm = ttk.Frame(top, padding=12)
        frm.pack(fill="both", expand=True)
        ttk.Label(frm, text=f"Xem trước khôi phục: {dev['name']} ({dev['ip']}) -> backup #{backup_id}", style="H2.TLabel").pack(anchor="w")
        if warns:
            ttk.Label(frm, text="\n".join("⚠ " + w for w in warns), foreground="#b45309", wraplength=860,
                      justify="left").pack(anchor="w", pady=6)
        bar = ttk.Frame(frm)
        bar.pack(side="bottom", fill="x", pady=(8, 0))
        self.save = tk.BooleanVar(value=True)
        ttk.Checkbutton(frm, text="Lưu cấu hình vào startup-config sau khi khôi phục", variable=self.save).pack(side="bottom", anchor="w")
        nb = ttk.Notebook(frm)
        nb.pack(fill="both", expand=True, pady=6)
        f1, t1 = make_text(nb, app.theme, terminal=True)
        set_text(t1, "\n".join(cmds) if cmds else "(không có lệnh)")
        f2, t2 = make_text(nb, app.theme, terminal=True)
        set_text(t2, diff or "(không có khác biệt)", diff=True)
        nb.add(f1, text=f"Lệnh sẽ gửi ({len(cmds)})")
        nb.add(f2, text="Khác biệt (hiện tại → backup)")
        ttk.Button(bar, text="Hủy", command=top.destroy).pack(side="right", padx=(6, 0))
        b = ttk.Button(bar, text="Áp dụng khôi phục", style="Danger.TButton", command=self._go)
        b.pack(side="right")
        if not cmds:
            b.configure(state="disabled")

    def _go(self) -> None:
        if messagebox.askyesno("Xác nhận", "Gửi các lệnh khôi phục lên thiết bị?\n(Cấu hình hiện tại sẽ được sao lưu trước.)",
                               parent=self.top, icon="warning"):
            self.ok = True
            self.top.destroy()

    def run(self) -> tuple[bool, bool]:
        _modal(self.top, self.app.root)
        return self.ok, self.save.get()


# ---------------------------------------------------------------------------
class PickDialog:
    """Bảng chọn nhiều giá trị từ cấu hình thiết bị (VLAN, cổng, zone...)."""

    def __init__(self, app, title: str, options: list, current: list[str]):
        self.app, self.options, self.result = app, options, None
        top = self.top = tk.Toplevel(app.root)
        top.title(f"Chọn: {title.split('(')[0].strip()}")
        top.geometry(scaled_geometry(top, 560, 520))
        frm = ttk.Frame(top, padding=12)
        frm.pack(fill="both", expand=True)
        bar = ttk.Frame(frm)
        bar.pack(side="bottom", fill="x", pady=(10, 0))
        ttk.Button(bar, text="Hủy", command=top.destroy).pack(side="right", padx=(6, 0))
        ttk.Button(bar, text="Chọn", style="Accent.TButton", command=self._ok).pack(side="right")
        ttk.Button(bar, text="Chọn tất cả", command=lambda: self.tree.selection_set(self.tree.get_children())).pack(side="left")
        ttk.Button(bar, text="Bỏ chọn", command=lambda: self.tree.selection_set([])).pack(side="left", padx=6)
        if not options:
            ttk.Label(frm, foreground="#b45309", wraplength=520, justify="left", text=(
                "Chưa có dữ liệu cấu hình của thiết bị đã chọn. Hãy đóng bảng này, bấm '↻ Đọc cấu hình thiết bị' ở tab Cấu hình, "
                "hoặc tự gõ giá trị vào ô nhập.")).pack(anchor="w", pady=(0, 8))
        top_row = ttk.Frame(frm)
        top_row.pack(fill="x", pady=(0, 6))
        ttk.Label(top_row, text="Lọc:").pack(side="left")
        self.filter = tk.StringVar()
        self.filter.trace_add("write", lambda *_: self._fill())
        ttk.Entry(top_row, textvariable=self.filter).pack(side="left", fill="x", expand=True, padx=6)
        f, self.tree = make_tree(frm, [("v", "Giá trị", 150), ("l", "Mô tả (từ cấu hình)", 360)], selectmode="extended", height=14)
        f.pack(fill="both", expand=True)
        self.tree.bind("<Double-1>", lambda _e: self._ok())
        self._keep = set(current)
        self._fill()

    def _fill(self) -> None:
        keep = set(self.tree.selection()) | self._keep
        clear_tree(self.tree)
        t = self.filter.get().strip().lower()
        for o in self.options:
            if t and t not in o.label.lower():
                continue
            self.tree.insert("", "end", iid=o.value, values=(o.value, o.label))
        self.tree.selection_set([v for v in keep if self.tree.exists(v)])
        self._keep = set()

    def _ok(self) -> None:
        self.result = [i for i in self.tree.selection()]
        self.top.destroy()

    def run(self):
        _modal(self.top, self.app.root)
        return self.result


# ---------------------------------------------------------------------------
def show_result_detail(app, res: dict) -> None:
    """Cửa sổ chi tiết kết quả một thiết bị: lệnh / output / diff."""
    top = tk.Toplevel(app.root)
    top.title(f"Chi tiết: {res.get('name') or res.get('device_name')} ({res.get('ip')})")
    top.geometry(scaled_geometry(top, 960, 660))
    frm = ttk.Frame(top, padding=10)
    frm.pack(fill="both", expand=True)
    ttk.Label(frm, text=f"Trạng thái: {res.get('status')}  -  {res.get('message', '')}", wraplength=900,
              justify="left").pack(anchor="w", pady=(0, 6))
    ttk.Button(frm, text="Đóng", command=top.destroy).pack(side="bottom", anchor="e", pady=(8, 0))
    nb = ttk.Notebook(frm)
    nb.pack(fill="both", expand=True)
    cmds = res.get("commands") or ""
    if isinstance(cmds, list):
        cmds = "\n".join(cmds)
    for title, content, diff in (("Lệnh đã gửi", cmds, False), ("Phản hồi thiết bị", res.get("output", ""), False),
                                 ("Thay đổi cấu hình (diff)", res.get("diff", ""), True)):
        f, t = make_text(nb, app.theme, terminal=True)
        set_text(t, content or "(trống)", diff=diff)
        nb.add(f, text=title)
