from apps.product.pos.api.v1.serializers import quota_distribution_serializers
from apps.product.web.api.v1.serializers import quota_serializers
from apps.product.exceptions import QuotaExpiredTimeException
from apps.core.mixins.search_mixin import DynamicSearchMixin
from apps.core.pagination import CustomPageNumberPagination
from apps.product.web.api.v1.viewsets import product_api
from common.helpers import get_organization_by_user
from rest_framework.exceptions import APIException
from apps.product import models as product_models
from rest_framework.response import Response
from rest_framework.decorators import action
from rest_framework import viewsets, filters
from common.tools import CustomOperations
from rest_framework import status
from django.db import transaction
from django.db.models import Q
from datetime import datetime


def trash(queryset, pk):  # noqa
    """ sent object to trash """
    obj = queryset.get(id=pk)
    obj.trash = True
    obj.save()


def delete(queryset, pk):
    """ full delete object """
    obj = queryset.get(id=pk)
    obj.delete()


class QuotaViewSet(viewsets.ModelViewSet, DynamicSearchMixin):  # noqa
    """ apis for product quota """

    queryset = product_models.Quota.objects.all()
    serializer_class = quota_serializers.QuotaSerializer
    filter_backends = [filters.SearchFilter]
    CustomPageNumberPagination.page_size = 5
    search_fields = [
        "registerer_organization__name",
        "quota_id",
        "product__name",
        "sale_type",
        "sale_unit__unit",
        "group",
    ]

    @action(
        methods=['get'],
        detail=False,
        url_path='active_quotas',
        url_name='active_quotas',
        name='active_quotas'
    )
    @transaction.atomic
    def active_quotas(self, request):
        """ list of organization active quotas """

        queryset = self.filter_query(self.queryset)  # return by search param or all objects

        organization = get_organization_by_user(request.user)

        # paginate queryset
        page = self.paginate_queryset(
            queryset.filter(
                Q(registerer_organization=organization),
                Q(is_closed=False)
            ).order_by('-modify_date')
        )
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

    @action(
        methods=['get'],
        detail=False,
        url_path='closed_quotas',
        url_name='closed_quotas',
        name='closed_quotas'
    )
    @transaction.atomic
    def closed_quotas(self, request):
        """ list of organization closed quotas """

        queryset = self.filter_query(self.queryset)  # return by search param or all objects

        organization = get_organization_by_user(request.user)

        # paginate queryset
        page = self.paginate_queryset(
            queryset.filter(
                Q(registerer_organization=organization),
                Q(is_closed=True)
            ).order_by('-modify_date')
        )
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

    @action(
        methods=['get'],
        detail=True,
        url_path='distributions_by_quota',
        url_name='distributions_by_quota',
        name='distributions_by_quota'
    )
    def get_distributions_by_quota(self, request, pk=None):
        """ list of distributions by quota """

        try:
            quota = self.get_object()
            queryset = self.filter_query(
                quota.distributions_assigned.all().order_by('-modify_date')
            )  # return by search param or all objects

            # paginate queryset
            page = self.paginate_queryset(
                queryset
            )
            if page is not None:
                serializer = quota_distribution_serializers.QuotaDistributionSerializer(
                    page, many=True
                )
                return self.get_paginated_response(serializer.data)
        except Exception as e:
            raise APIException("none object", code=403)

    @action(
        methods=['get'],
        detail=True,
        url_path='quotas_information',
        url_name='quotas_information',
        name='quotas_information'
    )
    @transaction.atomic
    def quotas_information_by_product(self, request, pk=None):
        """ get quotas information of a product """

        quotas = self.queryset.select_related('product').filter(
            product_id=pk, is_closed=False
        )

        try:
            quota_serializer = self.serializer_class(quotas, many=True).data
            return Response(quota_serializer, status=status.HTTP_200_OK)
        except APIException as e:
            raise APIException(detail="data error", code=400)

    @action(
        methods=['get'],
        detail=False,
        url_path='quotas_info_by_org',
        url_name='quotas_info_by_org',
        name='quotas_info_by_org'
    )
    def quotas_information_by_organization(self, request):
        """ get quotas information of an organization """

        quotas = self.queryset.filter(
            Q(assigned_organizations=get_organization_by_user(request.user)) |
            Q(registerer_organization=get_organization_by_user(request.user))
        )

        serializer = self.serializer_class(quotas, many=True).data
        return Response(serializer, status=status.HTTP_200_OK)

    @action(
        methods=['put'],
        detail=True,
        url_path='trash',
        url_name='trash',
        name='trash',
    )
    @transaction.atomic
    def trash(self, request, pk=None):
        """ Sent quota to trash """
        try:
            trash(self.queryset, pk)
        except APIException as e:
            return Response(e, status.HTTP_204_NO_CONTENT)

    @action(
        methods=['post'],
        detail=True,
        url_name='delete',
        url_path='delete',
        name='delete'
    )
    @transaction.atomic
    def delete(self, request, pk=None):
        """ Full delete of quota object """
        try:
            delete(self.queryset, pk)
            return Response(status=status.HTTP_200_OK)
        except APIException as e:
            return Response(e, status=status.HTTP_204_NO_CONTENT)


