# Employee/employee_insurance_views.py

from datetime import date
from decimal import Decimal, InvalidOperation
import uuid

from django.db.models import Q
from django.shortcuts import get_object_or_404
from django.utils import timezone
from django.utils.dateparse import parse_date

from rest_framework import status
from rest_framework.permissions import BasePermission
from rest_framework.response import Response
from rest_framework.views import APIView

from Company.models import company_details

from Insurance.models import (
    InsurancePolicy,
    InsuranceDependent,
    InsuranceClaim,
    NetworkHospital,
)

from .models import EmployeeDT

from .employee_crud_permissions import (
    AdminOrEmployeeJWTAuthentication,
    resolve_company_for_user,
    actor_label,
)

try:
    from .employee_authentication import EmployeeJWTAuthentication
except ImportError:
    EmployeeJWTAuthentication = AdminOrEmployeeJWTAuthentication


# ============================================================
# HELPERS
# ============================================================

def employee_required(request):
    """
    Return the authenticated employee.

    The custom JWT authentication returns EmployeeDT directly,
    so we do NOT use DRF IsAuthenticated here.
    """

    employee = getattr(request, "user", None)

    if not isinstance(employee, EmployeeDT):
        return None

    if not getattr(employee, "is_active", True):
        return None

    if not getattr(employee, "company_id", None):
        return None

    return employee


def employee_company(employee):
    """
    Return the employee's company object.
    """

    try:
        return employee.company
    except Exception:
        return None


def safe_actor_label(user):
    """
    Safely create created_by / updated_by value.
    """

    try:
        value = actor_label(user)

        if value:
            return str(value)[:100]
    except Exception:
        pass

    employee_code = getattr(user, "employee_code", None)

    if employee_code:
        return str(employee_code)[:100]

    name = getattr(user, "name", None)

    if name:
        return str(name)[:100]

    return str(getattr(user, "pk", ""))[:100]


def generate_dependent_id():
    """
    Generate unique dependent ID.

    Example:
    DEP-2026-A1B2C3D4
    """

    return f"DEP-{timezone.now().year}-{uuid.uuid4().hex[:8].upper()}"


def generate_claim_id():
    """
    Generate unique claim ID.

    Example:
    CLM-2026-A1B2C3D4
    """

    return f"CLM-{timezone.now().year}-{uuid.uuid4().hex[:8].upper()}"


def parse_required_date(value, field_name):
    """
    Parse YYYY-MM-DD date.
    """

    if not value:
        return None, f"{field_name} is required."

    parsed = parse_date(str(value))

    if parsed is None:
        return None, f"{field_name} must be in YYYY-MM-DD format."

    return parsed, None


def parse_optional_date(value, field_name):
    """
    Parse optional YYYY-MM-DD date.
    """

    if not value:
        return None, None

    parsed = parse_date(str(value))

    if parsed is None:
        return None, f"{field_name} must be in YYYY-MM-DD format."

    return parsed, None


def parse_amount(value, field_name="amount"):
    """
    Convert amount safely to Decimal.
    """

    if value is None or value == "":
        return None, f"{field_name} is required."

    try:
        amount = Decimal(str(value))
    except (InvalidOperation, ValueError, TypeError):
        return None, f"{field_name} must be a valid number."

    if amount < 0:
        return None, f"{field_name} cannot be negative."

    return amount, None


# ============================================================
# EMPLOYEE AUTHENTICATION PERMISSION
# ============================================================

class IsEmployeeInsuranceUser(BasePermission):
    """
    Custom permission for EmployeeDT.

    IMPORTANT:
    Do not use DRF IsAuthenticated because the existing
    AdminOrEmployeeJWTAuthentication returns EmployeeDT directly.
    """

    message = "Valid employee authentication is required."

    def has_permission(self, request, view):

        user = getattr(request, "user", None)

        if not isinstance(user, EmployeeDT):
            return False

        if not getattr(user, "is_active", True):
            return False

        if not getattr(user, "company_id", None):
            return False

        return True


