"""Tab Cấu hình: chọn thiết bị -> chọn tác vụ -> nhập thông tin -> xem trước -> chạy.

Giao diện tự thích ứng theo thiết bị đang chọn: danh sách tác vụ chỉ hiện tác vụ có template cho hãng đó,
các ô nhập chỉ hiện trường áp dụng cho họ thiết bị đó, và ô "Lệnh tùy chỉnh" có mẫu đúng cú pháp của hãng.
"""
from __future__ import annotations

import threading
import tkinter as tk
from pathlib import Path
from typing import Optional
from tkinter import filedialog, messagebox, simpledialog, ttk

from core import guard, importer, pervar
from core.config_facts import options_for, validate_links
from core.jobs import build_payload, builder_from_payload, parse_when
from core.redact import redact_lines
from core.engine import STATUS_LABELS
from core.templating import TaskUnsupported, TemplateError, parse_kv_lines, sample_for
from drivers.vendors import VENDORS, get_vendor
from .dialogs import PickDialog, show_result_detail
from .widgets import DynamicForm, ScrollableFrame, clear_tree, make_text, make_tree, set_text

CUSTOM = "✍ Lệnh tùy chỉnh (Jinja2)"
CUSTOM_ID = "__custom__"
CUSTOM_HINT = (
    "Mỗi dòng là một lệnh gửi lên thiết bị (vào chế độ cấu hình tự động). Biến có sẵn: {{ device.name }} {{ device.ip }} "
    "{{ device.site }} {{ device.vendor }} {{ device.index }}; biến riêng khai báo ở ô 'Biến' (tên=giá trị). "
    "Vòng lặp: {% for p in cong.split(',') %} ... {% endfor %}")