class QuotaIncentiveAssignmentViewSet(viewsets.ModelViewSet):  # noqa
    """ apis for incentive assignment """

    queryset = product_models.QuotaIncentiveAssignment.objects.all()
    serializer_class = quota_serializers.QuotaIncentiveAssignmentSerializer

    @action(
        methods=['put'],
        detail=True,
        url_path='trash',
        url_name='trash',
        name='trash',
    )
    @transaction.atomic
    def trash(self, request, pk=None):
        """ Sent quota incentive assignment to trash """
        try:
            trash(self.queryset, pk)
        except APIException as e:
            return Response(e, status.HTTP_204_NO_CONTENT)

    @action(
        methods=['post'],
        detail=True,
        url_name='delete',
        url_path='delete',
        name='delete'
    )
    @transaction.atomic
    def delete(self, request, pk=None):
        """ Full delete of quota incentive assignment object """
        try:
            delete(self.queryset, pk)
            return Response(status=status.HTTP_200_OK)
        except APIException as e:
            return Response(e, status=status.HTTP_204_NO_CONTENT)


class QuotaBrokerValueViewSet(viewsets.ModelViewSet):  # noqa
    """ apis for quota broker value """

    queryset = product_models.QuotaBrokerValue.objects.all()
    serializer_class = quota_serializers.QuotaBrokerValueSerializer

    @action(
        methods=['put'],
        detail=True,
        url_path='trash',
        url_name='trash',
        name='trash',
    )
    @transaction.atomic
    def trash(self, request, pk=None):
        """ Sent quota broker value to trash """
        try:
            trash(self.queryset, pk)
        except APIException as e:
            return Response(e, status.HTTP_204_NO_CONTENT)

    @action(
        methods=['post'],
        detail=True,
        url_name='delete',
        url_path='delete',
        name='delete'
    )
    @transaction.atomic
    def delete(self, request, pk=None):
        """ Full delete of quota broker value object """
        try:
            delete(self.queryset, pk)
            return Response(status=status.HTTP_200_OK)
        except APIException as e:
            return Response(e, status=status.HTTP_204_NO_CONTENT)


class QuotaLiveStockAllocationViewSet(viewsets.ModelViewSet):
    """ apis for quota livestock allocation """

    queryset = product_models.QuotaLivestockAllocation.objects.all()
    serializer_class = quota_serializers.QuotaLiveStockAllocationSerializer

    @action(
        methods=['put'],
        detail=True,
        url_path='trash',
        url_name='trash',
        name='trash',
    )
    @transaction.atomic
    def trash(self, request, pk=None):
        """ Sent quota livestock allocation to trash """
        try:
            trash(self.queryset, pk)
        except APIException as e:
            return Response(e, status.HTTP_204_NO_CONTENT)

    @action(
        methods=['post'],
        detail=True,
        url_name='delete',
        url_path='delete',
        name='delete'
    )
    @transaction.atomic
    def delete(self, request, pk=None):
        """ Full delete of quota livestock allocation object """
        try:
            delete(self.queryset, pk)
            return Response(status=status.HTTP_200_OK)
        except APIException as e:
            return Response(e, status=status.HTTP_204_NO_CONTENT)


class QuotaLiveStockAgeLimitation(viewsets.ModelViewSet):
    queryset = product_models.QuotaLiveStockAgeLimitation.objects.all()  # noqa
    serializer_class = quota_serializers.QuotaLiveStockAgeLimitationSerializer

    @action(
        methods=['put'],
        detail=True,
        url_path='trash',
        url_name='trash',
        name='trash',
    )
    @transaction.atomic
    def trash(self, request, pk=None):
        """ Sent quota livestock age limitation to trash """
        try:
            trash(self.queryset, pk)
        except APIException as e:
            return Response(e, status.HTTP_204_NO_CONTENT)

    @action(
        methods=['post'],
        detail=True,
        url_name='delete',
        url_path='delete',
        name='delete'
    )
    @transaction.atomic
    def delete(self, request, pk=None):
        """ Full delete of quota livestock age limitation object """
        try:
            delete(self.queryset, pk)
            return Response(status=status.HTTP_200_OK)
        except APIException as e:
            return Response(e, status=status.HTTP_204_NO_CONTENT)
