import sqlmodel

from .apikey import apikey
from .password import password

class user(sqlmodel.SQLModel, table = True):
    """
    This represents user in database. All users has own unique nick and api
    key. Nick and password is used to login, api key is long, random and
    used to access database via API.
    """

    id: int | None = sqlmodel.Field(default = None, primary_key = True)
    nick: str = sqlmodel.Field(index = True, unique=True)
    password: str = sqlmodel.Field(index = False)
    apikey: str = sqlmodel.Field(index = True, unique=True)

class user_builder:
    def __init__(self) -> None:
        """
        Create new empty user builder.
        """

        self.clean()

    def clean(self) -> None:
        """
        This clean builed. That mean, new empty user is creating.
        """

        self.__target = user(apikey = apikey())

    @property
    def ready(self) -> bool:
        """
        This check that user in builder is ready to get.

        return: bool - True when user is ready, false if not
        """

        if self.__target.nick is None:
            return False

        if self.__target.password is None:
            return False

        return True

    @property
    def nick(self) -> str | None:
        """
        return: str | None - Current nick of the user in builder
        """

        return self.__target.nick

    @property
    def password(self) -> bool:
        """
        return: bool - True when password is set, false if not
        """

        return self.__target.password is not None

    @nick.setter
    def nick(self, target: str) -> None:
        """
        target: str - New nick for the user
        """

        self.__target.nick = target

    @password.setter
    def password(self, target: str) -> None:
        """
        target: str - New password to hash and set
        """

        self.__target.password = password(target).result

    @property
    def result(self) -> user:
        """
        This return user setup in the builder.

        return: user - User from builder
        """

        if not self.ready:
            raise TypeError("User in builder is not ready yet.")

        return self.__target