from rest_framework import status, views, serializers, pagination
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response

from basic_info import models as basic_models
from business import services as business_services
from business import models as business_models
from api_v1.views.stock_change_views.mixins import StockChangeViewMixin


class PurchaseOrderItemSerializer(serializers.ModelSerializer):
    quantity_of_rolls = serializers.SerializerMethodField(read_only=True)

    class Meta:
        model = business_models.PurchaseOrderItem
        fields = [
            'id', 'product', 'price', 'color', 'quantity', 'unit',
            'empty_diff_percent', 'quantity_of_rolls', 'num_of_rolls',
            'batch_number', 'remarks', 'created_at', 'updated_at', 'spec',
        ]
        read_only_fields = ['id', 'created_at', 'updated_at', 'total_amount', 'diff_quantity', 'real_quantity']

    def get_quantity_of_rolls(self, obj: business_models.PurchaseOrderItem):
        return obj.split_quantity_of_rolls()

class PurchaseOrderSerializer(serializers.ModelSerializer):
    total_amount = serializers.SerializerMethodField(read_only=True)
    diff_quantity = serializers.SerializerMethodField(read_only=True)
    total_quantity = serializers.SerializerMethodField(read_only=True)
    quantity_of_rolls = serializers.SerializerMethodField(read_only=True)
    human_id = serializers.CharField(read_only=True)

    def get_total_amount(self, obj: business_models.PurchaseOrder):
        return obj.get_total_amount()

    def get_diff_quantity(self, obj: business_models.PurchaseOrder):
        return obj.get_total_diff_quantity()

    def get_total_quantity(self, obj: business_models.PurchaseOrder):
        return obj.get_total_quantity()

    def get_quantity_of_rolls(self, obj: business_models.PurchaseOrder):
        return [item.split_quantity_of_rolls() for item in obj.items.all()]

    supplier_name = serializers.CharField(source='supplier.name', read_only=True)
    operator_name = serializers.CharField(source='operator.name', read_only=True)
    warehouse_name = serializers.CharField(source='warehouse.name', read_only=True)
    items = PurchaseOrderItemSerializer(many=True, read_only=True)

    class Meta:
        model = business_models.PurchaseOrder
        fields = [
            'id', 'human_id', 'supplier', 'supplier_name', 'purchase_date', 'kind',
            'total_amount', 'diff_quantity', 'total_quantity',
            'operator', 'operator_name', 'warehouse', 'warehouse_name',
            'status', 'is_red_flushed', 'red_flush_id', 'red_flushed_at',
            'balance_before_snapshot',
            'remarks', 'created_at', 'updated_at', 'items', 'quantity_of_rolls',
        ]
        read_only_fields = [
            'id', 'created_at', 'updated_at', 'items', 'supplier_name',
            'operator_name', 'warehouse_name', 'is_red_flushed',
            'red_flush_id', 'red_flushed_at',
            'balance_before_snapshot',
        ]


class PurchaseOrderPagination(pagination.LimitOffsetPagination):
    default_limit = 20
    max_limit = 100


