from .manager import manager
from .single_set_model import single_set_model

class single_set_manager(manager):
    def __init_subclass__(
        cls, 
        target_model: type, 
        related_models: str | tuple | list
    ) -> None: 
        super().__init_subclass__()

        if not issubclass(target_model, single_set_model):
            raise TypeError("Target must be subclass of single_set_model.")

        if type(related_models) is str:
            related_models = tuple([ related_models ])

        if type(related_models) is list:
            related_models = tuple(related_models)

        if type(related_models) is not tuple:
            raise TypeError("Related model must be str, list or tuple.")

        cls.__related_models = related_models
        cls.__target_model = target_model

    @classmethod
    def _get_related_models(cls) -> tuple:
        return cls.__related_models
    
    @classmethod
    def _get_model(cls) -> type:
        return cls.__target_model
    
    @classmethod
    async def add(cls, target: str) -> single_set_model:
        target_model = cls._get_model()
        
        result = await target_model \
        .filter(content = target) \
        .first()

        if result is None:
            return await cls._create(target)

        return result

    @classmethod
    async def _create(cls, content: str) -> single_set_model:
        result = cls \
        ._get_model() \
        .get_proxy() \
        .create(content) \
        .result()

        await result.save()
        return result

    @classmethod
    async def all(cls) -> tuple:
        return tuple(await cls._get_model().all())
    
    @classmethod
    async def clean(cls, target: str) -> None:  
        target_model = cls._get_model()
        related_models = cls._get_related_models()

        target = await target_model \
        .filter(content = target) \
        .first()

        await target.fetch_related(*related_models)

        for count in related_models:
            if len(target.__getattribute__(count)) > 1:
                return

        await target.delete()