"""Bảo mật: mã hóa mật khẩu thiết bị bằng Fernet.

Cơ chế: một "khóa dữ liệu" (data key) ngẫu nhiên mã hóa mọi mật khẩu thiết bị.
Khóa này được bọc (wrap) riêng cho từng người dùng bằng khóa dẫn xuất từ mật khẩu
của họ (PBKDF2-HMAC-SHA256). Nhờ vậy mỗi người có mật khẩu riêng nhưng dùng chung dữ liệu.
Không có mật khẩu nào được lưu dạng rõ (plaintext).
"""
from __future__ import annotations

import base64
import os
from typing import Optional

from cryptography.fernet import Fernet, InvalidToken
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

from .database import Database

ROLES = ("admin", "operator", "viewer")
ROLE_LABELS = {"admin": "Quản trị (Admin)", "operator": "Vận hành (Operator)", "viewer": "Chỉ xem (Viewer)"}
PERMISSIONS = {
    "admin": {"view", "edit_devices", "run_tasks", "backup", "rollback", "manage_users", "settings"},
    "operator": {"view", "edit_devices", "run_tasks", "backup", "rollback"},
    "viewer": {"view"},
}
ITERATIONS = 390_000


class AuthError(Exception):
    pass


def _derive(password: str, salt: bytes) -> bytes:
    kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=ITERATIONS)
    return base64.urlsafe_b64encode(kdf.derive(password.encode("utf-8")))


class Vault:
    def __init__(self, db: Database):
        self.db = db
        self._fernet: Optional[Fernet] = None
        self._data_key: Optional[bytes] = None
        self.user: Optional[dict] = None

    # ---- trạng thái ----------------------------------------------------
    def initialized(self) -> bool:
        return self.db.count_users() > 0

    @property
    def unlocked(self) -> bool:
        return self._fernet is not None

    def can(self, permission: str) -> bool:
        return bool(self.user) and permission in PERMISSIONS.get(self.user["role"], set())

    # ---- thiết lập & đăng nhập ----------------------------------------
    def initialize(self, username: str, password: str) -> dict:
        if self.initialized():
            raise AuthError("Ứng dụng đã được khởi tạo.")
        if not username.strip():
            raise AuthError("Tên đăng nhập không được để trống.")
        self._check_password(password)
        data_key = Fernet.generate_key()
        self._store_user(username.strip(), "admin", password, data_key)
        return self.login(username, password)

    def login(self, username: str, password: str) -> dict:
        row = self.db.get_user(username.strip())
        if not row:
            raise AuthError("Sai tên đăng nhập hoặc mật khẩu.")
        try:
            data_key = Fernet(_derive(password, row["salt"])).decrypt(row["wrapped_key"])
        except InvalidToken:
            raise AuthError("Sai tên đăng nhập hoặc mật khẩu.")
        self._data_key = data_key
        self._fernet = Fernet(data_key)
        self.user = {"username": row["username"], "role": row["role"]}
        return self.user

    def logout(self) -> None:
        self._fernet = None
        self._data_key = None
        self.user = None

    # ---- quản lý người dùng -------------------------------------------
    @staticmethod
    def _check_password(password: str) -> None:
        if len(password) < 8:
            raise AuthError("Mật khẩu phải có ít nhất 8 ký tự.")

    def _store_user(self, username: str, role: str, password: str, data_key: bytes) -> None:
        salt = os.urandom(16)
        wrapped = Fernet(_derive(password, salt)).encrypt(data_key)
        self.db.add_user(username, role, salt, wrapped)

    def add_user(self, username: str, password: str, role: str) -> None:
        if not self.can("manage_users"):
            raise AuthError("Bạn không có quyền quản lý người dùng.")
        username = username.strip()
        if not username:
            raise AuthError("Tên đăng nhập không được để trống.")
        if role not in ROLES:
            raise AuthError("Vai trò không hợp lệ.")
        if self.db.get_user(username):
            raise AuthError("Tên đăng nhập đã tồn tại.")
        self._check_password(password)
        assert self._data_key is not None
        self._store_user(username, role, password, self._data_key)

    def set_password(self, username: str, new_password: str) -> None:
        if not self.user or (self.user["username"] != username and not self.can("manage_users")):
            raise AuthError("Bạn không có quyền đổi mật khẩu này.")
        self._check_password(new_password)
        assert self._data_key is not None
        salt = os.urandom(16)
        self.db.update_user_key(username, salt, Fernet(_derive(new_password, salt)).encrypt(self._data_key))

    def delete_user(self, username: str) -> None:
        if not self.can("manage_users"):
            raise AuthError("Bạn không có quyền quản lý người dùng.")
        if self.user and self.user["username"] == username:
            raise AuthError("Không thể tự xóa tài khoản đang đăng nhập.")
        self.db.delete_user(username)

    # ---- mã hóa dữ liệu ------------------------------------------------
    def encrypt(self, text: str) -> str:
        if not text:
            return ""
        if not self._fernet:
            raise AuthError("Chưa đăng nhập.")
        return self._fernet.encrypt(text.encode("utf-8")).decode("ascii")

    def decrypt(self, token: str) -> str:
        if not token:
            return ""
        if not self._fernet:
            raise AuthError("Chưa đăng nhập.")
        try:
            return self._fernet.decrypt(token.encode("ascii")).decode("utf-8")
        except InvalidToken:
            raise AuthError("Không giải mã được mật khẩu thiết bị (sai khóa dữ liệu).")