# ============================================================
# 1. EMPLOYEE INSURANCE POLICY
# ============================================================

class EmployeeInsurancePolicyView(APIView):

    authentication_classes = [
        EmployeeJWTAuthentication
    ]

    permission_classes = [
        IsEmployeeInsuranceUser
    ]

    def get(self, request):

        employee = employee_required(request)

        if employee is None:
            return Response(
                {
                    "status": "error",
                    "message": "Valid employee authentication is required."
                },
                status=status.HTTP_401_UNAUTHORIZED
            )

        policies = InsurancePolicy.objects.filter(
            company_id=employee.company_id
        ).order_by("-start_date", "-id")

        data = []

        for policy in policies:

            data.append(
                {
                    "id": policy.id,
                    "policy_number": getattr(
                        policy,
                        "policy_number",
                        None
                    ),
                    "policy_name": getattr(
                        policy,
                        "policy_name",
                        None
                    ),
                    "provider_name": getattr(
                        policy,
                        "provider_name",
                        None
                    ),
                    "policy_type": getattr(
                        policy,
                        "policy_type",
                        None
                    ),
                    "sum_insured": str(
                        getattr(policy, "sum_insured", 0)
                    ),
                    "start_date": (
                        policy.start_date.isoformat()
                        if getattr(policy, "start_date", None)
                        else None
                    ),
                    "end_date": (
                        policy.end_date.isoformat()
                        if getattr(policy, "end_date", None)
                        else None
                    ),
                    "status": getattr(
                        policy,
                        "status",
                        None
                    ),
                }
            )

        return Response(
            {
                "status": "success",
                "count": len(data),
                "policies": data,
            },
            status=status.HTTP_200_OK
        )


# ============================================================
# 2. EMPLOYEE DEPENDENTS
# ============================================================

