from .model import model
from .field_generator import field_generator
from .category import category
from .author import author
from .product_type import product_type
from .proxy import proxy
from .attachment import attachment
from .validators import validators
from .constants import constants
from .exceptions import model_must_being_saved

class item(model):
    id = field_generator.id()
    name = field_generator.name()
    description = field_generator.description()
    on_stock = field_generator.stock()
    barcode = field_generator.barcode()
    category = field_generator.connected_single(category, "item")
    author = field_generator.connected_single(author, "item")
    product_type = field_generator.connected_single(product_type, "item")
    
    cover = field_generator.connected_single(
        attachment, 
        "item", 
        "cover"
    )
    
    attachments = field_generator.connected_many(
        attachment, 
        "item", 
        "attachments"
    )

    def _validators(self) -> dict:
        return {
            "name": validators.name,
            "description": validators.description,
            "barcode": validators.barcode
        }

class item_proxy(proxy):
    @classmethod
    def create(cls, name: str, barcode: str) -> proxy:
        return cls(item(
            name = name,
            barcode = barcode,
            on_stock = constants.base_on_stock(),
            description = constants.empty_text(),
            category = None,
            author = None,
            product_type = None
        ))

    def set_cover(self, target: attachment) -> proxy:
        self._target.cover = target
        return self

    async def remove_attachment(self, target: attachment) -> proxy:
        if not self._target.is_in_database():
            raise model_must_being_saved(self._target)

        await self._target.attachments.remove(target)
        return self

    async def add_attachment(self, target: attachment) -> proxy:
        if not self._target.is_in_database():
            raise model_must_being_saved(self._target)

        await self._target.attachments.add(target)
        return self

    def set_barcode(self, target: str) -> proxy:
        self._target.barcode = target
        return self

    def set_name(self, target: str) -> proxy:   
        self._target.name = target
        return self

    def set_on_stock(self, target: int) -> proxy:   
        self._target.on_stock = target
        return self

    def set_description(self, target: str) -> proxy:
        self._target.description = target
        return self

    def set_product_type(self, target: product_type) -> proxy:   
        self._target.product_type = target
        return self

    def set_author(self, target: author) -> proxy:
        self._target.author = target
        return self

    def set_category(self, target: category) -> proxy:
        self._target.category = target
        return self