from apps.utils.constants import EXCLUDE_FIELDS
from apps.utils.serializers import CustomModelSerializer
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

from .models import SfLog, StLog, SfLogExp, WMaterial, Mlog, Handover, Mlogb
from apps.system.models import Dept, User
from apps.pm.models import Mtask
from apps.wpm.tasks import cal_enstat_when_pcoal_heat_change, cal_enstat_when_team_change
from apps.mtm.serializers import MaterialSimpleSerializer
from django.db import transaction


class StLogSerializer(CustomModelSerializer):
    mgroup_name = serializers.CharField(source='mgroup.name', read_only=True)

    class Meta:
        model = StLog
        fields = '__all__'


class SfLogSerializer(CustomModelSerializer):
    mgroup_name = serializers.CharField(source='mgroup.name', read_only=True)
    team_name = serializers.CharField(source='team.name', read_only=True)
    shift_name = serializers.CharField(source='shift.name', read_only=True)
    leader_name = serializers.CharField(source='leader.name', read_only=True)

    class Meta:
        model = SfLog
        fields = '__all__'
        read_only_fields = EXCLUDE_FIELDS + \
            ['mgroup', 'start_time', 'end_time', 'belong_dept']
        extra_kwargs = {
            'team': {'required': True},
            'leader': {'required': True}
        }

    def update(self, instance, validated_data):
        old_pcoal_heat = instance.pcoal_heat
        old_team = instance.team
        instance = super().update(instance, validated_data)
        new_pcoal_heat = instance.pcoal_heat
        new_team = instance.team
        if new_pcoal_heat != old_pcoal_heat:
            cal_enstat_when_pcoal_heat_change.delay(instance.id)
        if new_team != old_team:
            cal_enstat_when_team_change.delay(instance.id)
        return instance
    # def to_internal_value(self, data):
    #     if hasattr(self.Meta, 'update_fields') and self.context['request'].method in ['PUT', 'PATCH']:
    #         u_fields = self.Meta.update_fields
    #         new_data = {key: data[key] for key in u_fields if key in data}
    #         return super().to_internal_value(new_data)
    #     return super().to_internal_value(data)


class SflogExpSerializer(CustomModelSerializer):
    mgroup = serializers.CharField(source='sflog.mgroup.id', read_only=True)
    mgroup_name = serializers.CharField(
        source='sflog.mgroup.name', read_only=True)
    stlog_ = StLogSerializer(source='stlog', read_only=True)
    happen_time = serializers.DateTimeField(required=True, label='发生时间')
    cate = serializers.CharField(required=True, label='原因类别')

    class Meta:
        model = SfLogExp
        fields = '__all__'
        read_only_fields = EXCLUDE_FIELDS + ['stlog', 'is_current_down']


class WMaterialSerializer(CustomModelSerializer):
    material_ = MaterialSimpleSerializer(source='material', read_only=True)
    belong_dept_name = serializers.CharField(
        source='belong_dept.name', read_only=True)

    class Meta:
        model = WMaterial
        fields = '__all__'


class MlogbSerializer(CustomModelSerializer):
    material_out_ = MaterialSimpleSerializer(
        source='material_out', read_only=True)

    class Meta:
        model = Mlogb
        fields = ['id', 'material_out', 'count_ok', 'material_out_']