class EmployeeInsuranceDependentView(APIView):

    authentication_classes = [
        EmployeeJWTAuthentication
    ]

    permission_classes = [
        IsEmployeeInsuranceUser
    ]

    def get(self, request):

        employee = employee_required(request)

        if employee is None:
            return Response(
                {
                    "status": "error",
                    "message": "Valid employee authentication is required."
                },
                status=status.HTTP_401_UNAUTHORIZED
            )

        dependents = (
            InsuranceDependent.objects
            .filter(employee=employee)
            .order_by("name", "id")
        )

        data = []

        for dependent in dependents:

            data.append(
                {
                    "id": dependent.id,
                    "dependent_id": dependent.dependent_id,
                    "name": dependent.name,
                    "relationship": dependent.relation,
                    "relation": dependent.relation,
                    "gender": dependent.gender,
                    "date_of_birth": (
                        dependent.dob.isoformat()
                        if dependent.dob
                        else None
                    ),
                    "dob": (
                        dependent.dob.isoformat()
                        if dependent.dob
                        else None
                    ),
                    "health_card_no": dependent.health_card_no,
                    "endorsement_status": dependent.endorsement_status,
                    "is_active": (
                        str(dependent.endorsement_status).lower()
                        == "active"
                    ),
                    "policy_id": None,
                }
            )

        return Response(
            {
                "status": "success",
                "count": len(data),
                "dependents": data,
            },
            status=status.HTTP_200_OK
        )

    def post(self, request):

        employee = employee_required(request)

        if employee is None:
            return Response(
                {
                    "status": "error",
                    "message": "Valid employee authentication is required."
                },
                status=status.HTTP_401_UNAUTHORIZED
            )

        company = employee_company(employee)

        if company is None:
            return Response(
                {
                    "status": "error",
                    "message": "Employee is not linked to a company."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        data = request.data

        # ----------------------------------------------------
        # REQUIRED NAME
        # ----------------------------------------------------

        name = str(data.get("name", "")).strip()

        if not name:
            return Response(
                {
                    "status": "error",
                    "message": "name is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # RELATIONSHIP
        # ----------------------------------------------------

        relation = (
            data.get("relationship")
            or data.get("relation")
            or ""
        )

        relation = str(relation).strip()

        if not relation:
            return Response(
                {
                    "status": "error",
                    "message": "relationship is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # GENDER
        # ----------------------------------------------------

        gender = str(
            data.get("gender", "")
        ).strip()

        if not gender:
            return Response(
                {
                    "status": "error",
                    "message": "gender is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # DATE OF BIRTH
        # ----------------------------------------------------

        dob_value = (
            data.get("date_of_birth")
            or data.get("dob")
        )

        dob, error = parse_required_date(
            dob_value,
            "date_of_birth"
        )

        if error:
            return Response(
                {
                    "status": "error",
                    "message": error
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # HEALTH CARD
        # ----------------------------------------------------

        health_card_no = str(
            data.get("health_card_no", "")
        ).strip()

        # ----------------------------------------------------
        # ENDORSEMENT STATUS
        # ----------------------------------------------------

        endorsement_status = str(
            data.get(
                "endorsement_status",
                "Active"
            )
        ).strip()

        if not endorsement_status:
            endorsement_status = "Active"

        # ----------------------------------------------------
        # IMPORTANT:
        # GENERATE dependent_id AUTOMATICALLY
        # ----------------------------------------------------

        dependent_id = generate_dependent_id()

        # Make absolutely sure the generated ID is unique.
        while InsuranceDependent.objects.filter(
            dependent_id=dependent_id
        ).exists():

            dependent_id = generate_dependent_id()

        # ----------------------------------------------------
        # CREATE DEPENDENT
        # ----------------------------------------------------

        dependent = InsuranceDependent.objects.create(
            dependent_id=dependent_id,
            company=company,
            employee=employee,
            name=name,
            relation=relation,
            gender=gender,
            dob=dob,
            health_card_no=health_card_no,
            endorsement_status=endorsement_status,
            created_by=safe_actor_label(request.user),
            updated_by=safe_actor_label(request.user),
        )

        return Response(
            {
                "status": "success",
                "message": "Dependent added successfully.",
                "dependent": {
                    "id": dependent.id,
                    "dependent_id": dependent.dependent_id,
                    "name": dependent.name,
                    "relationship": dependent.relation,
                    "gender": dependent.gender,
                    "date_of_birth": (
                        dependent.dob.isoformat()
                        if dependent.dob
                        else None
                    ),
                    "health_card_no": dependent.health_card_no,
                    "endorsement_status": dependent.endorsement_status,
                }
            },
            status=status.HTTP_201_CREATED
        )


# ============================================================
# 3. NETWORK HOSPITALS
# ============================================================

class EmployeeInsuranceHospitalView(APIView):

    authentication_classes = [
        EmployeeJWTAuthentication
    ]

    permission_classes = [
        IsEmployeeInsuranceUser
    ]

    def get(self, request):

        employee = employee_required(request)

        if employee is None:
            return Response(
                {
                    "status": "error",
                    "message": "Valid employee authentication is required."
                },
                status=status.HTTP_401_UNAUTHORIZED
            )

        search = str(
            request.query_params.get(
                "search",
                ""
            )
        ).strip()

        hospitals = NetworkHospital.objects.filter(
            company_id=employee.company_id
        )

        if search:

            hospitals = hospitals.filter(
                Q(hospital_name__icontains=search)
                |
                Q(city__icontains=search)
                |
                Q(address__icontains=search)
            )

        hospitals = hospitals.order_by(
            "hospital_name"
        )

        data = []

        for hospital in hospitals:

            data.append(
                {
                    "id": hospital.id,
                    "hospital_name": hospital.hospital_name,
                    "city": hospital.city,
                    "address": getattr(
                        hospital,
                        "address",
                        ""
                    ),
                    "contact_number": getattr(
                        hospital,
                        "contact_number",
                        ""
                    ),
                    "email": getattr(
                        hospital,
                        "email",
                        ""
                    ),
                    "status": getattr(
                        hospital,
                        "status",
                        None
                    ),
                }
            )

        return Response(
            {
                "status": "success",
                "count": len(data),
                "hospitals": data,
            },
            status=status.HTTP_200_OK
        )


# ============================================================
# 4. EMPLOYEE CLAIMS
# ============================================================

class EmployeeInsuranceClaimView(APIView):

    authentication_classes = [
        EmployeeJWTAuthentication
    ]

    permission_classes = [
        IsEmployeeInsuranceUser
    ]

    # --------------------------------------------------------
    # GET CLAIMS
    # --------------------------------------------------------

    def get(self, request):

        employee = employee_required(request)

        if employee is None:
            return Response(
                {
                    "status": "error",
                    "message": "Valid employee authentication is required."
                },
                status=status.HTTP_401_UNAUTHORIZED
            )

        claims = (
            InsuranceClaim.objects
            .filter(
                employee=employee,
                company_id=employee.company_id
            )
            .select_related("policy")
            .order_by("-claim_date", "-id")
        )

        data = []

        for claim in claims:

            data.append(
                {
                    "id": claim.id,
                    "claim_id": claim.claim_id,
                    "patient_name": claim.patient_name,
                    "relation": claim.relation,
                    "claim_type": claim.claim_type,
                    "hospital_name": claim.hospital_name,
                    "city": claim.city,
                    "diagnosis": claim.diagnosis,
                    "admission_date": (
                        claim.admission_date.isoformat()
                        if claim.admission_date
                        else None
                    ),
                    "discharge_date": (
                        claim.discharge_date.isoformat()
                        if claim.discharge_date
                        else None
                    ),
                    "claim_date": (
                        claim.claim_date.isoformat()
                        if claim.claim_date
                        else None
                    ),
                    "claimed_amount": str(
                        claim.claimed_amount
                    ),
                    "approved_amount": str(
                        claim.approved_amount
                    ),
                    "status": claim.status,
                    "rejection_category": claim.rejection_category,
                    "rejection_reason": claim.rejection_reason,
                    "tpa_ref": claim.tpa_ref,
                    "remarks": claim.remarks,
                    "policy_id": (
                        claim.policy_id
                        if claim.policy_id
                        else None
                    ),
                    "policy_number": (
                        claim.policy.policy_number
                        if claim.policy
                        else None
                    ),
                    "approved_at": (
                        claim.approved_at.isoformat()
                        if claim.approved_at
                        else None
                    ),
                    "approved_by": claim.approved_by,
                    "rejected_at": (
                        claim.rejected_at.isoformat()
                        if claim.rejected_at
                        else None
                    ),
                    "rejected_by": claim.rejected_by,
                }
            )

        return Response(
            {
                "status": "success",
                "count": len(data),
                "claims": data,
            },
            status=status.HTTP_200_OK
        )

    # --------------------------------------------------------
    # CREATE CLAIM
    # --------------------------------------------------------

    def post(self, request):

        employee = employee_required(request)

        if employee is None:
            return Response(
                {
                    "status": "error",
                    "message": "Valid employee authentication is required."
                },
                status=status.HTTP_401_UNAUTHORIZED
            )

        company = employee_company(employee)

        if company is None:
            return Response(
                {
                    "status": "error",
                    "message": "Employee is not linked to a company."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        data = request.data

        # ----------------------------------------------------
        # POLICY
        # ----------------------------------------------------

        policy_id = data.get("policy_id")

        if not policy_id:
            return Response(
                {
                    "status": "error",
                    "message": "policy_id is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        policy = get_object_or_404(
            InsurancePolicy,
            id=policy_id,
            company_id=employee.company_id
        )

        # ----------------------------------------------------
        # PATIENT
        # ----------------------------------------------------

        patient_name = str(
            data.get("patient_name", "")
        ).strip()

        if not patient_name:
            return Response(
                {
                    "status": "error",
                    "message": "patient_name is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # CLAIM TYPE
        # ----------------------------------------------------

        claim_type = str(
            data.get("claim_type", "")
        ).strip()

        if not claim_type:
            return Response(
                {
                    "status": "error",
                    "message": "claim_type is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # HOSPITAL
        # ----------------------------------------------------

        hospital_name = str(
            data.get("hospital_name", "")
        ).strip()

        if not hospital_name:
            return Response(
                {
                    "status": "error",
                    "message": "hospital_name is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        city = str(
            data.get("city", "")
        ).strip()

        if not city:
            return Response(
                {
                    "status": "error",
                    "message": "city is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # DIAGNOSIS
        # ----------------------------------------------------

        diagnosis = str(
            data.get("diagnosis", "")
        ).strip()

        if not diagnosis:
            return Response(
                {
                    "status": "error",
                    "message": "diagnosis is required."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # ADMISSION DATE
        # ----------------------------------------------------

        admission_date, error = parse_required_date(
            data.get("admission_date"),
            "admission_date"
        )

        if error:
            return Response(
                {
                    "status": "error",
                    "message": error
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # DISCHARGE DATE
        # ----------------------------------------------------

        discharge_date, error = parse_required_date(
            data.get("discharge_date"),
            "discharge_date"
        )

        if error:
            return Response(
                {
                    "status": "error",
                    "message": error
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        if discharge_date < admission_date:

            return Response(
                {
                    "status": "error",
                    "message": "discharge_date cannot be before admission_date."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # CLAIM DATE
        # ----------------------------------------------------

        claim_date, error = parse_optional_date(
            data.get("claim_date"),
            "claim_date"
        )

        if error:
            return Response(
                {
                    "status": "error",
                    "message": error
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        if claim_date is None:
            claim_date = timezone.localdate()

        # ----------------------------------------------------
        # AMOUNT
        # ----------------------------------------------------

        claimed_amount, error = parse_amount(
            data.get("claimed_amount"),
            "claimed_amount"
        )

        if error:
            return Response(
                {
                    "status": "error",
                    "message": error
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        # ----------------------------------------------------
        # GENERATE CLAIM ID
        # ----------------------------------------------------

        claim_id = generate_claim_id()

        while InsuranceClaim.objects.filter(
            claim_id=claim_id
        ).exists():

            claim_id = generate_claim_id()

        # ----------------------------------------------------
        # CREATE CLAIM
        # ----------------------------------------------------

        claim = InsuranceClaim.objects.create(
            claim_id=claim_id,
            company=company,
            employee=employee,
            policy=policy,
            patient_name=patient_name,
            relation=str(
                data.get("relation", "")
            ).strip(),
            claim_type=claim_type,
            hospital_name=hospital_name,
            city=city,
            diagnosis=diagnosis,
            admission_date=admission_date,
            discharge_date=discharge_date,
            claim_date=claim_date,
            claimed_amount=claimed_amount,
            approved_amount=Decimal("0.00"),
            status="Pending",
            rejection_category="",
            rejection_reason="",
            tpa_ref="",
            remarks=str(
                data.get("remarks", "")
            ).strip(),
            created_by=safe_actor_label(request.user),
            updated_by=safe_actor_label(request.user),
        )

        return Response(
            {
                "status": "success",
                "message": "Insurance claim submitted successfully.",
                "claim": {
                    "id": claim.id,
                    "claim_id": claim.claim_id,
                    "patient_name": claim.patient_name,
                    "relation": claim.relation,
                    "claim_type": claim.claim_type,
                    "hospital_name": claim.hospital_name,
                    "city": claim.city,
                    "diagnosis": claim.diagnosis,
                    "admission_date": claim.admission_date.isoformat(),
                    "discharge_date": claim.discharge_date.isoformat(),
                    "claim_date": claim.claim_date.isoformat(),
                    "claimed_amount": str(
                        claim.claimed_amount
                    ),
                    "approved_amount": str(
                        claim.approved_amount
                    ),
                    "status": claim.status,
                    "policy_id": claim.policy_id,
                }
            },
            status=status.HTTP_201_CREATED
        )


# ============================================================
# 5. SINGLE CLAIM
# ============================================================

class EmployeeInsuranceClaimDetailView(APIView):

    authentication_classes = [
        EmployeeJWTAuthentication
    ]

    permission_classes = [
        IsEmployeeInsuranceUser
    ]

    def get(self, request, claim_id):

        employee = employee_required(request)

        if employee is None:
            return Response(
                {
                    "status": "error",
                    "message": "Valid employee authentication is required."
                },
                status=status.HTTP_401_UNAUTHORIZED
            )

        claim = get_object_or_404(
            InsuranceClaim.objects.select_related(
                "policy"
            ),
            claim_id=claim_id,
            employee=employee,
            company_id=employee.company_id,
        )

        return Response(
            {
                "status": "success",
                "claim": {
                    "id": claim.id,
                    "claim_id": claim.claim_id,
                    "patient_name": claim.patient_name,
                    "relation": claim.relation,
                    "claim_type": claim.claim_type,
                    "hospital_name": claim.hospital_name,
                    "city": claim.city,
                    "diagnosis": claim.diagnosis,
                    "admission_date": (
                        claim.admission_date.isoformat()
                        if claim.admission_date
                        else None
                    ),
                    "discharge_date": (
                        claim.discharge_date.isoformat()
                        if claim.discharge_date
                        else None
                    ),
                    "claim_date": (
                        claim.claim_date.isoformat()
                        if claim.claim_date
                        else None
                    ),
                    "claimed_amount": str(
                        claim.claimed_amount
                    ),
                    "approved_amount": str(
                        claim.approved_amount
                    ),
                    "status": claim.status,
                    "rejection_category": claim.rejection_category,
                    "rejection_reason": claim.rejection_reason,
                    "tpa_ref": claim.tpa_ref,
                    "remarks": claim.remarks,
                    "policy_id": claim.policy_id,
                    "policy_number": (
                        claim.policy.policy_number
                        if claim.policy
                        else None
                    ),
                    "approved_at": (
                        claim.approved_at.isoformat()
                        if claim.approved_at
                        else None
                    ),
                    "approved_by": claim.approved_by,
                    "rejected_at": (
                        claim.rejected_at.isoformat()
                        if claim.rejected_at
                        else None
                    ),
                    "rejected_by": claim.rejected_by,
                    "reopened_at": (
                        claim.reopened_at.isoformat()
                        if claim.reopened_at
                        else None
                    ),
                    "reopened_by": claim.reopened_by,
                }
            },
            status=status.HTTP_200_OK
        )


# ============================================================
# 6. CLAIM DECISION PERMISSION
# ============================================================

class CanApproveInsurance(BasePermission):

    message = "You do not have permission to approve or reject insurance claims."

    def has_permission(self, request, view):

        user = getattr(request, "user", None)

        if isinstance(user, company_details):
            return True

        if isinstance(user, EmployeeDT):

            if not getattr(user, "is_active", True):
                return False

            if not getattr(user, "company_id", None):
                return False

            role = (
                getattr(user, "active_role", None)
                or getattr(user, "role", None)
                or getattr(user, "employee_role", None)
            )

            return bool(
                getattr(
                    role,
                    "can_approve_insurance",
                    False
                )
            )

        return False


# ============================================================
# 7. CLAIM DECISION
# ============================================================

class EmployeeInsuranceClaimDecisionView(APIView):

    authentication_classes = [
        AdminOrEmployeeJWTAuthentication
    ]

    permission_classes = [
        CanApproveInsurance
    ]

    def patch(self, request, claim_id):

        user = getattr(request, "user", None)

        company = resolve_company_for_user(user)

        if company is None:
            return Response(
                {
                    "status": "error",
                    "message": "Unable to determine company."
                },
                status=status.HTTP_400_BAD_REQUEST
            )

        claim = get_object_or_404(
            InsuranceClaim,
            claim_id=claim_id,
            company=company
        )

        decision = str(
            request.data.get(
                "decision",
                ""
            )
        ).strip().lower()

        # ----------------------------------------------------
        # APPROVE
        # ----------------------------------------------------

        if decision in (
            "approved",
            "approve"
        ):

            approved_amount, error = parse_amount(
                request.data.get("approved_amount"),
                "approved_amount"
            )

            if error:
                return Response(
                    {
                        "status": "error",
                        "message": error
                    },
                    status=status.HTTP_400_BAD_REQUEST
                )

            if approved_amount > claim.claimed_amount:

                return Response(
                    {
                        "status": "error",
                        "message": (
                            "approved_amount cannot be greater "
                            "than claimed_amount."
                        )
                    },
                    status=status.HTTP_400_BAD_REQUEST
                )

            claim.status = "Approved"
            claim.approved_amount = approved_amount
            claim.approved_at = timezone.now()
            claim.approved_by = safe_actor_label(user)

            claim.rejected_at = None
            claim.rejected_by = ""
            claim.rejection_category = ""
            claim.rejection_reason = ""

            claim.remarks = str(
                request.data.get(
                    "remarks",
                    claim.remarks
                )
            ).strip()

            claim.updated_by = safe_actor_label(user)

            claim.save()

            return Response(
                {
                    "status": "success",
                    "message": "Insurance claim approved successfully.",
                    "claim": {
                        "claim_id": claim.claim_id,
                        "status": claim.status,
                        "claimed_amount": str(
                            claim.claimed_amount
                        ),
                        "approved_amount": str(
                            claim.approved_amount
                        ),
                        "approved_at": (
                            claim.approved_at.isoformat()
                            if claim.approved_at
                            else None
                        ),
                        "approved_by": claim.approved_by,
                    }
                },
                status=status.HTTP_200_OK
            )

        # ----------------------------------------------------
        # REJECT
        # ----------------------------------------------------

        if decision in (
            "rejected",
            "reject"
        ):

            rejection_reason = str(
                request.data.get(
                    "rejection_reason",
                    ""
                )
            ).strip()

            if not rejection_reason:

                return Response(
                    {
                        "status": "error",
                        "message": "rejection_reason is required."
                    },
                    status=status.HTTP_400_BAD_REQUEST
                )

            claim.status = "Rejected"
            claim.approved_amount = Decimal("0.00")

            claim.rejection_category = str(
                request.data.get(
                    "rejection_category",
                    ""
                )
            ).strip()

            claim.rejection_reason = rejection_reason

            claim.rejected_at = timezone.now()
            claim.rejected_by = safe_actor_label(user)

            claim.approved_at = None
            claim.approved_by = ""

            claim.remarks = str(
                request.data.get(
                    "remarks",
                    claim.remarks
                )
            ).strip()

            claim.updated_by = safe_actor_label(user)

            claim.save()

            return Response(
                {
                    "status": "success",
                    "message": "Insurance claim rejected successfully.",
                    "claim": {
                        "claim_id": claim.claim_id,
                        "status": claim.status,
                        "claimed_amount": str(
                            claim.claimed_amount
                        ),
                        "approved_amount": str(
                            claim.approved_amount
                        ),
                        "rejection_category": (
                            claim.rejection_category
                        ),
                        "rejection_reason": (
                            claim.rejection_reason
                        ),
                        "rejected_at": (
                            claim.rejected_at.isoformat()
                            if claim.rejected_at
                            else None
                        ),
                        "rejected_by": claim.rejected_by,
                    }
                },
                status=status.HTTP_200_OK
            )

        return Response(
            {
                "status": "error",
                "message": (
                    "Invalid decision. Use "
                    "'Approved' or 'Rejected'."
                )
            },
            status=status.HTTP_400_BAD_REQUEST
        )
        