"""Tab Sao lưu: lịch sử bản sao lưu, so sánh, khôi phục (rollback), sao lưu tự động."""
from __future__ import annotations

import tkinter as tk
from pathlib import Path
from tkinter import filedialog, messagebox, ttk

from core.config_tools import unified_diff
from core.engine import STATUS_LABELS
from .dialogs import RollbackDialog, show_result_detail
from .widgets import clear_tree, make_tree, open_folder, show_text_window


class BackupsTab(ttk.Frame):
    def __init__(self, parent, app):
        super().__init__(parent, padding=10)
        self.app, self.ctx = app, app.ctx
        pane = ttk.PanedWindow(self, orient="horizontal")
        pane.pack(fill="both", expand=True)
        left = ttk.LabelFrame(pane, text="Thiết bị", padding=8)
        right = ttk.Frame(pane)
        pane.add(left, weight=2)
        pane.add(right, weight=5)
        f, self.devtree = make_tree(left, [("name", "Thiết bị", 130), ("ip", "IP", 100), ("n", "Số bản", 50, "center")],
                                    selectmode="browse", height=20)
        f.pack(fill="both", expand=True)
        self.devtree.bind("<<TreeviewSelect>>", lambda _e: self.load_backups())

        bar = ttk.Frame(right)
        bar.pack(fill="x")
        for text, fn, style in [("💾 Sao lưu thiết bị này", self.backup_one, "Accent.TButton"),
                                ("💾 Sao lưu tất cả", self.backup_all, "TButton"),
                                ("📂 Mở thư mục backup", lambda: open_folder(self.ctx.home / "backups"), "TButton")]:
            ttk.Button(bar, text=text, command=fn, style=style).pack(side="left", padx=(0, 6))
        bar2 = ttk.Frame(right)
        bar2.pack(fill="x", pady=6)
        for text, fn in [("👁 Xem", self.view), ("⇄ So sánh 2 bản (chọn 2 dòng)", self.compare),
                         ("⇄ So với cấu hình hiện tại", self.compare_live), ("⏪ Khôi phục về bản này", self.rollback),
                         ("📤 Lưu bản này ra file", self.export)]:
            ttk.Button(bar2, text=text, command=fn).pack(side="left", padx=(0, 6))
        f2, self.btree = make_tree(right, [("id", "#", 50), ("time", "Thời gian", 140), ("note", "Ghi chú", 280),
                                           ("user", "Người", 80), ("size", "Kích thước", 80, "e")], height=14)
        f2.pack(fill="both", expand=True)

        sch = ttk.LabelFrame(right, text="Sao lưu tự động & phát hiện thay đổi cấu hình", padding=8)
        sch.pack(fill="x", pady=(8, 0))
        ttk.Label(sch, text="Sao lưu tất cả thiết bị mỗi").pack(side="left")
        self.interval = tk.IntVar(value=int(self.ctx.db.get_setting("backup_interval", 60)))
        ttk.Spinbox(sch, from_=1, to=10080, textvariable=self.interval, width=6).pack(side="left", padx=4)
        ttk.Label(sch, text="phút").pack(side="left")
        self.sch_btn = ttk.Button(sch, text="▶ Bật", command=self.toggle_scheduler)
        self.sch_btn.pack(side="left", padx=10)
        self.sch_lbl = ttk.Label(sch, text="Đang tắt. (Chỉ chạy khi chương trình đang mở.)", style="Muted.TLabel")
        self.sch_lbl.pack(side="left")
        self.refresh_devices()

    # ------------------------------------------------------------------ dữ liệu
    def refresh_devices(self) -> None:
        keep = self.devtree.selection()
        clear_tree(self.devtree)
        for d in self.ctx.db.list_devices():
            self.devtree.insert("", "end", iid=str(d["id"]), values=(d["name"], d["ip"], len(self.ctx.db.list_backups(d["id"]))))
        if keep and self.devtree.exists(keep[0]):
            self.devtree.selection_set(keep)
        self.load_backups()

    def on_show(self) -> None:
        self.refresh_devices()

    def on_event(self, kind: str, data: dict) -> None:
        if kind in ("job_done", "scheduler"):
            self.refresh_devices()
        if kind == "scheduler":
            s = data["stats"]
            self.sch_lbl.configure(text=f"Lần chạy gần nhất: {s['ok']} OK, {s['failed']} lỗi, {s['drift']} thiết bị bị đổi cấu hình")

    def device(self):
        sel = self.devtree.selection()
        return self.ctx.db.get_device(int(sel[0])) if sel else None

    def load_backups(self) -> None:
        clear_tree(self.btree)
        d = self.device()
        if not d:
            return
        for b in self.ctx.db.list_backups(d["id"]):
            self.btree.insert("", "end", iid=str(b["id"]), values=(b["id"], b["created"], b["note"], b["user"], f"{b['size']:,} B"))

    def _selected_backups(self) -> list[dict]:
        return [self.ctx.db.get_backup(int(i)) for i in self.btree.selection()]

    # ------------------------------------------------------------------ sao lưu
    def backup_one(self) -> None:
        if not self.app.require("backup", "sao lưu"):
            return
        d = self.device()
        if not d:
            return messagebox.showinfo("Sao lưu", "Hãy chọn một thiết bị ở cột bên trái.", parent=self.app.root)
        self.app.set_status(f"Đang sao lưu {d['name']}...")

        def done(res, exc):
            if exc:
                return messagebox.showerror("Lỗi", str(exc), parent=self.app.root)
            ok, msg, _ = res
            self.app.set_status(f"{d['name']}: {msg}")
            self.app.notify_devices_changed()
            if not ok:
                messagebox.showerror("Sao lưu thất bại", msg, parent=self.app.root)

        self.app.run_bg(lambda: self.ctx.engine.backup_device(d), done)

    def backup_all(self) -> None:
        if not self.app.require("backup", "sao lưu"):
            return
        devs = self.ctx.db.list_devices()
        if not devs:
            return
        self.app.set_status(f"Đang sao lưu {len(devs)} thiết bị...")
        workers = int(self.ctx.db.get_setting("workers", 5))

        def done(res, exc):
            if exc:
                return messagebox.showerror("Lỗi", str(exc), parent=self.app.root)
            self.app.set_status(f"Sao lưu xong: {res['ok']} OK, {res['failed']} lỗi, {res['drift']} thiết bị bị đổi cấu hình.")
            self.app.notify_devices_changed()
            messagebox.showinfo("Sao lưu hàng loạt", f"Thành công: {res['ok']}\nThất bại: {res['failed']}\n"
                                f"Cấu hình đã thay đổi so với lần trước: {res['drift']}", parent=self.app.root)

        self.app.run_bg(lambda: self.ctx.engine.backup_many(devs, workers), done)

    # ------------------------------------------------------------------ xem / so sánh
    def view(self) -> None:
        sel = self._selected_backups()
        if len(sel) != 1:
            return messagebox.showinfo("Xem", "Hãy chọn một bản sao lưu.", parent=self.app.root)
        b = sel[0]
        show_text_window(self.app, f"Backup #{b['id']} - {b['created']}", b["config"])

    def compare(self) -> None:
        sel = sorted(self._selected_backups(), key=lambda b: b["id"])
        if len(sel) != 2:
            return messagebox.showinfo("So sánh", "Hãy chọn đúng 2 bản sao lưu (giữ Ctrl để chọn thêm).", parent=self.app.root)
        a, b = sel
        diff = unified_diff(a["config"], b["config"], f"#{a['id']} ({a['created']})", f"#{b['id']} ({b['created']})")
        show_text_window(self.app, f"So sánh #{a['id']} → #{b['id']}", diff or "Hai bản giống nhau (sau khi bỏ qua dòng nhiễu).", diff=True)

    def compare_live(self) -> None:
        d, sel = self.device(), self._selected_backups()
        if not d or len(sel) != 1:
            return messagebox.showinfo("So sánh", "Chọn một thiết bị và một bản sao lưu.", parent=self.app.root)
        b = sel[0]

        def work():
            drv_cfg = {}
            from drivers.base import get_driver
            drv = get_driver(self.ctx.engine.conn_params(d))
            try:
                drv.connect()
                drv_cfg["c"] = drv.get_config()
            finally:
                drv.disconnect()
            return drv_cfg["c"]

        def done(res, exc):
            if exc:
                from drivers.base import friendly_error
                return messagebox.showerror("Lỗi kết nối", friendly_error(exc), parent=self.app.root)
            diff = unified_diff(b["config"], res, f"backup #{b['id']}", "hiện tại")
            show_text_window(self.app, f"{d['name']}: backup #{b['id']} → hiện tại", diff or "Không có khác biệt.", diff=True)

        self.app.run_bg(work, done)

    def export(self) -> None:
        sel = self._selected_backups()
        if len(sel) != 1:
            return
        b = sel[0]
        path = filedialog.asksaveasfilename(parent=self.app.root, defaultextension=".cfg", initialfile=f"backup_{b['id']}.cfg")
        if path:
            Path(path).write_text(b["config"], encoding="utf-8")

    # ------------------------------------------------------------------ rollback
    def rollback(self) -> None:
        if not self.app.require("rollback", "khôi phục cấu hình"):
            return
        d, sel = self.device(), self._selected_backups()
        if not d or len(sel) != 1:
            return messagebox.showinfo("Khôi phục", "Chọn một thiết bị và đúng một bản sao lưu muốn quay về.", parent=self.app.root)
        b = sel[0]
        self.app.set_status("Đang tính toán lệnh khôi phục...")

        def done(res, exc):
            self.app.set_status("Sẵn sàng.")
            if exc:
                from drivers.base import friendly_error
                return messagebox.showerror("Không thể khôi phục", friendly_error(exc), parent=self.app.root)
            cmds, warns, diff = res
            ok, save = RollbackDialog(self.app, d, b["id"], cmds, warns, diff).run()
            if ok:
                self._do_rollback(d, b["id"], cmds, save)

        self.app.run_bg(lambda: self.ctx.engine.preview_rollback(d, b["id"]), done)

    def _do_rollback(self, d: dict, bid: int, cmds: list[str], save: bool) -> None:
        self.app.set_status("Đang khôi phục...")

        def done(res, exc):
            self.app.set_status("Sẵn sàng.")
            self.app.notify_devices_changed()
            if exc:
                return messagebox.showerror("Lỗi", f"{type(exc).__name__}: {exc}", parent=self.app.root)
            show_result_detail(self.app, {"name": d["name"], "ip": d["ip"], "status": STATUS_LABELS.get(res.status, res.status),
                                          "message": res.message, "commands": res.commands, "output": res.output, "diff": res.diff})

        self.app.run_bg(lambda: self.ctx.engine.rollback(d, bid, cmds, save), done)

    # ------------------------------------------------------------------ lịch tự động
    def toggle_scheduler(self) -> None:
        if not self.app.require("backup", "bật sao lưu tự động"):
            return
        sch = self.ctx.scheduler
        if sch.running:
            sch.stop()
            self.sch_btn.configure(text="▶ Bật")
            self.sch_lbl.configure(text="Đang tắt.")
        else:
            minutes = max(1, int(self.interval.get() or 60))
            self.ctx.db.set_setting("backup_interval", minutes)
            sch.start(minutes)
            self.sch_btn.configure(text="■ Tắt")
            self.sch_lbl.configure(text=f"Đang bật: mỗi {minutes} phút (lần đầu chạy ngay).")
