from __future__ import annotations

from typing import Any

from backend.features.accounts.service import AccountService


class AccountApplicationMixin:
    def bind_user(self, user_id: int) -> None:
        self._request_context.user_id = int(user_id)
        encrypted = self.database.get_user_credentials(int(user_id))
        self._request_context.credentials = self.vault.decrypt_json(encrypted) if encrypted else {}
        self._request_context.access = self.database.user_access(int(user_id)) or {}

    @property
    def current_user_id(self) -> int:
        user_id = getattr(self._request_context, "user_id", 0)
        if not user_id:
            raise ValueError("当前请求尚未绑定账号。")
        return int(user_id)

    def membership(self) -> dict[str, Any]:
        return self.accounts.membership()

    def admin_users(self) -> list[dict[str, Any]]:
        return self.accounts.admin_users(self._platform_usage_today_for_user)

    def update_membership(self, payload: dict[str, Any]) -> None:
        self.accounts.update_membership(payload)

    def register_account(self, username: str, password: str, device_hash: str = "") -> dict[str, Any]:
        return self.accounts.register(username, password, device_hash)

    def login_account(self, username: str, password: str, device_hash: str = "") -> dict[str, Any]:
        return self.accounts.login(username, password, device_hash)

    def change_password(self, current_password: str, new_password: str) -> None:
        self.accounts.change_password(current_password, new_password)

    def create_account_session(self, user: dict[str, Any]) -> dict[str, Any]:
        return self.accounts.create_session(user)

    @staticmethod
    def _validate_account_input(username: str, password: str) -> None:
        AccountService.validate_input(username, password)

    def save_birth_profile(self, payload: dict[str, Any]) -> dict[str, Any]:
        return self.accounts.save_birth_profile(payload)

    def stored_birth_profile(self) -> dict[str, str] | None:
        return self.accounts.stored_birth_profile()

    def account_personal_field(
        self,
        current_date: str,
        current_field: dict[str, Any],
        public: bool = False,
    ) -> dict[str, Any] | None:
        return self.accounts.personal_field(current_date, current_field, public)

    @staticmethod
    def _public_personal_profile(personal: dict[str, Any]) -> dict[str, Any]:
        return AccountService.public_personal_profile(personal)
