"""Engine: chạy tác vụ hàng loạt (đa luồng), backup, so sánh, rollback."""
from __future__ import annotations

import re
import threading
from concurrent.futures import ThreadPoolExecutor
from dataclasses import asdict, dataclass, field
from datetime import datetime
from pathlib import Path
from typing import Callable, Optional

from drivers.base import ConnParams, DriverError, MockDriver, extract_version, friendly_error, get_driver
from drivers.vendors import VENDORS, get_vendor
from . import health
from .config_tools import (config_hash, count_changes, normalize, rollback_commands, unified_diff)
from .redact import redact_lines, redact_text
from .database import Database, now
from .logger import get_logger
from .security import Vault
from .templating import TaskUnsupported

Builder = Callable[[dict, int], list]   # (device_row, index) -> list[str]
Emit = Callable[..., None]

STATUS_LABELS = {"success": "Thành công", "warning": "Có cảnh báo", "failed": "Thất bại",
                 "dry_run": "Kiểm tra khô OK", "skipped": "Bỏ qua", "cancelled": "Đã hủy"}


@dataclass
class DeviceResult:
    device_id: int
    name: str
    ip: str
    status: str = "failed"
    message: str = ""
    commands: list = field(default_factory=list)
    output: str = ""
    diff: str = ""
    backup_before: Optional[int] = None
    backup_after: Optional[int] = None
    started: str = ""
    finished: str = ""