class PurchaseOrderView(StockChangeViewMixin, views.APIView):
    """采购订单查询与创建"""

    permission_classes = [IsAuthenticated]
    pagination_class = PurchaseOrderPagination

    def get(self, request):
        if not self.check_employee_permission(request):
            return self.permission_error_response('无权限访问')

        merchant = request.user.employee.merchant
        queryset = business_models.PurchaseOrder.objects.filter(merchant=merchant).prefetch_related(
            'items', 'supplier', 'operator', 'warehouse'
        )
        paginator = self.pagination_class()
        page = paginator.paginate_queryset(queryset.order_by('-created_at'), request, view=self)
        serializer = PurchaseOrderSerializer(page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request):
        if not self.check_employee_permission(request):
            return self.permission_error_response('无权限访问')

        merchant = request.user.employee.merchant
        data = request.data or {}

        supplier_id = data.get('supplier')
        warehouse_id = data.get('warehouse_id') or data.get('warehouse')
        order_date = data.get('order_date')
        items = data.get('items', [])
        remarks = data.get('remarks', '')
        from_pre_purchase_order_id = data.get('from_pre_purchase_order_id')

        if not supplier_id:
            return Response({'error': '缺少供应商 ID'}, status=status.HTTP_400_BAD_REQUEST)
        if not warehouse_id:
            return Response({'error': '缺少仓库 ID'}, status=status.HTTP_400_BAD_REQUEST)
        if not order_date:
            return Response({'error': '缺少 order_date'}, status=status.HTTP_400_BAD_REQUEST)
        if not isinstance(items, list) or not items:
            return Response({'error': 'items 需要为非空数组'}, status=status.HTTP_400_BAD_REQUEST)

        try:
            supplier = basic_models.Supplier.objects.get(id=supplier_id, merchant=merchant)
        except basic_models.Supplier.DoesNotExist:
            return Response({'error': f'供应商 {supplier_id} 不存在'}, status=status.HTTP_400_BAD_REQUEST)

        try:
            warehouse = basic_models.WareHouse.objects.get(id=warehouse_id, merchant=merchant)
        except basic_models.WareHouse.DoesNotExist:
            return Response({'error': f'仓库 {warehouse_id} 不存在'}, status=status.HTTP_400_BAD_REQUEST)

        operator = request.user.employee

        try:
            purchase_order = business_services.create_purchase_order(
                merchant=merchant,
                supplier=supplier,
                order_date=order_date,
                warehouse=warehouse,
                operator=operator,
                items=items,
                remarks=remarks,
                from_pre_purchase_order_id=from_pre_purchase_order_id,
                created_by=request.user,
            )
        except ValueError as exc:
            return Response({'error': str(exc)}, status=status.HTTP_400_BAD_REQUEST)

        return Response(
            {
                'id': purchase_order.id,
                'human_id': purchase_order.human_id,
                'status': purchase_order.status,
                'balance_before_snapshot': purchase_order.balance_before_snapshot,
                'message': '采购单创建成功，等待审批',
            },
            status=status.HTTP_201_CREATED,
        )


class PurchaseOrderDetailView(StockChangeViewMixin, views.APIView):
    permission_classes = [IsAuthenticated]

    def _get_order(self, request, pk: int):
        if not self.check_employee_permission(request):
            return None, self.permission_error_response('无权限访问')
        merchant = request.user.employee.merchant
        try:
            order = business_models.PurchaseOrder.objects.select_related(
                'supplier', 'operator', 'warehouse'
            ).prefetch_related('items').get(id=pk, merchant=merchant)
            return order, None
        except business_models.PurchaseOrder.DoesNotExist:
            return None, self.not_found_response('采购单不存在')

    def put(self, request, pk: int):
        return self._update(request, pk)

    def patch(self, request, pk: int):
        return self._update(request, pk)

    def _update(self, request, pk: int):
        purchase_order, error_response = self._get_order(request, pk)
        if error_response:
            return error_response

        merchant = request.user.employee.merchant
        data = request.data or {}

        supplier = purchase_order.supplier
        supplier_id = data.get('supplier')
        if supplier_id:
            try:
                supplier = basic_models.Supplier.objects.get(id=supplier_id, merchant=merchant)
            except basic_models.Supplier.DoesNotExist:
                return Response({'error': f'供应商 {supplier_id} 不存在'}, status=status.HTTP_400_BAD_REQUEST)

        warehouse = purchase_order.warehouse
        warehouse_id = data.get('warehouse_id') or data.get('warehouse')
        if warehouse_id:
            try:
                warehouse = basic_models.WareHouse.objects.get(id=warehouse_id, merchant=merchant)
            except basic_models.WareHouse.DoesNotExist:
                return Response({'error': f'仓库 {warehouse_id} 不存在'}, status=status.HTTP_400_BAD_REQUEST)

        order_date = data.get('order_date') or purchase_order.purchase_date
        items = data.get('items')
        if not isinstance(items, list) or not items:
            return Response({'error': 'items 需要为非空数组'}, status=status.HTTP_400_BAD_REQUEST)
        remarks = data.get('remarks', purchase_order.remarks)
        from_pre_purchase_order_id = data.get('from_pre_purchase_order_id')

        try:
            updated_order = business_services.update_purchase_order(
                purchase_order=purchase_order,
                supplier=supplier,
                order_date=order_date,
                warehouse=warehouse,
                items=items,
                remarks=remarks,
                from_pre_purchase_order_id=from_pre_purchase_order_id,
            )
        except ValueError as exc:
            return Response({'error': str(exc)}, status=status.HTTP_400_BAD_REQUEST)

        serializer = PurchaseOrderSerializer(updated_order)
        return Response(serializer.data, status=status.HTTP_200_OK)


class PurchaseOrderReviewSerializer(serializers.Serializer):
    action = serializers.ChoiceField(choices=[('approve', '审批通过'), ('cancel', '作废')])


