from typing import Optional, Dict, Any

from core.enums import DataScopeEnum


class CurrentUser:
    """当前用户信息类"""

    _user_id: Optional[int] = None
    _username: Optional[str] = None
    _nick_name: Optional[str] = None
    _dept_id: Optional[int] = None
    _email: Optional[str] = None
    _phone: Optional[str] = None
    _data_scope: Optional[DataScopeEnum] = None
    _roles: list = None
    _role_ids: list = None
    _menus: list = None

    def __init__(
        self,
        user_id: Optional[int] = None,
        username: Optional[str] = None,
        nick_name: Optional[str] = None,
        dept_id: Optional[int] = None,
        dept_name: Optional[str] = None,
        email: Optional[str] = None,
        phone: Optional[str] = None,
        data_scope: Optional[DataScopeEnum] = None,
        roles: list = None,
        role_ids: list = None,
        menus: list = None,
        permissions: list = None,
    ):
        self._user_id = user_id
        self._username = username
        self._nick_name = nick_name
        self._dept_id = dept_id
        self._dept_name = dept_name
        self._email = email
        self._phone = phone
        self._data_scope = data_scope
        self._roles = roles
        self._role_ids = role_ids
        self._menus = menus
        self._permissions = permissions

    @property
    def user_id(self) -> Optional[int]:
        return self._user_id

    @property
    def username(self) -> Optional[str]:
        return self._username

    @property
    def nick_name(self) -> Optional[str]:
        return self._nick_name

    @property
    def dept_id(self) -> Optional[int]:
        return self._dept_id

    @property
    def dept_name(self) -> Optional[str]:
        return self._dept_name

    @property
    def email(self) -> Optional[str]:
        return self._email

    @property
    def phone(self) -> Optional[str]:
        return self._phone

    @property
    def data_scope(self) -> DataScopeEnum:
        return self._data_scope or DataScopeEnum.SELF

    @property
    def roles(self) -> list:
        return self._roles or []

    @property
    def role_ids(self) -> list:
        return self._role_ids or []

    @property
    def menus(self) -> list:
        return self._menus or []

    @property
    def permissions(self) -> list:
        return self._permissions or []

    @property
    def is_super_admin(self) -> bool:
        """检查当前用户是否为超级管理员

        从当前用户对象中检查管理员状态

        Returns:
            bool: 是否为超级管理员，如果用户不存在则返回False
        """
        return self._username == "admin" or "admin" in self.roles

    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> "CurrentUser":
        return cls(
            user_id=data.get("user_id"),
            username=data.get("username"),
            nick_name=data.get("nick_name"),
            dept_id=data.get("dept_id"),
            dept_name=data.get("dept_name"),
            email=data.get("email"),
            phone=data.get("phone"),
            data_scope=DataScopeEnum.to_enum(
                data.get("data_scope", DataScopeEnum.SELF.key)
            ),
            roles=data.get("roles", []),
            role_ids=data.get("role_ids", []),
            menus=data.get("menus", []),
            permissions=data.get("permissions", []),
        )

    def to_dict(self) -> Dict[str, Any]:
        return {
            "user_id": self.user_id,
            "username": self.username,
            "nick_name": self.nick_name,
            "dept_id": self.dept_id,
            "dept_name": self.dept_name,
            "email": self.email,
            "phone": self.phone,
            "data_scope": self.data_scope.key,
            "roles": self.roles,
            "role_ids": self.role_ids,
            "menus": self.menus,
            "permissions": self.permissions,
        }