class Engine:
    def __init__(self, db: Database, vault: Vault, home: Path):
        self.db, self.vault, self.home = db, vault, Path(home)
        self.log = get_logger()
        self.emit: Emit = lambda kind, **kw: None   # GUI gán hàm nhận sự kiện
        self._db_lock = threading.Lock()
        MockDriver.configure(self.home / "simulated_state.json")   # nhớ cấu hình thiết bị giả lập

    # ------------------------------------------------------------------ tiện ích
    @property
    def user(self) -> str:
        return (self.vault.user or {}).get("username", "system")

    def conn_params(self, dev: dict) -> ConnParams:
        return ConnParams(
            name=dev["name"], host=dev["ip"], vendor=dev["vendor"], username=dev.get("username") or "",
            password=self.vault.decrypt(dev.get("password_enc") or ""), secret=self.vault.decrypt(dev.get("secret_enc") or ""),
            port=int(dev.get("port") or 22), protocol=dev.get("protocol") or "ssh", simulated=bool(dev.get("simulated")),
            model=(dev.get("model") or "") if dev.get("simulated") else "",
            timeout=int(self.db.get_setting("timeout", 30)), delay_factor=float(self.db.get_setting("delay_factor", 1.0)),
            host_key_mode=str(self.db.get_setting("host_key_mode", "tofu")), known_hosts=str(self.home / "known_hosts"))

    def _backup_path(self, dev: dict) -> Path:
        safe = re.sub(r"[^\w.\-]+", "_", dev["name"]) or f"dev{dev['id']}"
        d = self.home / "backups" / safe
        d.mkdir(parents=True, exist_ok=True)
        return d / f"{datetime.now():%Y%m%d_%H%M%S_%f}.cfg"

    def store_backup(self, dev: dict, text: str, note: str, force: bool = False) -> tuple[int, bool]:
        """Lưu backup nếu khác bản gần nhất. Trả về (backup_id, có_thay_đổi)."""
        h = config_hash(text)
        with self._db_lock:
            last = self.db.last_backup(dev["id"])
            if last and last["hash"] == h and not force:
                return last["id"], False
            path = self._backup_path(dev)
            path.write_text(text, encoding="utf-8")
            bid = self.db.add_backup(dev["id"], text, h, note, self.user, str(path))
            self._prune(dev)
        return bid, True

    def _prune(self, dev: dict) -> int:
        """Giữ số bản sao lưu theo chính sách (Cài đặt): tối đa N bản / thiết bị và/hoặc N ngày."""
        keep, days = int(self.db.get_setting("retention_keep", 50)), int(self.db.get_setting("retention_days", 0))
        removed = self.db.prune_backups(dev["id"], keep, days)
        for p in removed:
            try:
                Path(p).unlink(missing_ok=True)
            except OSError:
                pass
        return len(removed)

    # ------------------------------------------------------------------ kiểm tra kết nối
    def test_connection(self, dev: dict) -> tuple[bool, str]:
        drv = None
        try:
            drv = get_driver(self.conn_params(dev))
            drv.connect()
            facts = drv.get_facts()
            self.db.update_device(dev["id"], status="online", last_seen=now(), os_version=facts.get("os_version", ""))
            return True, facts.get("os_version") or "Kết nối OK"
        except Exception as e:
            self.db.update_device(dev["id"], status="offline")
            return False, friendly_error(e)
        finally:
            if drv:
                drv.disconnect()

    def autodetect(self, dev: dict) -> str:
        """Dò chính xác hãng bằng Netmiko SSHDetect (cần tài khoản đăng nhập)."""
        if dev.get("simulated"):
            return dev["vendor"]                      # thiết bị giả lập: hãng do người dùng chọn
        try:
            from netmiko.ssh_autodetect import SSHDetect
        except ImportError as e:
            raise DriverError("Chưa cài Netmiko. Chạy: pip install -r requirements.txt") from e
        p = self.conn_params(dev)
        guesser = SSHDetect(device_type="autodetect", host=p.host, username=p.username, password=p.password,
                            port=p.port, secret=p.secret, timeout=p.timeout)
        try:
            best = guesser.autodetect()
        finally:
            try:
                guesser.connection.disconnect()
            except Exception:
                pass
        if not best:
            raise DriverError("Không dò được hãng - hãy chọn thủ công.")
        for key, v in VENDORS.items():
            if v.netmiko == best and key != "mock":
                return key
        raise DriverError(f"Dò ra loại '{best}' nhưng ứng dụng chưa hỗ trợ.")

    # ------------------------------------------------------------------ backup
    def backup_device(self, dev: dict, note: str = "Sao lưu thủ công") -> tuple[bool, str, bool]:
        """Trả về (thành_công, thông_điệp, có_thay_đổi_so_với_bản_trước)."""
        drv = None
        try:
            drv = get_driver(self.conn_params(dev))
            drv.connect()
            text = drv.get_config()
            if not text.strip():
                raise DriverError("Thiết bị trả về cấu hình rỗng.")
            had_prev = self.db.last_backup(dev["id"]) is not None
            bid, changed = self.store_backup(dev, text, note)
            self.db.update_device(dev["id"], status="online", last_seen=now())
            drift = had_prev and changed
            if drift:
                self.log.warning("[%s] Cấu hình ĐÃ THAY ĐỔI so với bản sao lưu trước (backup #%s)", dev["name"], bid)
                self.db.audit(self.user, "config_drift", f"{dev['name']} backup#{bid}")
            else:
                self.log.info("[%s] Sao lưu OK%s", dev["name"], "" if changed else " (không đổi)")
            return True, f"Backup #{bid}" + (" - cấu hình đã thay đổi" if drift else ""), drift
        except Exception as e:
            self.db.update_device(dev["id"], status="offline")
            msg = friendly_error(e)
            self.log.error("[%s] Sao lưu thất bại: %s", dev["name"], msg)
            return False, msg, False
        finally:
            if drv:
                drv.disconnect()

    def backup_many(self, devices: list[dict], workers: int = 5, note: str = "Sao lưu hàng loạt",
                    cancel: Optional[threading.Event] = None) -> dict:
        stats = {"ok": 0, "failed": 0, "drift": 0}

        def one(d: dict) -> None:
            if cancel is not None and cancel.is_set():
                return
            ok, _, drift = self.backup_device(d, note)
            with self._db_lock:
                stats["ok" if ok else "failed"] += 1
                stats["drift"] += int(drift)

        with ThreadPoolExecutor(max_workers=max(1, workers)) as ex:
            list(ex.map(one, devices))
        self.db.audit(self.user, "backup_many", f"{stats}")
        return stats

    # ------------------------------------------------------------------ chạy tác vụ
    def run_job(self, devices: list[dict], builder: Builder, label: str, *, dry_run: bool = True, save: bool = True,
                workers: int = 5, cancel: Optional[threading.Event] = None, stop_on_error: bool = False, canary: int = 0,
                safe_minutes: int = 0, verify: bool = False) -> tuple[int, list[DeviceResult]]:
        """Chạy tác vụ trên nhiều thiết bị.

        stop_on_error: dừng các thiết bị còn lại khi một thiết bị lỗi/cảnh báo.
        canary: chạy tuần tự N thiết bị đầu tiên trước (nếu ổn mới chạy song song phần còn lại).
        safe_minutes: Junos/SRX - dùng 'commit confirmed N', chỉ xác nhận khi kết nối lại được; không thì thiết bị tự quay về.
        verify: chụp số giao diện up / số route trước và sau, cảnh báo nếu giảm.
        """
        cancel = cancel or threading.Event()
        stop = threading.Event()
        job_id = self.db.add_job(label, self.user, dry_run, len(devices))
        opts = [x for x, on in (("dừng khi lỗi", stop_on_error), (f"chạy thử {canary} máy đầu", canary), (f"commit confirmed {safe_minutes}p", safe_minutes),
                                ("kiểm tra trước/sau", verify)) if on]
        self.db.audit(self.user, "job_dry_run" if dry_run else "job_run", f"#{job_id} {label} ({len(devices)} thiết bị)" + (f" [{', '.join(opts)}]" if opts else ""))
        self.log.info("=== Bắt đầu tác vụ #%s: %s | %d thiết bị | %s%s ===", job_id, label, len(devices),
                      "KIỂM TRA KHÔ" if dry_run else "ÁP DỤNG THẬT", f" | {', '.join(opts)}" if opts else "")
        results: list[DeviceResult] = []
        done = 0
        lock = threading.Lock()

        def one(idx_dev: tuple[int, dict]) -> None:
            nonlocal done
            idx, dev = idx_dev
            r = self._process_device(dev, idx, builder, label, dry_run, save, cancel, stop, safe_minutes, verify)
            if stop_on_error and r.status in ("failed", "warning"):
                if not stop.is_set():
                    self.log.warning("Dừng các thiết bị còn lại vì [%s] bị lỗi/cảnh báo (chế độ dừng khi lỗi)", dev["name"])
                stop.set()
            with lock:
                results.append(r)
                done += 1
                self.db.add_job_result(job_id, asdict(r))
                self.emit("result", job_id=job_id, result=r)
                self.emit("progress", done=done, total=len(devices))

        items = list(enumerate(devices, start=1))
        head = items[:canary] if 0 < canary < len(items) else []
        for it in head:                                  # đợt chạy thử: tuần tự
            one(it)
            if stop.is_set() or cancel.is_set():
                break
        rest = items[len(head):]
        if not (head and (stop.is_set() or cancel.is_set())) or not stop_on_error:
            with ThreadPoolExecutor(max_workers=max(1, min(workers, 50))) as ex:
                list(ex.map(one, rest))
        else:
            for it in rest:                              # ghi nhận các máy bị bỏ qua
                one(it)
        ok = sum(r.status in ("success", "dry_run") for r in results)
        bad = sum(r.status in ("failed", "warning") for r in results)
        self.db.finish_job(job_id, ok, bad, "cancelled" if cancel.is_set() else "done")
        self.log.info("=== Kết thúc #%s: %d thành công, %d lỗi/cảnh báo ===", job_id, ok, bad)
        self.emit("job_done", job_id=job_id, ok=ok, failed=bad)
        return job_id, results

    def _verify_access(self, dev: dict) -> tuple[bool, str]:
        """Mở kết nối MỚI để chắc chắn vẫn quản trị được thiết bị sau khi thay đổi."""
        drv = None
        try:
            drv = get_driver(self.conn_params(dev))
            drv.connect()
            drv.run_show(get_vendor(dev["vendor"]).facts_cmd)
            return True, "kết nối lại OK"
        except Exception as e:
            return False, friendly_error(e)
        finally:
            if drv:
                drv.disconnect()

    def _process_device(self, dev: dict, idx: int, builder: Builder, label: str, dry_run: bool, save: bool,
                        cancel: threading.Event, stop: Optional[threading.Event] = None, safe_minutes: int = 0,
                        verify: bool = False) -> DeviceResult:
        stop = stop or threading.Event()
        r = DeviceResult(device_id=dev["id"], name=dev["name"], ip=dev["ip"], started=now())
        tag = f"[{dev['name']}]"
        if cancel.is_set() or stop.is_set():
            r.status = "cancelled"
            r.message = "Đã hủy trước khi chạy" if cancel.is_set() else "Bỏ qua: đã dừng vì một thiết bị trước đó bị lỗi/cảnh báo (chế độ dừng khi lỗi)"
            r.finished = now()
            return r
        try:
            cmds = list(builder(dev, idx))
        except TaskUnsupported as e:
            r.status, r.message, r.finished = "skipped", str(e), now()
            self.log.warning("%s Bỏ qua: %s", tag, e)
            return r
        except Exception as e:
            r.status, r.message, r.finished = "failed", f"Lỗi tạo lệnh: {e}", now()
            self.log.error("%s %s", tag, r.message)
            return r
        if not cmds:
            r.status, r.message, r.finished = "skipped", "Không có lệnh nào để gửi", now()
            return r
        r.commands = redact_lines(cmds)                    # lịch sử/báo cáo chỉ lưu bản đã che mật khẩu
        vendor = get_vendor(dev["vendor"])

        drv = None
        try:
            drv = get_driver(self.conn_params(dev))
            self.log.info("%s Đang kết nối %s ...", tag, dev["ip"])
            drv.connect()
            before = drv.get_config()
            r.backup_before, _ = self.store_backup(dev, before, f"Trước khi chạy: {label}")
            snap_before = health.snapshot(drv, vendor) if verify else {}
            if dry_run:
                r.status, r.message = "dry_run", f"Kết nối & backup OK. {len(cmds)} lệnh CHƯA được gửi (đang ở chế độ kiểm tra khô)"
                self.log.info("%s %s", tag, r.message)
            elif cancel.is_set():
                r.status, r.message = "cancelled", "Đã hủy trước khi gửi lệnh"
            else:
                use_confirm = safe_minutes if (safe_minutes and vendor.save == "commit") else 0
                self.log.info("%s Gửi %d lệnh%s ...", tag, len(cmds), f" (commit confirmed {use_confirm} phút)" if use_confirm else "")
                ap = drv.apply(cmds, save=save, confirm_minutes=use_confirm)
                r.output = redact_text(ap.output)
                after = drv.get_config()
                snap_after = health.snapshot(drv, vendor) if verify else {}
                r.diff = redact_text(unified_diff(before, after, "trước", "sau"))
                add, rem = count_changes(r.diff)
                if ap.errors:
                    r.status = "warning"
                    r.message = (f"Thiết bị báo lỗi {len(ap.errors)} dòng (đã KHÔNG lưu cấu hình): " + "; ".join(ap.errors[:2]))
                else:
                    r.status = "success"
                    r.message = f"OK (+{add}/-{rem} dòng cấu hình)"
                    if not save and vendor.save == "netmiko":
                        r.message += " - CHƯA lưu vào startup-config"
                    if ap.pending_confirm:                       # Junos commit confirmed: chỉ xác nhận khi kết nối lại được
                        ok, why = self._verify_access(dev)
                        if ok:
                            drv.confirm_commit()
                            r.backup_after, _ = self.store_backup(dev, after, f"Sau khi chạy: {label}")
                            r.message += f" | đã XÁC NHẬN commit ({why})"
                        else:
                            r.status = "warning"
                            r.message = (f"Đã áp dụng nhưng KHÔNG xác minh được kết nối ({why}) → thiết bị sẽ TỰ HOÀN TÁC sau "
                                         f"{use_confirm} phút. Hãy kiểm tra đường quản trị.")
                    else:
                        r.backup_after, _ = self.store_backup(dev, after, f"Sau khi chạy: {label}")
                    if verify and r.status == "success":
                        bad = health.compare(snap_before, snap_after)
                        r.output += "\n\n▌ KIỂM TRA TRƯỚC/SAU THAY ĐỔI:\n" + health.describe(snap_before, snap_after)
                        if bad:
                            r.status = "warning"
                            r.message += " | ⚠ SAU THAY ĐỔI: " + "; ".join(bad) + " - nên kiểm tra/khôi phục"
                (self.log.warning if r.status == "warning" else self.log.info)("%s %s", tag, r.message)
            self.db.update_device(dev["id"], status="online", last_seen=now())
        except Exception as e:
            r.status, r.message = "failed", friendly_error(e)
            self.log.error("%s Thất bại: %s", tag, r.message)
            self.db.update_device(dev["id"], status="offline")
        finally:
            if drv:
                drv.disconnect()
            r.finished = now()
        return r

    # ------------------------------------------------------------------ rollback
    def preview_rollback(self, dev: dict, backup_id: int) -> tuple[list[str], list[str], str]:
        """Tính lệnh đưa thiết bị về bản backup. Trả về (lệnh, cảnh báo, diff hiện tại→bản backup)."""
        v = get_vendor(dev["vendor"])
        if not v.negate:
            raise DriverError(f"{v.label} chưa hỗ trợ rollback tự động. Hãy khôi phục thủ công từ file backup.")
        b = self.db.get_backup(backup_id)
        if not b or b["device_id"] != dev["id"]:
            raise DriverError("Không tìm thấy bản sao lưu.")
        drv = get_driver(self.conn_params(dev))
        try:
            drv.connect()
            current = drv.get_config()
        finally:
            drv.disconnect()
        cmds, warns = rollback_commands(current, b["config"], v.negate, v.exit_cmd)
        return cmds, warns, unified_diff(current, b["config"], "hiện tại", f"backup #{backup_id}")

    def rollback(self, dev: dict, backup_id: int, commands: list[str], save: bool = True) -> DeviceResult:
        _, results = self.run_job([dev], lambda d, i: commands, f"Rollback về backup #{backup_id}",
                                  dry_run=False, save=save, workers=1)
        self.db.audit(self.user, "rollback", f"{dev['name']} -> backup#{backup_id}: {results[0].status}")
        return results[0]

    def reset_simulated(self, dev: dict) -> None:
        """Đưa thiết bị giả lập về cấu hình ban đầu."""
        MockDriver.forget(dev["ip"], dev["vendor"])
        self.db.audit(self.user, "reset_simulated", dev["name"])

    # ------------------------------------------------------------------ chạy lệnh xem
    def run_show(self, dev: dict, command: str) -> str:
        drv = get_driver(self.conn_params(dev))
        try:
            drv.connect()
            return drv.run_show(command)
        finally:
            drv.disconnect()


SAFE_FIRST_WORDS = {"show", "display", "get", "print", "ping", "traceroute", "tracepath", "export", "uname", "cat"}


def is_read_only_command(cmd: str) -> bool:
    """Chỉ cho phép lệnh xem (không làm thay đổi cấu hình) trong công cụ Terminal."""
    c = cmd.strip().lower()
    if not c or any(ch in c for ch in (";", "&&", "`", "$(", ">")):
        return False
    if any(p.strip().split(" ")[0] in ("save", "redirect", "tee", "append", "commit") for p in c.split("|")[1:]):
        return False                      # pipe ghi ra file không được phép
    first = c.split()[0]
    if c.startswith("/"):
        return " print" in c or c.startswith("/export") or c.endswith(" print")
    if first == "uci":
        return c.split()[1:2] in (["show"], ["export"], ["get"])
    return first in SAFE_FIRST_WORDS
