from rest_framework import serializers

from employee.models import BonusPoint, Employee
from leave.models import LeaveType
from payroll.models.models import (
    Allowance,
    Contract,
    Deduction,
    LoanAccount,
    MultipleCondition,
    Payslip,
    Reimbursement,
    ReimbursementMultipleAttachment,
)
from payroll.models.tax_models import TaxBracket


class PayslipSerializer(serializers.ModelSerializer):
    employee_first_name = serializers.CharField(
        source="employee_id.employee_first_name", read_only=True
    )
    employee_last_name = serializers.CharField(
        source="employee_id.employee_last_name", read_only=True
    )
    shift_name = serializers.CharField(source="shift_id.employee_shift", read_only=True)
    badge_id = serializers.CharField(source="employee_id.badge_id", read_only=True)
    employee_profile_url = serializers.SerializerMethodField(read_only=True)
    department_name = serializers.CharField(
        source="employee_id.employee_work_info.department_id.department", read_only=True
    )
    bank_account_check_number = serializers.CharField(
        source="employee_id.employee_bank_details.account_number", read_only=True
    )

    class Meta:
        model = Payslip
        fields = "__all__"
        # exclude = ['reference',
        #            'sent_to_employee',
        #            'installment_ids', 'created_at']

    def get_employee_profile_url(self, obj):
        try:
            employee_profile = obj.employee_id.employee_profile
            return employee_profile.url
        except:
            return None


class ContractSerializer(serializers.ModelSerializer):
    employee_first_name = serializers.CharField(
        source="employee_id.employee_first_name", read_only=True
    )
    employee_last_name = serializers.CharField(
        source="employee_id.employee_last_name", read_only=True
    )
    shift_name = serializers.CharField(source="shift_id.employee_shift", read_only=True)
    badge_id = serializers.CharField(source="employee_id.badge_id", read_only=True)
    employee_profile_url = serializers.SerializerMethodField(read_only=True)

    job_position_name = serializers.CharField(
        source="job_position_id.job_position", read_only=True
    )
    job_role_name = serializers.CharField(source="job_role_id.job_role", read_only=True)
    department_name = serializers.CharField(
        source="department_id.department", read_only=True
    )
    shift_name = serializers.CharField(source="shift_id.employee_shift", read_only=True)
    work_type_name = serializers.CharField(
        source="work_type_id.work_type", read_only=True
    )

    def get_employee_profile_url(self, obj):
        try:
            employee_profile = obj.employee_id.employee_profile
            return employee_profile.url
        except:
            return None

    class Meta:
        model = Contract
        fields = "__all__"


class MultipleConditionSerializer(serializers.ModelSerializer):
    class Meta:
        model = MultipleCondition
        fields = "__all__"


class AllowanceSerializer(serializers.ModelSerializer):
    specific_employees = serializers.PrimaryKeyRelatedField(
        queryset=Employee.objects.all(), many=True, required=False
    )
    exclude_employees = serializers.PrimaryKeyRelatedField(
        queryset=Employee.objects.all(), many=True, required=False
    )
    other_conditions = serializers.PrimaryKeyRelatedField(
        queryset=MultipleCondition.objects.all(), many=True, required=False
    )

    class Meta:
        model = Allowance
        fields = "__all__"
        read_only_fields = ["id", "company_id", "only_show_under_employee", "is_loan"]

    def create(self, validated_data):
        specific_employees = validated_data.pop("specific_employees", [])
        exclude_employees = validated_data.pop("exclude_employees", [])
        other_conditions = validated_data.pop("other_conditions", [])

        allowance = Allowance.objects.create(**validated_data)

        # Set the ManyToMany relationships after the instance is created
        allowance.specific_employees.set(specific_employees)
        allowance.exclude_employees.set(exclude_employees)
        allowance.other_conditions.set(other_conditions)

        return allowance

    def validate(self, data):
        is_fixed = data.get("is_fixed")
        amount = data.get("amount")
        based_on = data.get("based_on")
        per_attendance_fixed_amount = data.get("per_attendance_fixed_amount")
        shift_id = data.get("shift_id")
        work_type_id = data.get("work_type_id")
        is_condition_based = data.get("is_condition_based")
        field = data.get("field")
        condition = data.get("condition")
        value = data.get("value")
        has_max_limit = data.get("has_max_limit")
        maximum_amount = data.get("maximum_amount")

        if is_fixed and (amount is None or amount < 0):
            raise serializers.ValidationError(
                "If 'is_fixed' is True, 'amount' must be a positive number."
            )

        if not is_fixed and not based_on:
            raise serializers.ValidationError(
                "If 'is_fixed' is False, 'based_on' is required."
            )

        if based_on == "attendance" and not per_attendance_fixed_amount:
            raise serializers.ValidationError(
                "If 'based_on' is 'attendance', 'per_attendance_fixed_amount' is required."
            )

        if based_on == "shift_id" and not shift_id:
            raise serializers.ValidationError(
                "If 'based_on' is 'shift_id', 'shift_id' is required."
            )

        if based_on == "work_type_id" and not work_type_id:
            raise serializers.ValidationError(
                "If 'based_on' is 'work_type_id', 'work_type_id' is required."
            )

        if is_condition_based and (not field or not value or not condition):
            raise serializers.ValidationError(
                "If 'is_condition_based' is True, 'field', 'value', and 'condition' are required."
            )

        if has_max_limit and maximum_amount is None:
            raise serializers.ValidationError(
                "If 'has_max_limit' is True, 'maximum_amount' is required."
            )

        return data