class TasksTab(ttk.Frame):
    def __init__(self, parent, app):
        super().__init__(parent, padding=10)
        self.app, self.ctx, self.cat = app, app.ctx, app.ctx.catalog
        self.cancel = threading.Event()
        self.running = False
        self.last_job_id = None
        self._results: dict[str, dict] = {}
        self._dev_cache: dict[str, dict] = {}
        self.task_map: dict[str, str] = {}
        self.cur_tid = next(iter(self.cat.task_ids()))
        self._built_tid = None
        self._auto_sample = ""
        self._last_dry = False
        self._auto_done: set = set()
        self.per_vars: dict = {}
        self.per_src = ""

        pane = ttk.PanedWindow(self, orient="horizontal")
        pane.pack(fill="both", expand=True)
        left = ttk.LabelFrame(pane, text="① Chọn thiết bị", padding=8)
        self.rscroll = ScrollableFrame(pane, app.theme)       # cột phải có thanh cuộn: form dài đến đâu cũng kéo xuống được
        right = self.rscroll.body
        pane.add(left, weight=2)
        pane.add(self.rscroll, weight=5)
        self._build_left(left)
        self._build_right(right)
        self.refresh_devices()

    # ------------------------------------------------------------------ bố cục
    def _build_left(self, left: ttk.Frame) -> None:
        top = ttk.Frame(left)
        top.pack(fill="x")
        self.search = tk.StringVar()
        self.search.trace_add("write", lambda *_: self.refresh_devices())
        ttk.Entry(top, textvariable=self.search).pack(side="left", fill="x", expand=True)
        ttk.Button(top, text="Tất cả", command=self._select_all).pack(side="left", padx=(6, 0))
        ttk.Button(top, text="Bỏ chọn", command=lambda: self.tree.selection_set([])).pack(side="left", padx=(4, 0))
        f, self.tree = make_tree(left, [("name", "Thiết bị", 125), ("ip", "IP", 95), ("vendor", "Hãng", 85),
                                        ("ok", "Tác vụ", 55, "center")], height=18)
        f.pack(fill="both", expand=True, pady=(6, 0))
        self.tree.bind("<<TreeviewSelect>>", lambda _e: self._on_select())
        self.sel_lbl = ttk.Label(left, text="Đã chọn: 0", style="Muted.TLabel")
        self.sel_lbl.pack(anchor="w", pady=(4, 0))
        ttk.Label(left, text="Cột 'Tác vụ': ✔ = thiết bị này hỗ trợ tác vụ đang chọn, – = sẽ bị bỏ qua.",
                  style="Muted.TLabel", wraplength=300, justify="left").pack(anchor="w")

    def _build_right(self, right: ttk.Frame) -> None:
        box = ttk.LabelFrame(right, text="② Chọn tác vụ & nhập thông tin", padding=8)
        box.pack(fill="x")
        row = ttk.Frame(box)
        row.pack(fill="x")
        self.task_var = tk.StringVar()
        self.task_cb = ttk.Combobox(row, textvariable=self.task_var, state="readonly", width=66, height=24)
        self.task_cb.pack(side="left")
        self.task_cb.bind("<<ComboboxSelected>>", lambda _e: self.on_task_change())
        self.avail_lbl = ttk.Label(box, text="", style="Muted.TLabel", wraplength=780, justify="left")
        self.avail_lbl.pack(anchor="w", pady=(4, 0))
        fr = ttk.Frame(box)
        fr.pack(fill="x", pady=(2, 0))
        self.btn_facts = ttk.Button(fr, text="↻ Đọc cấu hình thiết bị", command=lambda: self.load_facts())
        self.btn_facts.pack(side="right", padx=(8, 0))
        self.facts_lbl = ttk.Label(fr, text="", style="Muted.TLabel", wraplength=640, justify="left")
        self.facts_lbl.pack(side="left", fill="x", expand=True)
        self.desc = ttk.Label(box, text="", wraplength=780, justify="left")
        self.desc.pack(anchor="w", pady=(2, 6))
        self.form = DynamicForm(box)
        self.form.picker = self._pick_values
        self.form.pack(fill="x")
        self.custom = self._build_custom(box)

        opt = ttk.LabelFrame(right, text="③ Tùy chọn & thực thi", padding=8)
        opt.pack(fill="x", pady=8)
        row1 = ttk.Frame(opt)
        row1.pack(fill="x")
        self.dry = tk.BooleanVar(value=True)
        self.save = tk.BooleanVar(value=bool(self.ctx.db.get_setting("save_default", True)))
        self.workers = tk.IntVar(value=int(self.ctx.db.get_setting("workers", 5)))
        ttk.Checkbutton(row1, text="Kiểm tra khô (KHÔNG gửi lệnh)", variable=self.dry, command=self._sync_mode).pack(side="left")
        ttk.Checkbutton(row1, text="Lưu cấu hình (write memory/commit)", variable=self.save).pack(side="left", padx=14)
        ttk.Label(row1, text="Số luồng:").pack(side="left")
        ttk.Spinbox(row1, from_=1, to=30, textvariable=self.workers, width=4).pack(side="left", padx=4)
        row2 = ttk.Frame(opt)
        row2.pack(fill="x", pady=(6, 0))
        self.stop_on_err = tk.BooleanVar(value=True)
        self.canary = tk.IntVar(value=1)
        self.verify = tk.BooleanVar(value=True)
        self.safe = tk.IntVar(value=5)
        ttk.Checkbutton(row2, text="Dừng khi có thiết bị lỗi", variable=self.stop_on_err).pack(side="left")
        ttk.Label(row2, text="   Chạy thử đợt đầu (máy):").pack(side="left")
        ttk.Spinbox(row2, from_=0, to=20, textvariable=self.canary, width=3).pack(side="left", padx=4)
        ttk.Checkbutton(row2, text="Kiểm tra trước/sau (cảnh báo nếu mất cổng/route)", variable=self.verify).pack(side="left", padx=(12, 0))
        row3 = ttk.Frame(opt)
        row3.pack(fill="x", pady=(4, 0))
        ttk.Label(row3, text="Junos/SRX - tự hoàn tác sau (phút, 0 = tắt):").pack(side="left")
        ttk.Spinbox(row3, from_=0, to=60, textvariable=self.safe, width=4).pack(side="left", padx=4)
        ttk.Label(row3, text="(commit confirmed: chỉ xác nhận khi kết nối lại được, nếu không thiết bị tự quay về cấu hình cũ)",
                  style="Muted.TLabel").pack(side="left", padx=6)
        row4 = ttk.Frame(opt)
        row4.pack(fill="x", pady=(6, 0))
        ttk.Button(row4, text="📥 Nạp biến theo thiết bị (CSV/Excel)", command=self.load_pervars).pack(side="left")
        ttk.Button(row4, text="📄 Tạo file mẫu", command=self.make_pervar_template).pack(side="left", padx=4)
        ttk.Button(row4, text="✖ Bỏ biến riêng", command=self.clear_pervars).pack(side="left")
        self.pervar_lbl = ttk.Label(row4, text="Chưa nạp biến riêng: mọi thiết bị dùng cùng giá trị ở form.", style="Muted.TLabel")
        self.pervar_lbl.pack(side="left", padx=8)
        row5 = ttk.Frame(opt)
        row5.pack(fill="x", pady=(6, 0))
        ttk.Label(row5, text="⏰ Hẹn giờ chạy (YYYY-MM-DD HH:MM hoặc HH:MM):").pack(side="left")
        self.when = tk.StringVar()
        ttk.Entry(row5, textvariable=self.when, width=18).pack(side="left", padx=6)
        ttk.Button(row5, text="Đặt lịch", command=self.schedule_job).pack(side="left")
        ttk.Label(row5, text="(chạy khi ứng dụng đang mở; xem/hủy ở tab Nhật ký → Lịch hẹn)", style="Muted.TLabel").pack(side="left", padx=8)
        self.mode_lbl = ttk.Label(opt, text="", wraplength=780, justify="left")
        self.mode_lbl.pack(anchor="w", pady=(6, 0))
        bar = ttk.Frame(right)
        bar.pack(fill="x")
        self.btn_prev = ttk.Button(bar, text="👁 Xem trước lệnh", command=self.preview)
        self.btn_prev.pack(side="left")
        self.btn_run = ttk.Button(bar, text="▶ Kiểm tra khô", style="Accent.TButton", command=self.run)
        self.btn_run.pack(side="left", padx=8)
        self.btn_cancel = ttk.Button(bar, text="■ Hủy", command=self.cancel.set, state="disabled")
        self.btn_cancel.pack(side="left")
        self.btn_report = ttk.Button(bar, text="📄 Xuất báo cáo", command=self.export_report, state="disabled")
        self.btn_report.pack(side="right")
        self.prog = ttk.Progressbar(right, mode="determinate")
        self.prog.pack(fill="x", pady=(8, 2))
        self.prog_lbl = ttk.Label(right, text="", style="Muted.TLabel")
        self.prog_lbl.pack(anchor="w")
        self.nb = ttk.Notebook(right)
        self.nb.pack(fill="x", pady=(6, 0))
        pf, self.preview_txt = make_text(self.nb, self.app.theme, terminal=True, height=14)
        self.nb.add(pf, text="Xem trước lệnh")
        rf = ttk.PanedWindow(self.nb, orient="vertical", height=360)
        tf, self.res_tree = make_tree(rf, [("dev", "Thiết bị", 150), ("ip", "IP", 110), ("st", "Kết quả", 110),
                                           ("msg", "Ghi chú", 420)], selectmode="browse", height=4)
        df, self.res_detail = make_text(rf, self.app.theme, terminal=True, height=9)
        rf.add(tf, weight=1)
        rf.add(df, weight=3)
        self.nb.add(rf, text="Kết quả & chi tiết")
        self.res_tree.bind("<<TreeviewSelect>>", lambda _e: self._show_result())
        self.res_tree.bind("<Double-1>", self._open_detail)
        set_text(self.res_detail, "Kết quả sẽ hiện ở đây. Chọn một thiết bị để xem lệnh đã gửi, phản hồi và thay đổi cấu hình (diff).")
        self._sync_mode()
        if not self.ctx.can("run_tasks"):
            self.btn_run.configure(state="disabled")

    def _build_custom(self, parent: ttk.Frame) -> ttk.Frame:
        fr = ttk.Frame(parent)
        self.custom_note = ttk.Label(fr, text="", foreground="#b45309", wraplength=780, justify="left")
        self.custom_note.pack(anchor="w", pady=(0, 4))
        top = ttk.Frame(fr)
        top.pack(fill="x", pady=(0, 4))
        ttk.Label(top, text="Mẫu đã lưu:").pack(side="left")
        self.saved = tk.StringVar()
        self.saved_cb = ttk.Combobox(top, textvariable=self.saved, state="readonly", width=28)
        self.saved_cb.pack(side="left", padx=6)
        ttk.Button(top, text="Mở", command=self._load_custom).pack(side="left")
        ttk.Button(top, text="Lưu mẫu...", command=self._save_custom).pack(side="left", padx=4)
        ttk.Button(top, text="Xóa mẫu", command=self._del_custom).pack(side="left")
        ttk.Button(top, text="Mẫu theo hãng", command=lambda: self._apply_sample(force=True)).pack(side="left", padx=(12, 0))
        ef, self.custom_txt = make_text(fr, self.app.theme, height=7, wrap="none")
        ef.pack(fill="x")
        ttk.Label(fr, text="Biến (mỗi dòng: tên=giá trị):").pack(anchor="w", pady=(6, 0))
        vf, self.custom_vars = make_text(fr, self.app.theme, height=3, wrap="none")
        vf.pack(fill="x")
        ttk.Label(fr, text=CUSTOM_HINT, style="Muted.TLabel", wraplength=780, justify="left").pack(anchor="w", pady=(4, 0))
        self._refresh_saved()
        return fr

    # ------------------------------------------------------------------ thiết bị đang chọn -> thích ứng giao diện
    def selected(self) -> list[dict]:
        return [d for d in (self.ctx.db.get_device(int(i)) for i in self.tree.selection()) if d]

    def _families(self, devs: list[dict]) -> list[str]:
        return sorted({get_vendor(d["vendor"]).family for d in devs if d["vendor"] in VENDORS})

    def _available_tasks(self, devs: list[dict]) -> list[tuple[str, str]]:
        items: list[tuple[str, str]] = []
        for tid in self.cat.task_ids():
            if not devs:
                items.append((self.cat.display(tid), tid))
                continue
            n = sum(self.cat.supported(tid, d["vendor"]) for d in devs)
            if n:
                items.append((self.cat.display(tid) + ("" if n == len(devs) else f"   [{n}/{len(devs)} thiết bị]"), tid))
        items.append((CUSTOM, CUSTOM_ID))
        return items

    def _on_select(self) -> None:
        self._update_count()
        self.refresh_task_choices()

    def refresh_task_choices(self) -> None:
        devs = self.selected()
        items = self._available_tasks(devs)
        self.task_map = {disp: tid for disp, tid in items}
        self.task_cb.configure(values=[d for d, _ in items])
        tids = [t for _, t in items]
        if self.cur_tid not in tids:
            self.cur_tid = tids[0]
        self.task_var.set(next(d for d, t in items if t == self.cur_tid))
        n_tasks = len(items) - 1
        if not devs:
            self.avail_lbl.configure(text=f"Chưa chọn thiết bị: đang hiện tất cả {n_tasks} tác vụ. Hãy chọn thiết bị để chỉ hiện tác vụ và ô nhập phù hợp.")
        else:
            names = {}
            for d in devs:
                lbl = VENDORS[d["vendor"]].label.split(" (")[0] if d["vendor"] in VENDORS else d["vendor"]
                names[lbl] = names.get(lbl, 0) + 1
            kinds = ", ".join(f"{k} ×{v}" for k, v in names.items())
            extra = "" if n_tasks else "  → Hãng này chưa có template dựng sẵn, hãy dùng 'Lệnh tùy chỉnh'."
            self.avail_lbl.configure(text=f"Đang chọn {len(devs)} thiết bị ({kinds}) → {n_tasks} tác vụ phù hợp.{extra}")
        self._auto_facts(devs)
        self.on_task_change(keep_values=True)

    # ------------------------------------------------------------------ liên kết với cấu hình thiết bị
    def _facts_text(self, devs: list[dict]) -> str:
        if not devs:
            return "Chọn thiết bị để các ô VLAN / cổng / zone / address... hiện danh sách có sẵn trong cấu hình thiết bị."
        have = [d for d in devs if self.ctx.facts.get(d).loaded]
        miss = [d["name"] for d in devs if d not in have]
        txt = f"Dữ liệu cấu hình đã đọc: {len(have)}/{len(devs)} thiết bị"
        if have:
            txt += f" (bản mới nhất lúc {max(self.ctx.facts.get(d).backup_time for d in have)})"
        if miss:
            txt += f". Chưa có: {', '.join(miss[:4])}{'...' if len(miss) > 4 else ''} - bấm '↻ Đọc cấu hình thiết bị'"
        if any(get_vendor(d["vendor"]).family in ("junos", "junos_srx", "mikrotik") for d in devs if d["vendor"] in VENDORS):
            txt += ". Lưu ý: danh sách cổng của Junos/MikroTik chỉ gồm cổng đã có cấu hình, cổng khác hãy gõ tay."
        return txt

    def _auto_facts(self, devs: list[dict]) -> None:
        """Thiết bị giả lập chưa có dữ liệu: tự đọc ngay (không cần thiết bị thật)."""
        need = [d for d in devs if d.get("simulated") and not self.ctx.db.last_backup(d["id"]) and d["id"] not in self._auto_done]
        if need:
            self._auto_done.update(d["id"] for d in need)
            self._fetch_facts(need, quiet=True)

    def load_facts(self) -> None:
        devs = self.selected()
        if not devs:
            return messagebox.showinfo("Đọc cấu hình", "Hãy chọn thiết bị ở cột bên trái.", parent=self.app.root)
        self._fetch_facts(devs, quiet=False)

    def _fetch_facts(self, devs: list[dict], quiet: bool) -> None:
        eng = self.ctx.engine
        self.facts_lbl.configure(text="Đang đọc cấu hình thiết bị...")

        def work():
            return [(d["name"],) + tuple(eng.backup_device(d, "Đọc cấu hình cho form")[:2]) for d in devs]

        def done(res, exc):
            if exc:
                return messagebox.showerror("Lỗi", str(exc), parent=self.app.root)
            bad = [f"• {n}: {m}" for n, ok, m in res if not ok]
            self.app.notify_devices_changed()
            if bad and not quiet:
                messagebox.showwarning("Đọc cấu hình", "Không đọc được:\n" + "\n".join(bad[:10]), parent=self.app.root)

        self.app.run_bg(work, done)

    def _pick_values(self, title: str, options: list, current: list[str]):
        return PickDialog(self.app, title, options, current).run()

    def _link_warnings(self, devs: list[dict], tid: str) -> dict:
        """Cảnh báo khi giá trị nhập không khớp cấu hình hiện có (VLAN chưa tạo, zone chưa có...)."""
        if tid == CUSTOM_ID:
            return {}
        out = {}
        for d in devs:
            if d["vendor"] not in VENDORS or not self.cat.supported(tid, d["vendor"]):
                continue
            fam = get_vendor(d["vendor"]).family
            w = validate_links(self.cat.fields_for(tid, [fam]), self._values_for(d), d, self.ctx.facts.get(d))
            if w:
                out[d["name"]] = w
        return out

    def focus_task(self, device_ids: list[int], task_id: str) -> None:
        """Chọn sẵn thiết bị + tác vụ (dùng khi bấm 'Mở tác vụ để sửa' ở tab Tuân thủ)."""
        self.search.set("")
        self.tree.selection_set([str(i) for i in device_ids if self.tree.exists(str(i))])
        self.cur_tid = task_id
        self._on_select()

    def _guard_warnings(self, devs: list[dict], builder) -> dict:
        """Chống tự khóa mình: lệnh nào có thể làm mất kết nối quản trị của chính ứng dụng."""
        out = {}
        for i, d in enumerate(devs, start=1):
            try:
                cmds = builder(d, i)
            except (TaskUnsupported, TemplateError):
                continue
            w = guard.check(d, self.ctx.facts.get(d), cmds)
            if w:
                out[d["name"]] = w
        return out

    def task_id(self) -> str:
        return self.task_map.get(self.task_var.get(), self.cur_tid)

    def on_task_change(self, keep_values: bool = False) -> None:
        tid = self.task_id()
        devs = self.selected()
        fams = self._families(devs)
        preset = self.form.values() if (keep_values and self._built_tid == tid and tid != CUSTOM_ID) else None
        self.cur_tid = tid
        if tid == CUSTOM_ID:
            self.form.pack_forget()
            self.custom.pack(fill="x")
            self._built_tid = tid
            self.desc.configure(text="Tự viết lệnh bằng Jinja2 - dùng được cho MỌI hãng (kể cả hãng chưa có template dựng sẵn).")
            mixed = len(fams) > 1
            self.custom_note.configure(text=(
                "⚠ Bạn đã chọn thiết bị khác hãng: cùng một đoạn lệnh sẽ gửi cho TẤT CẢ. Dùng {% if device.vendor.startswith('juniper') %} ... "
                "để gửi đúng cú pháp từng hãng, hoặc chọn từng nhóm cùng hãng." if mixed else ""))
            self._apply_sample()
        else:
            self.custom.pack_forget()
            self.form.pack(fill="x")
            fields = self.cat.fields_for(tid, fams)
            refs = {f["ref"] for f in fields if f.get("ref")}
            options = {r: options_for(r, devs, self.ctx.facts) for r in refs}
            self.form.build(fields, self.app.theme, preset, options)
            self._built_tid = tid
            self.desc.configure(text=self.cat.tasks[tid].get("description", ""))
        self.facts_lbl.configure(text=self._facts_text(devs))
        self._update_marks()

    def _apply_sample(self, force: bool = False) -> None:
        """Điền mẫu lệnh đúng cú pháp hãng, trừ khi người dùng đã tự sửa nội dung."""
        current = self.custom_txt.get("1.0", "end").strip()
        if force or not current or current == self._auto_sample.strip():
            sample = sample_for(self._families(self.selected()))
            self.custom_txt.delete("1.0", "end")
            self.custom_txt.insert("1.0", sample)
            self._auto_sample = sample

    def _update_marks(self) -> None:
        """Cột 'Tác vụ': ✔/– cho biết thiết bị có hỗ trợ tác vụ đang chọn hay không."""
        tid = self.cur_tid
        for iid, d in self._dev_cache.items():
            if not self.tree.exists(iid):
                continue
            ok = tid == CUSTOM_ID or self.cat.supported(tid, d["vendor"])
            self.tree.set(iid, "ok", "✔" if ok else "–")
            self.tree.item(iid, tags=() if ok else ("muted",))

    def _select_all(self) -> None:
        self.tree.selection_set(self.tree.get_children())

    def refresh_devices(self) -> None:
        keep = set(self.tree.selection())
        clear_tree(self.tree)
        self._dev_cache = {}
        for d in self.ctx.db.list_devices(self.search.get().strip()):
            v = VENDORS.get(d["vendor"])
            iid = str(d["id"])
            self._dev_cache[iid] = d
            self.tree.insert("", "end", iid=iid, values=(
                ("🧪 " if d.get("simulated") else "") + d["name"], d["ip"], v.label.split(" (")[0] if v else d["vendor"], ""))
        self.tree.selection_set([i for i in keep if self.tree.exists(i)])
        self._update_count()
        self.refresh_task_choices()

    def _update_count(self) -> None:
        self.sel_lbl.configure(text=f"Đã chọn: {len(self.tree.selection())} / {len(self.tree.get_children())}")

    # ------------------------------------------------------------------ chế độ chạy
    def _sync_mode(self) -> None:
        if self.dry.get():
            self.mode_lbl.configure(foreground="#b45309", text=(
                "🟡 Đang ở chế độ KIỂM TRA KHÔ: ứng dụng chỉ kết nối + sao lưu cấu hình hiện tại, KHÔNG gửi lệnh nên cấu hình thiết bị "
                "không thay đổi. Muốn áp dụng thật: BỎ TICK 'Kiểm tra khô' rồi bấm Thực thi."))
            self.btn_run.configure(text="▶ Kiểm tra khô", style="Accent.TButton")
        else:
            self.mode_lbl.configure(foreground="#dc2626", text=(
                "🔴 Chế độ ÁP DỤNG THẬT: lệnh sẽ được GỬI lên thiết bị (đã tự sao lưu trước và sau để so sánh/khôi phục)."))
            self.btn_run.configure(text="▶ Thực thi THẬT", style="Danger.TButton")

    def _show_result(self) -> None:
        sel = self.res_tree.selection()
        r = self._results.get(sel[0]) if sel else None
        if not r:
            return
        cmds = r["commands"] if isinstance(r["commands"], str) else "\n".join(r["commands"])
        parts = [f"■ {r['name']} ({r['ip']})  -  {STATUS_LABELS.get(r['status'], r['status'])}", f"  {r['message']}", ""]
        parts += ["▌ LỆNH " + ("ĐÃ GỬI" if r["status"] in ("success", "warning") else "SẼ GỬI (chưa gửi)") + ":", cmds or "(không có)", ""]
        if r.get("output", "").strip():
            parts += ["▌ PHẢN HỒI CỦA THIẾT BỊ:", r["output"], ""]
        if r.get("diff"):
            parts += ["▌ THAY ĐỔI CẤU HÌNH (diff):", r["diff"]]
        elif r["status"] == "dry_run":
            parts += ["(Kiểm tra khô: cấu hình thiết bị chưa thay đổi nên chưa có diff.)"]
        set_text(self.res_detail, "\n".join(parts), diff=False)

    def _offer_apply(self) -> None:
        """Sau khi kiểm tra khô thành công: hỏi có muốn áp dụng thật luôn không."""
        if self.running or not self.ctx.can("run_tasks"):
            return
        if messagebox.askyesno("Kiểm tra khô xong", "Kiểm tra khô thành công - CHƯA có lệnh nào được gửi lên thiết bị.\n\n"
                               "Bạn có muốn ÁP DỤNG THẬT các lệnh này lên thiết bị ngay bây giờ không?",
                               parent=self.app.root, icon="question"):
            self.dry.set(False)
            self._sync_mode()
            self.run(confirmed=True)

    # ------------------------------------------------------------------ lệnh tùy chỉnh
    def _refresh_saved(self) -> None:
        self.saved_cb.configure(values=self.cat.list_custom())

    def _load_custom(self) -> None:
        if self.saved.get():
            self.custom_txt.delete("1.0", "end")
            self.custom_txt.insert("1.0", self.cat.load_custom(self.saved.get()))

    def _save_custom(self) -> None:
        name = simpledialog.askstring("Lưu mẫu", "Tên mẫu:", parent=self.app.root)
        if name:
            try:
                self.cat.save_custom(name, self.custom_txt.get("1.0", "end").rstrip() + "\n")
            except TemplateError as e:
                return messagebox.showerror("Lỗi", str(e), parent=self.app.root)
            self._refresh_saved()
            self.saved.set(self.cat._safe(name))

    def _del_custom(self) -> None:
        if self.saved.get() and messagebox.askyesno("Xóa mẫu", f"Xóa mẫu '{self.saved.get()}'?", parent=self.app.root):
            self.cat.delete_custom(self.saved.get())
            self.saved.set("")
            self._refresh_saved()

    @staticmethod
    def _int(var, default: int) -> int:
        try:                                   # ô số bị xóa trống / nhập chữ -> dùng giá trị mặc định thay vì báo lỗi
            return int(var.get())
        except (tk.TclError, ValueError, TypeError):
            return default

    def _run_options(self) -> dict:
        return {"dry": self.dry.get(), "save": self.save.get(), "workers": max(1, self._int(self.workers, 5)),
                "stop_on_error": self.stop_on_err.get(), "canary": max(0, self._int(self.canary, 0)),
                "verify": self.verify.get(), "safe_minutes": max(0, self._int(self.safe, 0))}

    def make_payload(self, devs: list[dict]) -> dict:
        tid = self.task_id()
        if tid == CUSTOM_ID:
            text = self.custom_txt.get("1.0", "end")
            if not text.strip():
                raise TemplateError("Chưa nhập lệnh nào.")
            return build_payload(tid, {}, self.per_vars, text, parse_kv_lines(self.custom_vars.get("1.0", "end")),
                                 [d["id"] for d in devs], self._run_options())
        return build_payload(tid, self.form.values(), self.per_vars, "", {}, [d["id"] for d in devs], self._run_options())

    def make_builder(self, devs: Optional[list] = None):
        """Hàm sinh lệnh cho từng thiết bị (đã gộp biến riêng từ CSV/Excel nếu có)."""
        payload = self.make_payload(devs if devs is not None else self.selected())
        tid = payload["task_id"]
        return builder_from_payload(self.cat, payload), ("Lệnh tùy chỉnh" if tid == CUSTOM_ID else self.cat.label(tid))

    def _values_for(self, dev: dict) -> dict:
        base = {} if self.task_id() == CUSTOM_ID else self.form.values()
        return {**base, **pervar.lookup(self.per_vars, dev)}

    # ---- biến theo thiết bị ----
    def load_pervars(self) -> None:
        path = filedialog.askopenfilename(parent=self.app.root, title="Chọn file biến theo thiết bị",
                                          filetypes=[("CSV / Excel", "*.csv *.xlsx"), ("Tất cả", "*.*")])
        if not path:
            return
        try:
            table = pervar.load_table(Path(path))
        except Exception as e:  # noqa: BLE001
            return messagebox.showerror("Lỗi đọc file", f"{type(e).__name__}: {e}", parent=self.app.root)
        if not table:
            return messagebox.showwarning("Biến theo thiết bị", "Không đọc được dòng nào. File cần có cột 'device' (tên hoặc IP thiết bị).",
                                          parent=self.app.root)
        self.per_vars, self.per_src = table, Path(path).name
        sel = self.selected()
        hit = sum(1 for d in sel if pervar.lookup(table, d))
        self.pervar_lbl.configure(text=f"Đã nạp '{self.per_src}': {len({id(v) for v in table.values()})} thiết bị có biến riêng"
                                       + (f"; {hit}/{len(sel)} thiết bị đang chọn khớp." if sel else "."))
        self.refresh_task_choices()

    def clear_pervars(self) -> None:
        self.per_vars, self.per_src = {}, ""
        self.pervar_lbl.configure(text="Chưa nạp biến riêng: mọi thiết bị dùng cùng giá trị ở form.")

    def make_pervar_template(self) -> None:
        devs, tid = self.selected(), self.task_id()
        if not devs or tid == CUSTOM_ID:
            return messagebox.showinfo("File mẫu", "Hãy chọn thiết bị và một tác vụ dựng sẵn (không phải lệnh tùy chỉnh).", parent=self.app.root)
        path = filedialog.asksaveasfilename(parent=self.app.root, defaultextension=".csv", initialfile="bien_theo_thiet_bi.csv",
                                            filetypes=[("CSV", "*.csv"), ("Excel", "*.xlsx")])
        if path:
            fams = self._families(devs)
            pervar.write_template(Path(path), devs, self.cat.fields_for(tid, fams), self.form.values())
            messagebox.showinfo("File mẫu", "Đã tạo file mẫu: mỗi thiết bị một dòng. Sửa giá trị cho từng máy rồi bấm 'Nạp biến theo thiết bị'.",
                                parent=self.app.root)

    # ---- hẹn giờ ----
    def schedule_job(self) -> None:
        if not self.app.require("run_tasks", "hẹn giờ chạy cấu hình"):
            return
        devs = self.selected()
        if not devs:
            return messagebox.showinfo("Hẹn giờ", "Hãy chọn ít nhất một thiết bị.", parent=self.app.root)
        try:
            when = parse_when(self.when.get())
            payload = self.make_payload(devs)
            builder, label = self.make_builder(devs)
            for i, d in enumerate(devs, start=1):
                try:
                    builder(d, i)
                except TaskUnsupported:
                    pass
            jid = self.ctx.jobs.schedule(when, label, payload)
        except (ValueError, TemplateError) as e:
            return messagebox.showerror("Hẹn giờ", str(e), parent=self.app.root)
        self.app.set_status(f"Đã hẹn #{jid}: {label} lúc {when:%Y-%m-%d %H:%M} ({len(devs)} thiết bị)")
        messagebox.showinfo("Đã đặt lịch", f"Sẽ chạy '{label}' trên {len(devs)} thiết bị lúc {when:%Y-%m-%d %H:%M}.\n\n"
                            "Lưu ý: ứng dụng phải đang mở vào thời điểm đó. Chế độ (kiểm tra khô/áp dụng thật) lấy theo các tùy chọn hiện tại.",
                            parent=self.app.root)
        if "logs" in self.app.tabs:
            self.app.tabs["logs"].refresh_history()

    # ------------------------------------------------------------------ xem trước
    def preview(self) -> None:
        devs = self.selected()
        if not devs:
            return messagebox.showinfo("Xem trước", "Hãy chọn ít nhất một thiết bị ở cột bên trái.", parent=self.app.root)
        try:
            builder, label = self.make_builder()
        except TemplateError as e:
            return messagebox.showerror("Thiếu/sai thông tin", str(e), parent=self.app.root)
        t = self.preview_txt
        t.configure(state="normal")
        t.delete("1.0", "end")
        bad = 0
        links = self._link_warnings(devs, self.task_id())
        guards = self._guard_warnings(devs, builder)
        for i, d in enumerate(devs, start=1):
            v = VENDORS[d["vendor"]]
            t.insert("end", f"━━ {d['name']} ({d['ip']})  [{v.label}] ━━\n", "hdr")
            for w in guards.get(d["name"], []):
                t.insert("end", f"  {w}\n", "err")
            for w in links.get(d["name"], []):
                t.insert("end", f"  ⚠ {w}\n", "warn")
            try:
                for line in redact_lines(builder(d, i)):
                    t.insert("end", "  " + line + "\n")
            except TaskUnsupported as e:
                bad += 1
                t.insert("end", f"  (bỏ qua) {e}\n", "warn")
            except TemplateError as e:
                bad += 1
                t.insert("end", f"  (LỖI) {e}\n", "err")
            t.insert("end", "\n")
        t.configure(state="disabled")
        self.nb.select(0)
        self.rscroll.scroll_to_bottom()
        self.app.set_status(f"Xem trước {label}: {len(devs)} thiết bị" + (f", {bad} bị bỏ qua/lỗi" if bad else "")
                            + (f", {len(links)} thiết bị có cảnh báo liên kết" if links else "")
                            + (f", ⛔ {len(guards)} thiết bị có nguy cơ mất kết nối" if guards else ""))

    # ------------------------------------------------------------------ chạy
    def run(self, confirmed: bool = False) -> None:
        if self.running or not self.app.require("run_tasks", "chạy cấu hình"):
            return
        devs = self.selected()
        if not devs:
            return messagebox.showinfo("Thực thi", "Hãy chọn ít nhất một thiết bị.", parent=self.app.root)
        try:
            builder, label = self.make_builder()
            for i, d in enumerate(devs, start=1):      # kiểm tra dữ liệu nhập trước khi kết nối
                try:
                    builder(d, i)
                except TaskUnsupported:
                    pass
        except TemplateError as e:
            return messagebox.showerror("Thiếu/sai thông tin", str(e), parent=self.app.root)
        dry = self.dry.get()
        self._last_dry = dry
        links = {} if dry else self._link_warnings(devs, self.task_id())
        guards = {} if dry else self._guard_warnings(devs, builder)
        if guards and not confirmed:
            lines = [f"• {n}: {w}" for n, ws in guards.items() for w in ws][:8]
            if not messagebox.askyesno("⛔ NGUY CƠ MẤT KẾT NỐI QUẢN TRỊ",
                                       "Lệnh sắp gửi có thể làm ỨNG DỤNG MẤT KẾT NỐI tới thiết bị (khi đó không thể hoàn tác từ xa):\n\n"
                                       + "\n".join(lines) + "\n\nBạn có chắc chắn muốn tiếp tục?", parent=self.app.root, icon="error", default="no"):
                return
        if links and not confirmed:
            lines = [f"• {n}: {w}" for n, ws in links.items() for w in ws][:10]
            if not messagebox.askyesno("Cảnh báo liên kết với cấu hình hiện có",
                                       "Một số giá trị chưa khớp với cấu hình đang có trên thiết bị:\n\n" + "\n".join(lines)
                                       + "\n\nVẫn tiếp tục gửi lệnh?", parent=self.app.root, icon="warning"):
                return
        if not dry and not confirmed:
            msg = (f"Sắp GỬI cấu hình '{label}' lên {len(devs)} thiết bị.\n\n"
                   "• Cấu hình hiện tại sẽ được sao lưu trước.\n• Thiết bị báo lỗi sẽ KHÔNG được lưu.\n"
                   "• Nên chạy 'Kiểm tra khô' và 'Xem trước lệnh' trước.\n\nTiếp tục?")
            if not messagebox.askyesno("Xác nhận thực thi", msg, parent=self.app.root, icon="warning"):
                return
        self._start_ui(len(devs))
        eng, o = self.ctx.engine, self._run_options()
        self.cancel = threading.Event()
        cancel = self.cancel

        def work():
            return eng.run_job(devs, builder, label, dry_run=dry, save=o["save"], workers=o["workers"], cancel=cancel,
                               stop_on_error=o["stop_on_error"], canary=o["canary"], safe_minutes=o["safe_minutes"], verify=o["verify"])

        def done(res, exc):
            self._end_ui()
            if exc:
                messagebox.showerror("Lỗi", f"{type(exc).__name__}: {exc}", parent=self.app.root)

        self.app.run_bg(work, done)

    def _start_ui(self, total: int) -> None:
        self.running = True
        clear_tree(self.res_tree)
        self._results.clear()
        self.prog.configure(maximum=total, value=0)
        self.prog_lbl.configure(text=f"0/{total}")
        self.btn_run.configure(state="disabled")
        self.btn_prev.configure(state="disabled")
        self.btn_cancel.configure(state="normal")
        self.btn_report.configure(state="disabled")
        self.nb.select(1)
        self.rscroll.scroll_to_bottom()

    def _end_ui(self) -> None:
        self.running = False
        self.btn_run.configure(state="normal" if self.ctx.can("run_tasks") else "disabled")
        self.btn_prev.configure(state="normal")
        self.btn_cancel.configure(state="disabled")
        self.btn_report.configure(state="normal" if self.last_job_id else "disabled")
        self.app.notify_devices_changed()

    def on_event(self, kind: str, data: dict) -> None:
        if kind == "progress":
            self.prog.configure(value=data["done"])
            self.prog_lbl.configure(text=f"{data['done']}/{data['total']}")
        elif kind == "result":
            r = data["result"]
            self.last_job_id = data["job_id"]
            tag = {"success": "ok", "dry_run": "ok", "warning": "warn", "failed": "err"}.get(r.status, "muted")
            iid = self.res_tree.insert("", "end", tags=(tag,), values=(r.name, r.ip, STATUS_LABELS.get(r.status, r.status), r.message))
            self._results[iid] = {"name": r.name, "ip": r.ip, "status": r.status, "message": r.message,
                                  "commands": r.commands, "output": r.output, "diff": r.diff}
            if not self.res_tree.selection():
                self.res_tree.selection_set(iid)
                self._show_result()
        elif kind == "job_done":
            self.app.set_status(f"Hoàn tất: {data['ok']} thành công, {data['failed']} lỗi/cảnh báo.")
            if data["failed"]:
                messagebox.showwarning("Hoàn tất có lỗi", f"{data['ok']} thành công, {data['failed']} lỗi/cảnh báo.\n"
                                       "Chọn từng dòng để xem chi tiết.", parent=self.app.root)
            elif self._last_dry and data["ok"]:
                self.app.call_soon(self._offer_apply)     # chạy sau khi giao diện đã mở khóa nút

    def _open_detail(self, _e=None) -> None:
        sel = self.res_tree.selection()
        if sel and sel[0] in self._results:
            show_result_detail(self.app, self._results[sel[0]])

    def export_report(self) -> None:
        if not self.last_job_id:
            return
        db = self.ctx.db
        path = filedialog.asksaveasfilename(parent=self.app.root, defaultextension=".html", initialfile=f"bao_cao_job_{self.last_job_id}.html",
                                            filetypes=[("HTML", "*.html"), ("Excel", "*.xlsx"), ("CSV", "*.csv")])
        if path:
            importer.export_job_report(Path(path), db.get_job(self.last_job_id), db.job_results(self.last_job_id))
            messagebox.showinfo("Báo cáo", f"Đã lưu: {path}", parent=self.app.root)
