from pickle import TRUE
from typing import Optional

from django.db import models
from django.utils import timezone
from django.forms import ModelForm


from .user import User
from crm.models import Project
from crm.models import get_base_record_for_project
from misc.generic_models.meta_mixin import MetaMixin
from misc.views.clean_form_errors import clean_form_errors
from misc.generic_models.generic_model import GenericModel
from users.models.user_access import UserAccess
from users.models.user_property import Property


class SubmissionRequestManager(models.Manager):
    """Переопределение менеджера"""

    @staticmethod
    def submission_request_create_or_update(
            data: dict, instance: Optional['SubmissionRequest'] = None, user: Optional['User'] = None
    ) -> dict:
        """Выполняет создание или изменение экземпляра ConnectingUserToAccess."""

        connecting_user_to_access_form = SubmissionRequest(data=data, instance=instance)

        is_valid = connecting_user_to_access_form.is_valid()

        if is_valid:
            instance = connecting_user_to_access_form.save()

        return {
            'is_ok': is_valid,
            'errors': clean_form_errors(connecting_user_to_access_form.errors),
            'obj': instance
        }

    @staticmethod
    def response_to_request(obj: 'SubmissionRequest', user: 'User') -> dict:
        """Выполняет перевод в архив экземпляра SubmissionRequest."""

        errors = {}
        is_ok = True
        if not obj:
            errors = {'obj': SubmissionRequest.ErrorHandler.FAIL_TO_FIND_OBJ}
            is_ok = False

        # :TODO Поменять на метод ответа

        return {'is_ok': is_ok, 'errors': errors, 'obj': obj}

    @staticmethod
    def submission_request_delete(obj: 'SubmissionRequest', user: Optional['User'] = None) -> dict:
        if not obj:
            error = SubmissionRequest.ErrorHandler.FAIL_TO_FIND_OBJ
            return {'is_ok': False, 'error': error, 'obj': None}
        else:
            obj.delete()
            return {'is_ok': True, 'error': '', 'obj': obj}


class SubmissionRequest(GenericModel):

    class ErrorHandler:
        """Статусы ошибок"""

        FAIL_TO_FIND_OBJ = 'Объект не найден.'

    class Status(models.TextChoices):
        """Статус набора данных."""

        REQUEST_COMPLETED = 'request_completed', 'Запрос выполнен'
        IN_PROCESS = 'in_process', 'В процессе'
        DENIED = 'denied', 'Отказано'

    meta_tags = [MetaMixin.ModelTags.UserData]

    _id_meta = [MetaMixin.FieldTags.PKField, MetaMixin.FieldTags.NotForLog]# Мета данные поля id

    user = models.ForeignKey(
        User,
        verbose_name='Сотрудник',
        related_name='submission_request_user',
        on_delete=models.CASCADE,
        null=False,
        blank=False,
    )
    _user_meta = [MetaMixin.FieldTags.UserField]

    comment_user = models.TextField(verbose_name='Комментарий запрашиваемого запрос', null=True, blank=True)
    comment = models.TextField(verbose_name='Комментарий руководителя', null=True, blank=True)
    status = models.CharField('Статус заявки', max_length=18, choices=Status.choices, default=Status.IN_PROCESS)

    supervisor = models.ForeignKey(
        User,
        verbose_name='Ответственный',
        related_name='submission_request_supervisor',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
    )

    access = models.ForeignKey(
        UserAccess,
        verbose_name='Назначение доступа сотруднику',
        related_name='submission_request_access',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
    )

    property = models.ForeignKey(
        Property,
        verbose_name='Имущество выданное сотруднику',
        related_name='submission_request_property',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
    )

    project = models.ForeignKey(
        Project, verbose_name='проект',
        on_delete=models.PROTECT,
        default=get_base_record_for_project,
        blank=True,
    )
    _project_meta = [MetaMixin.FieldTags.ProjectField]

    request_period_from = models.DateTimeField('Период заявки от', null=True, blank=True)
    request_period_to = models.DateTimeField('Период заявки до', null=True, blank=True)
    request_processed = models.BooleanField(verbose_name='Заявка обработана и подтверждена', default=False)

    objects = SubmissionRequestManager()

    def save(self, *args, **kwargs):
        """Переопределение метода сохранение, для обработка заявки после статуса заявке"""
        print('asdasdasdasdasdasdasd')
        if self.request_period_from and self.request_period_to:
            self.request_processed = True
            self.status = SubmissionRequest.Status.REQUEST_COMPLETED
            print(self.request_period_from, self.request_period_to)

        super().save(*args, **kwargs)

    def get_name_request(self):
        """Получение название ресурса"""

        return self.resource_definition().name

    def get_comment_resource(self):
        """Получение комментария ресурса"""

        return self.resource_definition().comment

    def get_resource(self):
        """Возвращает содержимое ресурса"""
        if self.access:
            return self.access.url

        if self.property:
            return f'{self.property.declared_value}/{self.property.serial_number}'

    def resource_definition(self):
        """Определение ресурса"""

        if self.access:
            return self.access

        if self.property:
            return self.property

        return None

    def __str__(self):
        return str(self.user)

    __repr__ = __str__

    class Meta:
        verbose_name = 'Запрос на подпись (Имущество и доступы)'
        verbose_name_plural = 'Запрос на подпись (Имущество и доступы)'
        ordering = ['-id']


class SubmissionRequestForm(ModelForm):

    class Meta:
        model = SubmissionRequest
        fields = '__all__'