class DeductionSerializer(serializers.ModelSerializer):
    class Meta:
        model = Deduction
        fields = "__all__"


class LoanAccountSerializer(serializers.ModelSerializer):
    employee_profile_url = serializers.SerializerMethodField(read_only=True)
    employee_full_name = serializers.CharField(
        source="employee_id.get_full_name", read_only=True
    )
    badge_id = serializers.CharField(source="employee_id.badge_id", read_only=True)
    job_position_name = serializers.CharField(
        source="employee_id.get_job_position", read_only=True
    )

    class Meta:
        model = LoanAccount
        fields = "__all__"

    def get_employee_profile_url(self, obj):
        try:
            employee_profile = obj.employee_id.employee_profile
            return employee_profile.url
        except:
            return None


class ReimbursementSerializer(serializers.ModelSerializer):
    other_attachements = serializers.SerializerMethodField()
    leave_type_name = serializers.CharField(source="leave_type_id.name", read_only=True)
    employee_profile_url = serializers.SerializerMethodField(read_only=True)
    badge_id = serializers.CharField(source="employee_id.badge_id")
    employee_full_name = serializers.CharField(source="employee_id.get_full_name")

    def get_employee_profile_url(self, obj):
        try:
            employee_profile = obj.employee_id.employee_profile
            return employee_profile.url
        except:
            return None

    class Meta:
        model = Reimbursement
        fields = "__all__"

    def get_other_attachements(self, obj):
        attachments = []
        for attachment in obj.other_attachments.all():
            try:
                attachments.append(attachment.attachment.url)
            except:
                pass
        return attachments

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        exclude_fields = []
        # Get type from data or instance
        instance_type = getattr(self.instance, "type", None)

        if instance_type == "reimbursement":
            exclude_fields.extend(
                ["leave_type_id", "cfd_to_encash", "ad_to_encash", "bonus_to_encash"]
            )
        elif instance_type == "leave_encashment":
            exclude_fields.extend(["attachment", "amount", "bonus_to_encash"])
        elif instance_type == "bonus_encashment":
            exclude_fields.extend(
                [
                    "attachment",
                    "amount",
                    "leave_type_id",
                    "cfd_to_encash",
                    "ad_to_encash",
                ]
            )

        # Remove excluded fields from serializer fields
        for field in exclude_fields:
            self.fields.pop(field, None)

    def get_encashable_leaves(self, employee):
        leaves = LeaveType.objects.filter(
            employee_available_leave__employee_id=employee,
            employee_available_leave__total_leave_days__gte=1,
            is_encashable=True,
        )
        return leaves

    def validate(self, data):
        try:
            employee_id = self.instance.employee_id
            type = self.instance.type
            leave_type_id = self.instance.leave_type_id
        except:
            employee_id = data["employee_id"]
            type = data["type"]
            leave_type_id = (
                data["leave_type_id"] if data.get("leave_type_id", None) else None
            )

        available_points = BonusPoint.objects.filter(employee_id=employee_id).first()
        if type == "bonus_encashment":
            try:
                bonus_to_encash = self.instance.bonus_to_encash
            except:
                bonus_to_encash = data["bonus_to_encash"]

            if available_points.points < bonus_to_encash:
                raise serializers.ValidationError(
                    {"bonus_to_encash": "Not enough bonus points to redeem"}
                )
            if bonus_to_encash <= 0:
                raise serializers.ValidationError(
                    {"bonus_to_encash": "Points must be greater than zero to redeem."}
                )
        if type == "leave_encashment":
            leave_type_id = leave_type_id
            encashable_leaves = self.get_encashable_leaves(employee_id)
            if (leave_type_id is None) or (leave_type_id not in encashable_leaves):
                raise serializers.ValidationError(
                    {"leave_type_id": "This leave type is not encashable"}
                )

        return data

    def save(self, **kwargs):
        multiple_attachment_ids = []
        request_files = self.context["request"].FILES
        attachments = request_files.getlist("attachment")
        if attachments:
            for attachment in attachments:
                file_instance = ReimbursementMultipleAttachment()
                file_instance.attachment = attachment
                file_instance.save()
                multiple_attachment_ids.append(file_instance.pk)

        instance = super().save()
        instance.other_attachments.add(*multiple_attachment_ids)

        return super().save(**kwargs)


class TaxBracketSerializer(serializers.ModelSerializer):
    class Meta:
        fields = "__all__"
        model = TaxBracket