from django.test import TestCase

from apps.mtm.models import Material
from apps.qm.models import Defect
from apps.wpm.filters import WMaterialFilter
from apps.wpm.models import WMaterial
from apps.wpm.serializers import WMaterialSerializer


class WMaterialDefectGradeTests(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.material = Material.objects.create(name="缺陷等级测试物料")
        cls.defect_b = Defect.objects.create(
            name="B类缺陷",
            cate=Defect.cate_list[0],
            okcate=Defect.DEFECT_OK_B,
        )
        cls.defect_notok = Defect.objects.create(
            name="不合格缺陷",
            cate=Defect.cate_list[0],
            okcate=Defect.DEFECT_NOTOK,
        )
        cls.repair_without_defect = WMaterial.objects.create(
            material=cls.material,
            batch="REPAIR-NONE",
            count=1,
            state=WMaterial.WM_REPAIR,
        )
        cls.normal_with_notok_defect = WMaterial.objects.create(
            material=cls.material,
            batch="NORMAL-NOTOK",
            count=1,
            state=WMaterial.WM_OK,
            defect=cls.defect_notok,
        )
        cls.notok_with_b_defect = WMaterial.objects.create(
            material=cls.material,
            batch="NOTOK-B",
            count=1,
            state=WMaterial.WM_NOTOK,
            defect=cls.defect_b,
        )
        cls.notok_with_legacy_sign = WMaterial.objects.create(
            material=cls.material,
            batch="NOTOK-LEGACY",
            count=1,
            state=WMaterial.WM_NOTOK,
            notok_sign="zw",
        )

    def test_serializer_uses_effective_grade_independent_of_state(self):
        repair_data = WMaterialSerializer(self.repair_without_defect).data
        notok_data = WMaterialSerializer(
            self.normal_with_notok_defect
        ).data
        b_data = WMaterialSerializer(self.notok_with_b_defect).data
        legacy_data = WMaterialSerializer(self.notok_with_legacy_sign).data

        self.assertEqual(repair_data["defect_grade"], Defect.DEFECT_OK)
        self.assertEqual(repair_data["defect_grade_name"], "合格")
        self.assertEqual(notok_data["defect_grade"], Defect.DEFECT_NOTOK)
        self.assertEqual(b_data["defect_grade"], Defect.DEFECT_OK_B)
        self.assertEqual(legacy_data["defect_grade"], Defect.DEFECT_NOTOK)

    def test_effective_grade_filter_matches_serializer_rules(self):
        ok_items = WMaterialFilter(
            {"defect_grade": Defect.DEFECT_OK},
            queryset=WMaterial.objects.all(),
        ).qs
        notok_items = WMaterialFilter(
            {"defect_grade": Defect.DEFECT_NOTOK},
            queryset=WMaterial.objects.all(),
        ).qs

        self.assertCountEqual(
            ok_items.values_list("id", flat=True),
            [self.repair_without_defect.id],
        )
        self.assertCountEqual(
            notok_items.values_list("id", flat=True),
            [
                self.normal_with_notok_defect.id,
                self.notok_with_legacy_sign.id,
            ],
        )