class PurchaseOrderReviewView(StockChangeViewMixin, views.APIView):
    """采购单审批 / 作废"""

    permission_classes = [IsAuthenticated]
    ACTION_STATUS_MAP = {
        'approve': business_models.PurchaseOrderStatusEnum.APPROVED,
        'cancel': business_models.PurchaseOrderStatusEnum.CANCELLED,
    }

    def post(self, request, pk: int):
        if not self.check_employee_permission(request):
            return self.permission_error_response('无权限访问')

        merchant = request.user.employee.merchant
        try:
            purchase_order = business_models.PurchaseOrder.objects.select_related(
                'supplier', 'operator', 'warehouse'
            ).prefetch_related('items').get(id=pk, merchant=merchant)
        except business_models.PurchaseOrder.DoesNotExist:
            return self.not_found_response('采购单不存在')

        serializer = PurchaseOrderReviewSerializer(data=request.data or {})
        serializer.is_valid(raise_exception=True)
        action = serializer.validated_data['action']
        target_status = self.ACTION_STATUS_MAP[action]

        try:
            business_services.review_purchase_order(
                purchase_order=purchase_order,
                target_status=target_status,
                reviewed_by=request.user,
            )
        except ValueError as exc:
            return Response({'error': str(exc)}, status=status.HTTP_400_BAD_REQUEST)

        refreshed_order = business_models.PurchaseOrder.objects.select_related(
            'supplier', 'operator', 'warehouse'
        ).prefetch_related('items').get(id=purchase_order.id)
        return Response(PurchaseOrderSerializer(refreshed_order).data, status=status.HTTP_200_OK)


class PurchaseOrderRedFlushSerializer(serializers.Serializer):
    reason = serializers.CharField(required=True, allow_blank=False, trim_whitespace=True)


class PurchaseOrderRedFlushView(StockChangeViewMixin, views.APIView):
    """采购单红冲"""

    permission_classes = [IsAuthenticated]

    def post(self, request, pk: int):
        if not self.check_employee_permission(request):
            return self.permission_error_response('无权限访问')

        merchant = request.user.employee.merchant
        try:
            purchase_order = business_models.PurchaseOrder.objects.select_related(
                'supplier', 'operator', 'warehouse'
            ).prefetch_related('items').get(id=pk, merchant=merchant)
        except business_models.PurchaseOrder.DoesNotExist:
            return self.not_found_response('采购单不存在')

        serializer = PurchaseOrderRedFlushSerializer(data=request.data or {})
        serializer.is_valid(raise_exception=True)

        try:
            red_flushed_order = business_services.red_flush_purchase_order(
                merchant=merchant,
                purchase_order=purchase_order,
                red_flushed_by=request.user,
                reason=serializer.validated_data['reason'],
            )
        except ValueError as exc:
            return Response({'error': str(exc)}, status=status.HTTP_400_BAD_REQUEST)

        refreshed_order = business_models.PurchaseOrder.objects.select_related(
            'supplier', 'operator', 'warehouse'
        ).prefetch_related('items').get(id=red_flushed_order.id)
        return Response(PurchaseOrderSerializer(refreshed_order).data, status=status.HTTP_200_OK)


class PurchaseOrderBindStockChangeSerializer(serializers.Serializer):
    stock_change_record_id = serializers.IntegerField(min_value=1)


class PurchaseOrderBindStockChangeView(StockChangeViewMixin, views.APIView):
    """采购单绑定库存记录"""

    permission_classes = [IsAuthenticated]

    def post(self, request, pk: int):
        if not self.check_employee_permission(request):
            return self.permission_error_response('无权限访问')

        merchant = request.user.employee.merchant
        try:
            purchase_order = business_models.PurchaseOrder.objects.select_related(
                'supplier', 'operator', 'warehouse'
            ).get(id=pk, merchant=merchant)
        except business_models.PurchaseOrder.DoesNotExist:
            return self.not_found_response('采购单不存在')

        serializer = PurchaseOrderBindStockChangeSerializer(data=request.data or {})
        serializer.is_valid(raise_exception=True)
        stock_change_record_id = serializer.validated_data['stock_change_record_id']

        try:
            record = business_services.bind_purchase_order_stock_change_record(
                purchase_order_id=purchase_order.id,
                stock_change_record_id=stock_change_record_id,
                operator=request.user,
            )
        except ValueError as exc:
            return Response({'error': str(exc)}, status=status.HTTP_400_BAD_REQUEST)

        return Response(
            {
                'purchase_order_id': purchase_order.id,
                'stock_change_record_id': record.id,
                'message': '采购单已绑定库存记录',
            },
            status=status.HTTP_200_OK,
        )
