from django.shortcuts import render
from apps.pum.models import Supplier, PuPlan, PuPlanItem, PuOrder, PuOrderItem
from apps.utils.viewsets import CustomGenericViewSet, CustomModelViewSet
from apps.pum.serializers import (SupplierSerializer, PuPlanSerializer, PuPlanItemSerializer,
                                  PuOrderSerializer, PuOrderItemSerializer, AddSerializer)
from rest_framework.exceptions import ParseError, PermissionDenied
from rest_framework.decorators import action
from rest_framework import serializers
from apps.pum.filters import PuPlanItemFilter
from django.db import transaction
from rest_framework.response import Response
from django.utils import timezone
from apps.pum.services import PumService
# Create your views here.


class SupplierViewSet(CustomModelViewSet):
    """
    list: 供应商

    供应商
    """
    queryset = Supplier.objects.all()
    serializer_class = SupplierSerializer
    search_fields = ['name', 'contact']

    def perform_destroy(self, instance):
        if PuOrder.objects.filter(supplier=instance).exists():
            raise ParseError('该供应商存在采购订单不可删除')
        instance.delete()


class PuPlanViewSet(CustomModelViewSet):
    """
    list: 采购计划

    采购计划
    """
    queryset = PuPlan.objects.all()
    serializer_class = PuPlanSerializer
    search_fields = ['name', 'number']
    filterset_fields = ['state']

    def perform_destroy(self, instance):
        if PuPlan.objects.filter(pu_plan=instance).exists():
            raise ParseError('该计划存在明细不可删除')
        return super().perform_destroy(instance)

    @action(methods=['post'], detail=True, perms_map={'post': 'pu_plan.update'}, serializer_class=serializers.Serializer)
    def submit(self, request, *args, **kwargs):
        """提交采购计划

        提交采购计划
        """
        puplan = self.get_object()
        user = request.user
        if puplan.create_by != user:
            raise PermissionDenied('非创建人不可提交')
        if puplan.state != PuPlan.PUPLAN_CREATE:
            raise ParseError('采购计划状态异常')
        puplan.submit_time = timezone.now()
        puplan.state = PuPlan.PUPLAN_SUBMITED
        puplan.save()
        return Response()


class PuPlanItemViewSet(CustomModelViewSet):
    """
    list: 采购计划明细

    采购计划明细
    """
    queryset = PuPlanItem.objects.all()
    serializer_class = PuPlanItemSerializer
    filterset_class = PuPlanItemFilter
    ordering_fields = ['create_time', 'material', 'need_date', 'need_count']
    ordering = ['create_time']

    def perform_destroy(self, instance):
        user = self.request.user
        pu_plan = instance.pu_plan
        if pu_plan.state == PuPlan.PUPLAN_CREATE and user != instance.create_by:
            raise ParseError('非创建人不可删除')
        elif instance.pu_order is not None:
            raise ParseError('存在采购订单不可删除')
        return super().perform_destroy(instance)


class PuOrderViewSet(CustomModelViewSet):
    """
    list: 采购订单

    采购订单
    """
    queryset = PuOrder.objects.all()
    serializer_class = PuOrderSerializer
    filterset_fields = ['state', 'supplier']
    search_fields = ['number', 'supplier__name']
    select_related_fields = ['create_by', 'update_by', 'supplier']

    @transaction.atomic
    def perform_destroy(self, instance):
        if instance.state != PuOrder.PUORDER_CREATE:
            raise ParseError('采购订单非创建中不可删除')
        instance.delete(soft=False)

    @action(methods=['post'], detail=True, perms_map={'post': 'pu_order.update'}, serializer_class=serializers.Serializer)
    @transaction.atomic
    def submit(self, request, *args, **kwargs):
        """提交采购订单

        提交采购订单
        """
        puorder = self.get_object()
        user = request.user
        if puorder.delivery_date is None or puorder.number is None:
            raise ParseError('订单信息不全')
        if puorder.create_by != user:
            raise PermissionDenied('非创建人不可提交')
        if puorder.state != PuOrder.PUPLAN_CREATE:
            raise ParseError('采购计划状态异常')
        puorder.submit_time = timezone.now()
        puorder.state = PuPlan.PUPLAN_SUBMITED
        puorder.save()
        PumService.change_puplan_state_when_puorder_sumbit(puorder)
        return Response()


class PuOrderItemViewSet(CustomModelViewSet):
    """
    list: 采购订单明细

    采购订单明细
    """
    queryset = PuOrderItem.objects.all()
    serializer_class = PuOrderItemSerializer
    filterset_fields = ['material', 'pu_order']
    ordering = ['create_time']

    @transaction.atomic
    def perform_destroy(self, instance):
        pu_order = instance.pu_order
        if pu_order.state != PuOrder.PUORDER_CREATE:
            raise ParseError('采购订单非创建中不可删除')
        instance.delete()

    @action(methods=['post'], detail=False, perms_map={'post': 'pu_orderitem.create'}, serializer_class=AddSerializer)
    @transaction.atomic
    def add_from_planitems(self, request, *args, **kwargs):
        """从计划明细创建/变更采购订单明细

        从计划明细创建/变更采购订单明细
        """
        data = request.data
        sr = AddSerializer(data=data)
        sr.is_valid(raise_exception=True)
        vdata = sr.validated_data
        puorder = vdata['pu_order']
        if puorder.state != PuOrder.PUORDER_CREATE:
            raise ParseError('该采购订单不可用')
        for item in vdata['pu_planitems']:
            if item.pu_plan.state == PuPlan.PUPLAN_CREATE:
                raise ParseError('存在不可选择的计划明细')
            if item.pu_order and item.pu_order.state != PuOrder.PUORDER_CREATE:
                raise ParseError('存在计划明细已指定进行中的采购订单')
            puorderitem, is_created = PuOrderItem.objects.get_or_create(
                pu_order=puorder, material=item.material,
                defaults={'pu_order': puorder,
                          'material': item.material, 'count': item.need_count}
            )
            if not is_created:
                puorderitem.count = puorderitem.count + item.need_count
                puorderitem.save()
            if puorder.delivery_date is None:
                puorder.delivery_date = item.need_date
            elif item.need_date < puorder.delivery_date:
                puorder.delivery_date = item.need_date
            puorder.save()
            item.pu_order = puorder
            item.save()
        return Response()