"""Hẹn giờ chạy tác vụ (cửa sổ bảo trì). Nội dung tác vụ được mã hóa khi lưu vì có thể chứa mật khẩu."""
from __future__ import annotations

import json
import threading
from datetime import datetime, timedelta
from typing import Any, Callable, Optional

from .database import Database
from .engine import Engine
from .logger import get_logger
from .pervar import lookup
from .security import Vault
from .templating import TaskCatalog

CUSTOM_ID = "__custom__"
FMT = "%Y-%m-%d %H:%M"


def parse_when(text: str) -> datetime:
    """'2026-11-02 02:30' hoặc 'HH:MM' (giờ kế tiếp: hôm nay nếu chưa qua, không thì ngày mai) -> datetime."""
    t = text.strip()
    try:
        return datetime.strptime(t, FMT)
    except ValueError:
        pass
    try:
        hm = datetime.strptime(t, "%H:%M")
    except ValueError:
        raise ValueError("Nhập thời gian dạng 'YYYY-MM-DD HH:MM' (vd 2026-11-02 02:30) hoặc 'HH:MM'.")
    now = datetime.now()
    when = now.replace(hour=hm.hour, minute=hm.minute, second=0, microsecond=0)
    return when if when > now else when + timedelta(days=1)


def build_payload(task_id: str, values: dict, per_vars: dict, custom_text: str, custom_vars: dict, device_ids: list[int],
                  options: dict) -> dict:
    return {"task_id": task_id, "values": values, "per_vars": per_vars, "custom_text": custom_text, "custom_vars": custom_vars,
            "device_ids": device_ids, "options": options}


def builder_from_payload(catalog: TaskCatalog, payload: dict) -> Callable[[dict, int], list]:
    """Tạo hàm sinh lệnh từ payload - dùng chung cho chạy ngay và chạy hẹn giờ để kết quả giống hệt nhau."""
    tid, per = payload["task_id"], payload.get("per_vars") or {}
    if tid == CUSTOM_ID:
        text, cv = payload.get("custom_text", ""), payload.get("custom_vars") or {}
        return lambda dev, idx: catalog.render_custom(text, dev, {**cv, **lookup(per, dev)}, idx)
    values = payload.get("values") or {}
    return lambda dev, idx: catalog.render(tid, dev, {**values, **lookup(per, dev)}, idx)


class JobScheduler:
    def __init__(self, engine: Engine, db: Database, vault: Vault, catalog: TaskCatalog):
        self.engine, self.db, self.vault, self.catalog = engine, db, vault, catalog
        self.log = get_logger()
        self._stop = threading.Event()
        self._thread: Optional[threading.Thread] = None
        self._busy = threading.Lock()

    # ---- quản lý lịch ----
    def schedule(self, run_at: datetime, label: str, payload: dict) -> int:
        if run_at <= datetime.now():
            raise ValueError("Thời điểm hẹn phải ở tương lai.")
        enc = self.vault.encrypt(json.dumps(payload, ensure_ascii=False))
        jid = self.db.add_sched(run_at.strftime("%Y-%m-%d %H:%M:%S"), label, self.engine.user, enc, len(payload.get("device_ids", [])))
        self.db.audit(self.engine.user, "job_schedule", f"#{jid} {label} lúc {run_at:%Y-%m-%d %H:%M}")
        return jid

    def list(self) -> list[dict]:
        return self.db.list_sched()

    def cancel(self, jid: int) -> bool:
        row = self.db.get_sched(jid)
        if row and row["status"] == "scheduled":
            self.db.update_sched(jid, "cancelled", "Đã hủy")
            self.db.audit(self.engine.user, "job_unschedule", f"#{jid} {row['label']}")
            return True
        return False

    # ---- chạy ----
    def run_due(self, now: Optional[datetime] = None) -> list[int]:
        """Chạy các lịch đã đến giờ (đồng bộ). Trả về danh sách id đã chạy."""
        ran = []
        with self._busy:
            for row in self.db.due_sched((now or datetime.now()).strftime("%Y-%m-%d %H:%M:%S")):
                self._execute(row)
                ran.append(row["id"])
        return ran

    def _execute(self, row: dict) -> None:
        jid = row["id"]
        self.db.update_sched(jid, "running", "")
        try:
            payload = json.loads(self.vault.decrypt(row["payload_enc"]))
            devs = [d for d in (self.db.get_device(i) for i in payload["device_ids"]) if d]
            if not devs:
                raise ValueError("Các thiết bị của lịch này đã bị xóa.")
            o = payload.get("options", {})
            self.log.info("⏰ Chạy theo lịch #%s: %s (%d thiết bị)", jid, row["label"], len(devs))
            job_id, results = self.engine.run_job(
                devs, builder_from_payload(self.catalog, payload), f"[Hẹn giờ] {row['label']}", dry_run=bool(o.get("dry", False)),
                save=bool(o.get("save", True)), workers=int(o.get("workers", 5)), stop_on_error=bool(o.get("stop_on_error", True)),
                canary=int(o.get("canary", 0)), safe_minutes=int(o.get("safe_minutes", 0)), verify=bool(o.get("verify", False)))
            ok = sum(r.status in ("success", "dry_run") for r in results)
            self.db.update_sched(jid, "done", f"Tác vụ #{job_id}: {ok} thành công / {len(results) - ok} lỗi hoặc bỏ qua")
        except Exception as e:  # noqa: BLE001
            self.db.update_sched(jid, "failed", f"{type(e).__name__}: {e}")
            self.log.error("Lịch #%s lỗi: %s", jid, e)
        self.engine.emit("scheduled_done", id=jid)

    def start(self) -> None:
        if self._thread and self._thread.is_alive():
            return
        self._stop.clear()
        self._thread = threading.Thread(target=self._loop, name="job-scheduler", daemon=True)
        self._thread.start()

    def stop(self) -> None:
        self._stop.set()

    def _loop(self) -> None:
        while not self._stop.is_set():
            try:
                self.run_due()
            except Exception as e:  # noqa: BLE001
                self.log.error("Lỗi bộ hẹn giờ: %s", e)
            self._stop.wait(15)
