from rest_framework import serializers
from .models import *
from basic.serializers import SymptomTypeSerializer,CalculationMethodSerializer,BMICaseWeightGain,CheckUpStatus,BMICaseLanguage
from mama_care_api.settings import languageKey
from mama_care_api.settings import MEDIA_ROOT
from common.common import isValidData,validateParentId,getImageName,uploadImage,getLanguage
from django.db.models import *
# Tools

# Bumpie


class BumpieSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = Bumpie
        fields = [
            "id",
            "weekNumber",
            "image",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def create(self, validated_data):
        validated_data["image"] = uploadImage(
            self, getImageName(validated_data["weekNumber"])
        )
        return super().create(validated_data)

    def update(self, instance, validated_data):
        if os.path.exists(MEDIA_ROOT + "/" + str(instance.image)):
            os.remove(MEDIA_ROOT + "/" + str(instance.image))

        instance.image = uploadImage(self, getImageName(validated_data["weekNumber"]))
        instance.save()
        return instance


# Symptom Group


class SymptomGroupSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()
    symptomRowList = serializers.SerializerMethodField()

    class Meta:
        model = SymptomGroup
        fields = [
            "id",
            "date",
            "note",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "symptomRowList",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        print(data)
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def get_symptomRowList(self, instance):
        languageId = getLanguage(self)
        dataList = SymptomRow.objects.filter(symptomGroupId=instance.id)
        return SymptomRowSerializer(
            dataList, many=True, context={languageKey: languageId}
        ).data


# Symptom Row


class SymptomRowSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()
    symptomType = serializers.SerializerMethodField()

    class Meta:
        model = SymptomRow
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "symptomTypeId",
            "symptomGroupId",
            "symptomType",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.symptomGroupId.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "symptomGroupId" in data:
            isCheck = validateParentId(
                self, data["symptomGroupId"].medicalProfileId.childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def get_symptomType(self, instance):
        languageId = getLanguage(self)
        val = SymptomType.objects.filter(id=instance.symptomTypeId.id).exists()
        if val:
            selected = SymptomType.objects.get(id=instance.symptomTypeId.id)
            return SymptomTypeSerializer(
                selected, context={languageKey: languageId}
            ).data
        return None


# Kick Tracker Group


class KickTrackerGroupSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()
    kickTrackerRowSummary = serializers.SerializerMethodField()

    class Meta:
        model = KickTrackerGroup
        fields = [
            "id",
            "date",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "kickTrackerRowSummary",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def get_kickTrackerRowSummary(self, instance):
        count = KickTrackerRow.objects.filter(kickTrackerGroupId=instance.id).count()
        if count > 0:
            kickCounts = KickTrackerRow.objects.filter(
                kickTrackerGroupId=instance.id
            ).aggregate(totalKicks=Sum("kicks"), totalSeconds=Sum("seconds"))
            if kickCounts is not None:
                hours, remainder = divmod(kickCounts["totalSeconds"], 3600)
                minutes, seconds = divmod(remainder, 60)
                return {
                    "totalKicks": kickCounts["totalKicks"],
                    "hours": hours,
                    "minutes": minutes,
                    "seconds": seconds,
                }
        return None


# Kick Tracker Row


class KickTrackerRowSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = KickTrackerRow
        fields = [
            "id",
            "date",
            "seconds",
            "kicks",
            "createdDate",
            "updatedDate",
            "kickTrackerGroupId",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.kickTrackerGroupId.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "kickTrackerGroupId" in data:
            isCheck = validateParentId(
                self, data["kickTrackerGroupId"].medicalProfileId.childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})


# Ovulation


class OvulationSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = Ovulation
        fields = [
            "id",
            "lastMenstrualPeriod",
            "cycleLength",
            "nextPeriod",
            "ovulationDay",
            "fertileStart",
            "fertileEnd",
            "expectedDueDate",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})


# Memory


class MemorySerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = Memory
        fields = [
            "id",
            "medicalProfileId",
            "image",
            "caption",
            "createdDate",
            "updatedDate",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def create(self, validated_data):
        validated_data["image"] = uploadImage(self, getImageName(""))
        return super().create(validated_data)

    def update(self, instance, validated_data):
        if os.path.exists(MEDIA_ROOT + "/" + str(instance.image)):
            os.remove(MEDIA_ROOT + "/" + str(instance.image))

        instance.image = uploadImage(self, getImageName(""))
        instance.save()
        return instance


# Due Date Calculator


class DueDateCalculatorSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()
    calculationMethod = serializers.SerializerMethodField()

    class Meta:
        model = DueDateCalculator
        fields = [
            "id",
            "lastMenstrualPeriod",
            "cycleLength",
            "conceiveDate",
            "dateOfTransfer",
            "numOfDays",
            "ultrasoundDate",
            "weeks",
            "days",
            "expectedDueDate",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "calculationMethodId",
            "calculationMethod",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def get_calculationMethod(self, instance):
        languageId = getLanguage(self)
        val = CalculationMethod.objects.filter(
            id=instance.calculationMethodId.id
        ).exists()
        if val:
            selected = CalculationMethod.objects.get(id=instance.calculationMethodId.id)
            return CalculationMethodSerializer(
                selected, context={languageKey: languageId}
            ).data

        return None


# Weight Gain


class WeightGainSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()
    bmi = serializers.SerializerMethodField()
    bmiCategory = serializers.SerializerMethodField()
    gain = serializers.SerializerMethodField()
    recommendedMin = serializers.SerializerMethodField()
    recommendedMax = serializers.SerializerMethodField()
    statusId = serializers.SerializerMethodField()
    status = serializers.SerializerMethodField()

    class Meta:
        model = WeightGain
        fields = [
            "id",
            "height",
            "prePregnancyWeight",
            "currentWeight",
            "currentWeek",
            "createdDate",
            "updatedDate",
            "bmiCaseId",
            "medicalProfileId",
            "bmi",
            "bmiCategory",
            "gain",
            "recommendedMin",
            "recommendedMax",
            "statusId",
            "status",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def get_bmi(self, instance):
        return round(instance.prePregnancyWeight / pow((instance.height / 100), 2), 2)

    def get_bmiCategory(self, instance):
        languageId = getLanguage(self)
        langList = BMICaseLanguage.objects.filter(bmiCaseId=instance.bmiCaseId).filter(
            languageId=languageId
        )
        if langList.__len__() > 0:
            return langList[0].name
        return ""

    def getGain(self, instance):
        return instance.currentWeight - instance.prePregnancyWeight

    def get_gain(self, instance):
        return self.getGain(instance)

    def getTotalMinMax(self, instance):
        minVal = 0
        maxVal = 0
        bmiCaseWeightGainList = BMICaseWeightGain.objects.filter(
            bmiCaseId=instance.bmiCaseId
        )
        if bmiCaseWeightGainList.__len__() > 0:
            minVal = bmiCaseWeightGainList[0].min
            maxVal = bmiCaseWeightGainList[0].max
        result = max(0, min(instance.currentWeek, 40)) / 40.0

        totalMin = minVal * result
        totalMax = maxVal * result

        return totalMin, totalMax

    def get_recommendedMin(self, instance):
        recoMin, recoMax = self.getTotalMinMax(instance)
        return round(recoMin, 2)

    def get_recommendedMax(self, instance):
        recoMin, recoMax = self.getTotalMinMax(instance)
        return round(recoMax, 2)

    def getStatus(self, instance):
        totalMin, totalMax = self.getTotalMinMax(instance)
        statusId = -1
        status = ""
        gain = self.getGain(instance)
        if gain < totalMin - 0.1:
            statusId = 1
            status = "Below"
        elif gain > totalMax + 0.1:
            statusId = 3
            status = "Above"
        else:
            statusId = 2
            status = "Within"
        return statusId, status

    def get_statusId(self, instance):
        statusId, status = self.getStatus(instance)
        return statusId

    def get_status(self, instance):
        statusId, status = self.getStatus(instance)
        return status


# Pregnancy Care Category


class PregnancyCareCategorySerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()
    itemList = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyCareCategory
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "title",
            "itemList",
        ]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyCareCategoryLanguageList = (
                PregnancyCareCategoryLanguage.objects.filter(
                    pregnancyCareCategoryId=str(instance.id)
                ).filter(languageId=languageId)
            )
            if pregnancyCareCategoryLanguageList.__len__() > 0:
                return pregnancyCareCategoryLanguageList[0].title

    def get_itemList(self, instance):
        languageId = getLanguage(self)
        dataList = PregnancyCareItem.objects.filter(pregnancyCareCategoryId=instance.id)
        return PregnancyCareItemSerializer(
            dataList, context={languageKey: languageId}, many=True
        ).data


class PregnancyCareCategoryLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyCareCategoryLanguage
        fields = [
            "id",
            "title",
            "createdDate",
            "updatedDate",
            "pregnancyCareCategoryId",
            languageKey,
        ]


# Pregnancy Care Category


class PregnancyCareItemSerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyCareItem
        fields = [
            "id",
            "isDo",
            "createdDate",
            "updatedDate",
            "pregnancyCareCategoryId",
            "title",
        ]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyCareItemLanguageList = PregnancyCareItemLanguage.objects.filter(
                pregnancyCareItemId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancyCareItemLanguageList.__len__() > 0:
                return pregnancyCareItemLanguageList[0].title


class PregnancyCareItemLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyCareItemLanguage
        fields = [
            "id",
            "title",
            "createdDate",
            "updatedDate",
            "pregnancyCareItemId",
            languageKey,
        ]


# Check Up


class CheckUpSerializer(serializers.ModelSerializer):
    bloodPressureTopStatus = serializers.SerializerMethodField()
    bloodPressureBottomStatus = serializers.SerializerMethodField()
    heartRateStatus = serializers.SerializerMethodField()
    bloodSugarFastingStatus = serializers.SerializerMethodField()
    bloodSugarAfterMeal1HourStatus = serializers.SerializerMethodField()
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = CheckUp
        fields = [
            "id",
            "bloodPressureTop",
            "bloodPressureBottom",
            "heartRate",
            "bloodSugarFasting",
            "bloodSugarAfterMeal1Hour",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "bloodPressureTopStatus",
            "bloodPressureBottomStatus",
            "heartRateStatus",
            "bloodSugarFastingStatus",
            "bloodSugarAfterMeal1HourStatus",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def get_bloodPressureTopStatus(self, instance):
        systolicLevel = None
        systolicList = CheckUpStatus.objects.filter(
            minSystolic__lte=instance.bloodPressureTop,
            maxSystolic__gte=instance.bloodPressureTop,
            flag="blood_pressure",
        )
        if systolicList.__len__() > 0:
            systolicLevel = systolicList[0].level
        return systolicLevel

    def get_bloodPressureBottomStatus(self, instance):
        systolicLevel = None
        diastolicLevel = None
        currentLevel = None

        systolicList = CheckUpStatus.objects.filter(
            minSystolic__lte=instance.bloodPressureTop,
            maxSystolic__gte=instance.bloodPressureTop,
        )
        diastolicList = CheckUpStatus.objects.filter(
            minDiastolic__lte=instance.bloodPressureBottom,
            maxDiastolic__gte=instance.bloodPressureBottom,
        )

        if systolicList.__len__() > 0:
            systolicLevel = systolicList[0].level

        if diastolicList.__len__() > 0:
            diastolicLevel = diastolicList[0].level

        if systolicLevel != diastolicLevel:
            currentLevel = systolicLevel
        else:
            currentLevel = diastolicLevel

        return currentLevel

    def get_heartRateStatus(self, instance):
        heartRateLevel = None
        heartRateList = CheckUpStatus.objects.filter(
            minBPM__lte=instance.heartRate,
            maxBPM__gte=instance.heartRate,
            flag="heart_rate",
        )
        if heartRateList.__len__() > 0:
            heartRateLevel = heartRateList[0].level
        return heartRateLevel

    def get_bloodSugarFastingStatus(self, instance):
        bloodSugarFastingStatusLevel = None
        bloodSugarFastingStatusList = CheckUpStatus.objects.filter(
            minMGDL__lte=instance.bloodSugarFasting,
            maxMGDL__gte=instance.bloodSugarFasting,
            flag="blood_sugar",
            bloodSugarType="fasting",
        )
        if bloodSugarFastingStatusList.__len__() > 0:
            bloodSugarFastingStatusLevel = bloodSugarFastingStatusList[0].level
        return bloodSugarFastingStatusLevel

    def get_bloodSugarAfterMeal1HourStatus(self, instance):
        bloodSugarAfterMeal1HourStatusLevel = None
        bloodSugarAfterMeal1HourStatusList = CheckUpStatus.objects.filter(
            minMGDL__lte=instance.bloodSugarAfterMeal1Hour,
            maxMGDL__gte=instance.bloodSugarAfterMeal1Hour,
            flag="blood_sugar",
            bloodSugarType="after_meal_1h",
        )
        if bloodSugarAfterMeal1HourStatusList.__len__() > 0:
            bloodSugarAfterMeal1HourStatusLevel = bloodSugarAfterMeal1HourStatusList[
                0
            ].level
        return bloodSugarAfterMeal1HourStatusLevel


# Pregnancy Shopping Category


class PregnancyShoppingCategorySerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()
    itemList = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyShoppingCategory
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "title",
            "itemList",
        ]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyShoppingCategoryLanguageList = (
                PregnancyShoppingCategoryLanguage.objects.filter(
                    pregnancyShoppingCategoryId=str(instance.id)
                ).filter(languageId=languageId)
            )
            if pregnancyShoppingCategoryLanguageList.__len__() > 0:
                return pregnancyShoppingCategoryLanguageList[0].title

    def get_itemList(self, instance):
        languageId = getLanguage(self)
        dataList = PregnancyShoppingItem.objects.filter(
            pregnancyShoppingCategoryId=instance.id
        )
        return PregnancyShoppingItemSerializer(
            dataList, context={languageKey: languageId}, many=True
        ).data


class PregnancyShoppingCategoryLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyShoppingCategoryLanguage
        fields = [
            "id",
            "title",
            "createdDate",
            "updatedDate",
            "pregnancyShoppingCategoryId",
            languageKey,
        ]


# Pregnancy Shopping Item


class PregnancyShoppingItemSerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyShoppingItem
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "pregnancyShoppingCategoryId",
            "title",
        ]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            PregnancyShoppingItemLanguageList = (
                PregnancyShoppingItemLanguage.objects.filter(
                    pregnancyShoppingItemId=str(instance.id)
                ).filter(languageId=languageId)
            )
            if PregnancyShoppingItemLanguageList.__len__() > 0:
                return PregnancyShoppingItemLanguageList[0].title


class PregnancyShoppingItemLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyShoppingItemLanguage
        fields = [
            "id",
            "title",
            "createdDate",
            "updatedDate",
            "pregnancyShoppingItemId",
            languageKey,
        ]


# Pregnancy Shopping Check Item


class PregnancyShoppingCheckItemSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyShoppingCheckItem
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "pregnancyShoppingItemId",
            "medicalProfileId",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})


# Notes


class NotesSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = Notes
        fields = [
            "id",
            "title",
            "description",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})


# Appointments


class AppointmentSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()

    class Meta:
        model = Appointment
        fields = [
            "id",
            "title",
            "doctorName",
            "speciality",
            "note",
            "date",
            "dateTime",
            "isDone",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

# Contraction Timer Group

class ContractionTimerGroupSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()
    totalDurationSeconds = serializers.SerializerMethodField()
    averageDurationSeconds = serializers.SerializerMethodField()
    averageIntervalSeconds = serializers.SerializerMethodField()

    class Meta:
        model = ContractionTimerGroup
        fields = [
            "id",
            "date",
            "note",
            "createdDate",
            "updatedDate",
            "medicalProfileId",
            "totalDurationSeconds",
            "averageDurationSeconds",
            "averageIntervalSeconds",
            "isAuthorized",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "medicalProfileId" in data:
            isCheck = validateParentId(
                self, data["medicalProfileId"].childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})

    def getContractionTimeRowList(self,instance):
        return ContractionTimerRow.objects.filter(contractionTimerGroupId = instance.id)
    
    def countContractionTimeRowList(self,instance):
        return len(ContractionTimerRow.objects.filter(contractionTimerGroupId = instance.id))

    def calculateTotalDurationSeconds(self,instance):
        dataList = self.getContractionTimeRowList(instance)
        if dataList.__len__() > 0:
            return sum(r.durationSeconds for r in dataList)
        return 0

    def get_totalDurationSeconds(self,instance):
        return self.calculateTotalDurationSeconds(instance)

    def get_averageDurationSeconds(self,instance):
        count = self.countContractionTimeRowList(instance)
        total = self.calculateTotalDurationSeconds(instance)
        if count > 0:
            return total / count
        return 0

    def get_averageIntervalSeconds(self,instance):
        dataList = self.getContractionTimeRowList(instance)
        intervals = [
            r.intervalSeconds for r in dataList
        ]
        if intervals.__len__() > 0:
            return sum(intervals) / len(dataList)
        return 0

# Contraction Timer Row

class ContractionTimerRowSerializer(serializers.ModelSerializer):
    isAuthorized = serializers.SerializerMethodField()
    
    class Meta:
        model = ContractionTimerRow
        fields = [
            "id",
            "startAt",
            "endAt",
            "durationSeconds",
            "intervalSeconds",
            "createdDate",
            "updatedDate",
            "isAuthorized",
            "contractionTimerGroupId",
        ]

    def get_isAuthorized(self, instance):
        if isValidData(self, instance.contractionTimerGroupId.medicalProfileId.childId.id):
            return True

    def validate(self, data):
        errorMessage = ""
        isCheck = False
        if "contractionTimerGroupId" in data:
            isCheck = validateParentId(
                self, data["contractionTimerGroupId"].medicalProfileId.childId.parentId.id
            )
        else:
            errorMessage = "Parent Id does not exit"

        if isCheck == True:
            return data

        elif len(errorMessage) > 0:
            raise serializers.ValidationError({"error": [errorMessage]})