import asyncio

from .proxy import proxy
from .apikey import apikey
from .password import password
from .field_generator import field_generator
from .model import model
from .validators import validators

class user(model):
    id = field_generator.id()
    nick = field_generator.nick()
    secret = field_generator.secret()
    apikey = field_generator.apikey()
    is_admin = field_generator.permissions()

    def _validators(self) -> dict:
        return {
            "nick": validators.nick,
            "apikey": validators.apikey
        }       

class user_proxy(proxy):
    @classmethod
    async def create(cls, nick: str, plain_password: str) -> proxy:
        secret = await password.from_plain_text(plain_password)
        key = apikey.create()

        return cls(user(
            nick = nick,
            secret = secret.result(),
            apikey = key.export(),
            is_admin = False
        ))

    def is_admin(self) -> bool:
        return self._target.is_admin

    def make_admin(self) -> None:
        self._target.is_admin = True
   
    def make_standard_user(self) -> None:
        self._target.is_admin = False

    async def set_password(self, plain_password: str) -> None:
        secret = await password.from_plain_text(plain_password)
        self._target.secret = secret.result()

    async def compare_password(self, target: str) -> bool:
        secret = await password.from_hash(self._target.secret)
        result = await secret.compare(target)

        return result

    def drop_sessions(self) -> None:
        self._target.apikey = apikey.create().export()