import secrets
import datetime
from rest_framework import serializers
from mama_care_api.settings import *
from subscription.models import SubscriptionOrder, SubscriptionTransaction
from user_profile.serializers import *
from datetime import datetime
import base64
import io
from PIL import Image
from django.core.files.uploadedfile import InMemoryUploadedFile
from basic.models import Language,basicPlanKeyName
from subscription.models import SubscriptionPlan

def isValidData(self, selectedMedicalProfileId):
    if self.context.__contains__("request"):
        parentId = self.context["request"].query_params.get("parentId", None)
        childId = self.context["request"].query_params.get("childId", None)
        medicalProfileId = self.context["request"].query_params.get(
            "medicalProfileId", None
        )
        errorMessage = ""
        if parentId is None:
            errorMessage = "Parent Id is required"

        elif childId is None:
            errorMessage = "Child Id is required"

        elif medicalProfileId is None:
            errorMessage = "Medical Profile Id is required"

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

        isExistChild = Child.objects.filter(id=childId).exists()

        if isExistChild == True:
            selectedChild = Child.objects.get(id=childId)
            if selectedChild.parentId.id == int(parentId):
                isExistMedicalProfile = MedicalProfile.objects.filter(
                    childId=childId
                ).exists()
                if isExistMedicalProfile == True:
                    selectedMedicalProfile = MedicalProfile.objects.get(childId=childId)
                    if selectedMedicalProfile.childId.id == int(
                        childId
                    ) and selectedMedicalProfile.childId.id == int(medicalProfileId):
                        if selectedMedicalProfileId == int(medicalProfileId):
                            return True
                        else:
                            errorMessage = "Invalid Medical Profile Id"
                    else:
                        errorMessage = "Invalid Medical Profile Id"
                else:
                    errorMessage = "Medical Profile Id does not exist"
            else:
                errorMessage = "Invalid Parent Id"
        else:
            errorMessage = "Child Id does not exits"

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

    return True

def getIsDashboard(self):
    if self.context.__contains__("request"):
        isDashboard = self.context["request"].headers.get("isDashboard", None)
    elif self.context.__contains__("isDashboard"):
        isDashboard = self.context["isDashboard"]
    else:
        isDashboard = None
    return isDashboard

def getLanguageRecord(languageId):
    if languageId is not None:
        selectedLanguage = Language.objects.get(id=languageId)
        if selectedLanguage.isEnabled:
            return selectedLanguage.id
    return None

def getLanguage(self):
    if self.context.__contains__("request"):
        languageId = self.context["request"].headers.get(languageKey, None)
    elif self.context.__contains__(languageKey):
        languageId = self.context[languageKey]
    else:
        languageId = None

    return getLanguageRecord(languageId)

def validatePassword(password):
    return len(password) == 6 and password.isdigit()

def generateToken(len):
    token = secrets.token_hex(len)
    return token

def getParentId(self):
    if self.context.__contains__("request"):
        parentId = self.context["request"].query_params.get("parentId", None)
        return parentId

def validateParentId(self, parentIdData):
    errorMessage = ""
    parentIdRequest = getParentId(self)
    if parentIdRequest is not None:
        if parentIdData is not None:
            if parentIdData == int(parentIdRequest):
                return True
            else:
                errorMessage = "Parent Id is not matched"
        else:
            errorMessage = "Parent Id is Required"
    else:
        errorMessage = "Parent Id is Required"

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

    return False

def getSubscriptionInfo(self, instance):
        isCheck = False
        transactionId = None
        keyName = None
        soCount = 0
        finAccList = FinancialProfile.objects.filter(parentId=instance.id)
        if finAccList.__len__() > 0:
            finAcc = finAccList[0]
            soCount = SubscriptionOrder.objects.filter(
                financialProfileId=finAcc
            ).count()
            subscriptionOrderList = SubscriptionOrder.objects.filter(
                financialProfileId=finAcc, isExpired=False
            )
            if subscriptionOrderList.__len__() > 0:
                selectedOrder = subscriptionOrderList[0]
                transList = SubscriptionTransaction.objects.filter(
                    subscriptionOrderId=selectedOrder.id
                )
                if transList.__len__() > 0:
                    isCheck = True
                    keyName = selectedOrder.subscriptionPlanId.keyName
                    transactionId = transList[0].transactionId

        if isCheck == True:
            return {
                "keyName": keyName,
                "transactionId": transactionId,
                "count": soCount,
            }
        else:
            subList = SubscriptionPlan.objects.filter(keyName=basicPlanKeyName)
            if subList.__len__() > 0:
                return {
                    "keyName": subList[0].keyName,
                    "transactionId": "",
                    "count": soCount,
                }
        return None

def getMedicalProfile(self, instance):
        isExists = MedicalProfile.objects.filter(childId=instance.id).exists()
        if isExists == True:
            selected = MedicalProfile.objects.get(childId=instance.id)
            return MedicalProfileSerializer(selected).data
        else:
            medicalProfileMap = {
                "createdDate": datetime.now(),
                "updatedDate": datetime.now(),
                "childId": instance.id,
            }
            medicalProfileSerializer = MedicalProfileSerializer(data=medicalProfileMap)
            if medicalProfileSerializer.is_valid():
                medicalProfileSerializer.save()
                return medicalProfileSerializer.data

def getImageName(weekNumber):
    dt = datetime.now()  # validated_data["createdDate"]
    dtString = (
        str(dt.year)
        + str(dt.month)
        + str(dt.day)
        + str(dt.hour)
        + str(dt.minute)
        + str(dt.second)
    )
    name = str(weekNumber) + "_" + dtString
    return name

def uploadImage(self, imageName):
    imageBase64 = self.context["request"].data.get("imageBase64")
    imageExtension = self.context["request"].data.get("imageExtension")

    data = base64.b64decode(imageBase64.encode("UTF-8"))
    buf = io.BytesIO(data)
    img = Image.open(buf)
    img_io = io.BytesIO()
    img.save(img_io, format=imageExtension.upper())

    newImage = InMemoryUploadedFile(
        file=img_io,
        field_name="image",
        name=imageName + "." + imageExtension,
        size=img_io.tell(),
        charset=None,
        content_type="image/" + imageExtension.upper(),
    )
    return newImage