from __future__ import annotations
import orjson
from redis.asyncio.client import Redis
from src.application.contracts import ICache
from src.application.domain.entities.user import UserEntity


class KeydbCache(ICache):
    USER_PREFIX = 'user:me'

    def __init__(self, redis_client: Redis):
        self._r = redis_client

    async def set(self, key: str, value: str, ttl: int) -> bool:
        return bool(await self._r.set(key, value, ex=ttl))

    async def set_nx(self, key: str, value: str, ttl: int) -> bool:
        return bool(await self._r.set(key, value, ex=ttl, nx=True))

    async def get(self, key: str) -> str | None:
        return await self._r.get(key)

    async def hget(self, key: str, field: str) -> str | None:
        return await self._r.hget(key, field)

    async def delete(self, key: str) -> bool:
        return (await self._r.delete(key)) > 0

    async def get_user(self, user_id: str) -> dict | None:
        raw = await self._r.get(f'{self.USER_PREFIX}:{user_id}')
        if raw is None:
            return None
        return orjson.loads(raw)

    async def set_user(self, user_id: str, user: UserEntity, ttl: int = 300) -> None:
        data = orjson.dumps({
            'id': user.id,
            'email': user.email,
            'first_name': user.first_name,
            'middle_name': user.middle_name,
            'last_name': user.last_name,
            'birth_date': str(user.birth_date) if user.birth_date else None,
            'encrypted_mnemonic': user.encrypted_mnemonic,
            'phone': user.phone,
            'passport_data': user.passport_data,
            'inn': user.inn,
            'erc20': user.erc20,
            'avatar_link': user.avatar_link,
            'kyc_verified': user.kyc_verified,
            'is_deleted': user.is_deleted,
            'created_at': user.created_at.isoformat() if user.created_at else None,
            'updated_at': user.updated_at.isoformat() if user.updated_at else None,
            'kyc_verified_at': user.kyc_verified_at.isoformat() if user.kyc_verified_at else None,
        })
        await self._r.set(f'{self.USER_PREFIX}:{user_id}', data, ex=ttl)