class MlogSerializer(CustomModelSerializer):
    mgroup_name = serializers.CharField(
        source='mtask.mgroup.name', read_only=True)
    mtask_count = serializers.IntegerField(
        source='mtask.count', read_only=True)
    create_by_name = serializers.CharField(
        source='create_by.name', read_only=True)
    update_by_name = serializers.CharField(
        source='update_by.name', read_only=True)
    handovers = serializers.PrimaryKeyRelatedField(
        source='handover_mlog', read_only=True, many=True)
    material_out_ = MaterialSimpleSerializer(
        source='material_out', read_only=True)
    handle_user_name = serializers.CharField(
        source='handle_user.name', read_only=True)
    handle_user_2_name = serializers.CharField(
        source='handle_user_2.name', read_only=True)
    handle_leader_name = serializers.CharField(
        source='handle_leader.name', read_only=True)
    equipment_name = serializers.CharField(
        source='equipment.name', read_only=True)
    equipment_2_name = serializers.CharField(
        source='equipment_2.name', read_only=True)
    shift_name = serializers.CharField(source='shift.name', read_only=True)
    material_outs = MlogbSerializer(
        label='多产出件信息', many=True, source='material_outs')

    class Meta:
        model = Mlog
        fields = '__all__'
        read_only_fields = EXCLUDE_FIELDS + ['submit_time', 'submit_user']

    def create(self, validated_data):
        mtask = validated_data.get('mtask', None)
        batch = validated_data['batch']
        handle_date = validated_data['handle_date']
        handle_user = validated_data['handle_user']
        if mtask:
            validated_data['mgroup'] = mtask.mgroup
            validated_data['material_out'] = mtask.material_out
            # if  not WMaterial.objects.filter(batch=batch).exists():
            #     raise ValidationError('批次号不存在')
        else:
            mgroup = validated_data['mgroup']
            material_out = validated_data['material_out']
            if not (mgroup and material_out):
                raise ValidationError('缺少工段或产物!')
        if Mlog.objects.filter(mtask=mtask, batch=batch, handle_date=handle_date, handle_user=handle_user).exists():
            raise ValidationError('存在相同的日志记录')
        with transaction.atomic():
            material_outs = validated_data.pop('material_outs', [])
            instance = super().create(validated_data)
            brotherId_should_list = material_out.brothers
            if brotherId_should_list:
                if material_outs:
                    for item in material_outs:
                        if item['material_out'].id in brotherId_should_list:
                            Mlogb.objects.create(
                                mlog=instance, material_out=item['material_out'], count_ok=item['count_ok'])
                else:
                    raise ValidationError('缺少产出物信息')
        return instance

    def update(self, instance, validated_data):
        validated_data.pop('mtask', None)
        validated_data.pop('batch', None)
        validated_data.pop('handle_date', None)
        validated_data.pop('handle_user', None)
        validated_data.pop('mgroup', None)
        with transaction.atomic():
            material_outs = validated_data.pop('material_outs', [])
            instance = super().update(instance, validated_data)
            brotherId_should_list = instance.material_out.brothers
            if brotherId_should_list:
                if material_outs:
                    for item in material_outs:
                        id = item.get('id', None)
                        if id:
                            mlogb = Mlogb.objects.get(id=id)
                            mlogb.count_ok = item['count_ok']
                            mlogb.save()
                        elif item['material_out'].id in brotherId_should_list:
                            Mlogb.objects.create(
                                mlog=instance, material_out=item['material_out'], count_ok=item['count_ok'])
                else:
                    raise ValidationError('缺少产出物信息')
        return instance

    def validate(self, attrs):
        mtask = attrs.get('mtask', None)
        if mtask:
            handle_date = attrs['handle_date']
            if handle_date >= mtask.start_date and handle_date <= mtask.end_date:
                pass
            else:
                raise ValidationError('操作日期错误')
            if mtask.state != Mtask.MTASK_ASSGINED:
                raise ValidationError(f'{mtask.mgroup.name}_不可提交日志!')
        return attrs


class MlogRelatedSerializer(serializers.Serializer):
    mtask = serializers.PrimaryKeyRelatedField(
        label='小任务ID', queryset=Mtask.objects.all())


class DeptBatchSerializer(serializers.Serializer):
    belong_dept_name = serializers.CharField(label='车间名称')


class HandoverSerializer(CustomModelSerializer):
    send_user_name = serializers.CharField(
        source='send_user.name', read_only=True)
    recive_user_name = serializers.CharField(
        source='send_user.name', read_only=True)
    material_ = MaterialSimpleSerializer(source='material', read_only=True)

    class Meta:
        model = Handover
        fields = '__all__'
        read_only_fields = EXCLUDE_FIELDS


class GenHandoverSerializer(serializers.Serializer):
    mlogs = serializers.PrimaryKeyRelatedField(
        label='mlog的ID列表', queryset=Mlog.objects.all(), many=True)
    recive_dept = serializers.PrimaryKeyRelatedField(
        label='交送车间', queryset=Dept.objects.all())
    recive_user = serializers.PrimaryKeyRelatedField(
        label='交送人', queryset=User.objects.all())
    send_user = serializers.PrimaryKeyRelatedField(
        label='交送人', queryset=User.objects.all())
    send_date = serializers.DateField(label='交送日期')