# ============================================================
# ADDITIVE: Employee self-service API - Leave & WFH Engine
# ------------------------------------------------------------
# Mounted at  /employee/leave/   (see Employee/leave_self_urls.py)
# Auth: Employee JWT. An employee only ever sees / changes their
# OWN requests. Designated managers / HODs additionally get an
# approvals queue for the people who report to them.
#
#   GET  dashboard/
#   GET/POST            leaves/           apply / list own leaves
#   GET/PUT/PATCH/DELETE leaves/<id>/     (edit / delete: Pending only)
#   POST                leaves/<id>/cancel/
#   GET/POST            wfh/              apply / list own WFH
#   GET/PUT/PATCH/DELETE wfh/<id>/        (edit / delete: Pending only)
#   POST                wfh/<id>/cancel/
#   GET                 wfh/policy/
#   GET                 balances/?financial_year=2026-27
#   GET                 calendar/?month=&year=&scope=team|me
#   GET                 policies/
#   GET                 workflow/
#   GET                 approvals/pending/       (manager / HOD)
#   POST                approvals/<action_id>/approve|reject/
# ============================================================

from datetime import timedelta
from decimal import Decimal

from django.db import transaction
from django.utils import timezone

from rest_framework import serializers
from rest_framework import status as http_status
from rest_framework.views import APIView

from Company.leave_engine import (
    _err,
    _ok,
    apply_leave_to_attendance,  # noqa: F401  (re-exported for clarity)
    revert_leave_attendance,
    working_dates,
)
from Company import leave_engine as eng
from Company.hr_api_views import MAX_LEAVE_RANGE_DAYS, employee_brief, employee_map

from .employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated
from .employee_crud_permissions import actor_label
from .leave_models import ApprovalAction, WFHRequest
from .models import EmployeeDT, LeaveRequest


class EmployeeLeaveBase(APIView):
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

    @property
    def me(self):
        return self.request.user

    @property
    def company(self):
        return self.request.user.company

    def _brief_lookup(self, extra_codes=()):
        return employee_map(self.company, {self.me.employee_code, *extra_codes})


# ============================================================
# helpers
# ============================================================

def _leave_with_pipeline(view, leave):
    acts = eng.actions_map(view.company, "leave", [leave.pk]).get(leave.pk, [])
    codes = {a.approver_code for a in acts if a.approver_code}
    return eng.leave_row(leave, view._brief_lookup(codes), acts, view.request)


def _wfh_with_pipeline(view, wfh):
    acts = eng.actions_map(view.company, "wfh", [wfh.pk]).get(wfh.pk, [])
    codes = {a.approver_code for a in acts if a.approver_code}
    return eng.wfh_row(wfh, view._brief_lookup(codes), acts, view.request, view.company)


def _overlaps(company, code, from_date, to_date, exclude_pk=None):
    qs = LeaveRequest.objects.filter(
        company=company, Employee_ID=code, is_active=True,
        status__in=["Pending", "Approved"],
        from_date__lte=to_date, to_date__gte=from_date,
    )
    if exclude_pk:
        qs = qs.exclude(pk=exclude_pk)
    return qs.exists()


def _validate_leave_range(company, code, leave_type, from_date, to_date, exclude_pk=None):
    """Returns (days, error_response_or_None)."""
    if to_date < from_date:
        return None, _err("invalid_dates", "to_date cannot be before from_date.")
    if (to_date - from_date).days + 1 > MAX_LEAVE_RANGE_DAYS:
        return None, _err("range_too_long",
                          f"A leave cannot span more than {MAX_LEAVE_RANGE_DAYS} days.")
    if to_date < timezone.localdate() - timedelta(days=eng.PAST_LEAVE_GRACE_DAYS):
        return None, _err(
            "past_dates",
            f"Leave cannot be applied for dates older than {eng.PAST_LEAVE_GRACE_DAYS} days. "
            "Ask HR to add it.")

    days = working_dates(company, from_date, to_date)
    if not days:
        return None, _err("no_working_days",
                          "The selected range has no working days (only Sundays / holidays).")

    if _overlaps(company, code, from_date, to_date, exclude_pk):
        return None, _err("leave_overlap",
                          "You already have a pending/approved leave in that range.",
                          http_status.HTTP_409_CONFLICT)

    err = eng.check_leave_policy_rules(company, leave_type, from_date, len(days))
    if err is not None:
        return None, err

    err = eng.check_leave_balance(company, code, leave_type, from_date, len(days), exclude_pk)
    if err is not None:
        return None, err

    return len(days), None


class SelfLeaveSerializer(serializers.ModelSerializer):
    class Meta:
        model = LeaveRequest
        fields = ["leave_type", "from_date", "to_date", "reason"]


class SelfWFHSerializer(serializers.ModelSerializer):
    class Meta:
        model = WFHRequest
        fields = ["wfh_date", "reason"]


# ============================================================
# DASHBOARD
# ============================================================

class MyLeaveDashboardView(EmployeeLeaveBase):
    """GET /employee/leave/dashboard/?financial_year=2026-27"""

    def get(self, request):
        company, code = self.company, self.me.employee_code
        fy = request.query_params.get("financial_year") or eng.financial_year()
        if not eng.valid_fy(fy):
            return _err("invalid_input", "financial_year must look like 2026-27.")
        start, end = eng.fy_range(fy)

        leaves = LeaveRequest.objects.filter(
            company=company, Employee_ID=code, is_active=True,
            from_date__gte=start, from_date__lte=end)

        policy = eng.get_wfh_policy(company)
        used = eng.wfh_quota_used(company, code, timezone.localdate())

        recent = list(leaves.order_by("-created_at", "-id")[:10])
        acts = eng.actions_map(company, "leave", [r.pk for r in recent])
        codes = {a.approver_code for lst in acts.values() for a in lst if a.approver_code}
        lookup = self._brief_lookup(codes)

        pending_for_me = ApprovalAction.objects.filter(
            company=company, approver_code=code, status="Pending").count()

        return _ok("my_leave_dashboard", "Leave dashboard fetched successfully.", {
            "financial_year": fy,
            "cards": {
                "total_requests": leaves.count(),
                "approved_leaves": leaves.filter(status="Approved").count(),
                "pending_approvals": leaves.filter(status="Pending").count(),
                "wfh_this_week": {
                    "used": used, "quota": policy.weekly_quota_days,
                    "remaining": max(policy.weekly_quota_days - used, 0),
                },
            },
            "balances": eng.balances_for(company, code, fy),
            "approvals_waiting_on_me": pending_for_me,
            "recent_requests": [eng.leave_row(r, lookup, acts.get(r.pk, []), request) for r in recent],
        })


# ============================================================
# MY LEAVES - CRUD
# ============================================================

class MyLeaveListCreateView(EmployeeLeaveBase):
    """
    GET  /employee/leave/leaves/?status=&financial_year=&leave_type=
    POST /employee/leave/leaves/
         {"leave_type":"Casual Leave","from_date":"2026-10-20","to_date":"2026-10-21","reason":"..."}
    """

    def get(self, request):
        company, code = self.company, self.me.employee_code
        qs = LeaveRequest.objects.filter(company=company, Employee_ID=code, is_active=True)
        p = request.query_params
        if p.get("status"):
            qs = qs.filter(status__iexact=p["status"].strip())
        if p.get("leave_type"):
            qs = qs.filter(leave_type__iexact=p["leave_type"].strip())
        if p.get("financial_year"):
            if not eng.valid_fy(p["financial_year"]):
                return _err("invalid_input", "financial_year must look like 2026-27.")
            s, e = eng.fy_range(p["financial_year"])
            qs = qs.filter(from_date__gte=s, from_date__lte=e)
        rows = list(qs.order_by("-created_at", "-id")[:500])
        acts = eng.actions_map(company, "leave", [r.pk for r in rows])
        codes = {a.approver_code for lst in acts.values() for a in lst if a.approver_code}
        lookup = self._brief_lookup(codes)
        return _ok("my_leave_list", "Your leave requests fetched successfully.",
                   [eng.leave_row(r, lookup, acts.get(r.pk, []), request) for r in rows])

    def post(self, request):
        company, me = self.company, self.me

        ser = SelfLeaveSerializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data

        days, error = _validate_leave_range(
            company, me.employee_code, d["leave_type"], d["from_date"], d["to_date"])
        if error is not None:
            return error

        actor = actor_label(me)
        with transaction.atomic():
            leave = LeaveRequest.objects.create(
                company=company, Employee_ID=me.employee_code, Name=me.name,
                leave_type=d["leave_type"], from_date=d["from_date"], to_date=d["to_date"],
                total_days=Decimal(days), reason=d.get("reason"), status="Pending",
                created_by=actor, updated_by=actor)
            eng.create_approval_actions(company, "leave", leave, actor)

        return _ok("my_leave_created", "Leave request submitted for approval.",
                   _leave_with_pipeline(self, leave), http_status.HTTP_201_CREATED)


class MyLeaveDetailView(EmployeeLeaveBase):
    """GET / PUT / PATCH / DELETE /employee/leave/leaves/<id>/  (edit & delete: Pending only)"""

    def _get(self, pk):
        return LeaveRequest.objects.filter(
            company=self.company, Employee_ID=self.me.employee_code,
            is_active=True, pk=pk).first()

    def _nf(self):
        return _err("not_found", "Leave request not found.", http_status.HTTP_404_NOT_FOUND)

    def get(self, request, pk):
        leave = self._get(pk)
        if leave is None:
            return self._nf()
        return _ok("my_leave_detail", "Leave request fetched successfully.",
                   _leave_with_pipeline(self, leave))

    def _update(self, request, pk, partial):
        leave = self._get(pk)
        if leave is None:
            return self._nf()
        if leave.status != "Pending":
            return _err("only_pending_editable",
                        "Only a Pending leave can be edited. Cancel it and apply again.",
                        http_status.HTTP_409_CONFLICT)

        ser = SelfLeaveSerializer(leave, data=request.data, partial=partial)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data
        leave_type = d.get("leave_type", leave.leave_type)
        from_date = d.get("from_date", leave.from_date)
        to_date = d.get("to_date", leave.to_date)

        days, error = _validate_leave_range(
            self.company, leave.Employee_ID, leave_type, from_date, to_date,
            exclude_pk=leave.pk)
        if error is not None:
            return error

        leave.leave_type, leave.from_date, leave.to_date = leave_type, from_date, to_date
        leave.reason = d.get("reason", leave.reason)
        leave.total_days = Decimal(days)
        leave.updated_by = actor_label(self.me)
        leave.id_version = (leave.id_version or 1) + 1
        leave.save()
        return _ok("my_leave_updated", "Leave request updated.", _leave_with_pipeline(self, leave))

    def put(self, request, pk):
        return self._update(request, pk, False)

    def patch(self, request, pk):
        return self._update(request, pk, True)

    def delete(self, request, pk):
        leave = self._get(pk)
        if leave is None:
            return self._nf()
        if leave.status != "Pending":
            return _err("only_pending_deletable",
                        "Only a Pending leave can be deleted. Use cancel for approved leave.",
                        http_status.HTTP_409_CONFLICT)
        with transaction.atomic():
            ApprovalAction.objects.filter(
                company=self.company, request_type="leave", request_id=leave.pk).delete()
            leave.delete()
        return _ok("my_leave_deleted", "Leave request deleted.")


class MyLeaveCancelView(EmployeeLeaveBase):
    """POST /employee/leave/leaves/<id>/cancel/  - Pending, or Approved that has not started."""

    def post(self, request, pk):
        company = self.company
        leave = LeaveRequest.objects.filter(
            company=company, Employee_ID=self.me.employee_code, is_active=True, pk=pk).first()
        if leave is None:
            return _err("not_found", "Leave request not found.", http_status.HTTP_404_NOT_FOUND)

        if leave.status not in ("Pending", "Approved"):
            return _err("invalid_state", f"A {leave.status} leave cannot be cancelled.",
                        http_status.HTTP_409_CONFLICT)

        if leave.status == "Approved" and leave.from_date < timezone.localdate():
            return _err("already_started",
                        "This leave has already started. Contact HR to change it.",
                        http_status.HTTP_409_CONFLICT)

        actor = actor_label(self.me)
        with transaction.atomic():
            if leave.status == "Approved":
                revert_leave_attendance(leave, company)
            ApprovalAction.objects.filter(
                company=company, request_type="leave", request_id=leave.pk, status="Pending"
            ).update(status="Skipped")
            leave.status = "Cancelled"
            leave.updated_by = actor
            leave.id_version = (leave.id_version or 1) + 1
            leave.save()

        return _ok("my_leave_cancelled", "Leave request cancelled.",
                   _leave_with_pipeline(self, leave))


# ============================================================
# MY WFH - CRUD
# ============================================================

class MyWFHPolicyView(EmployeeLeaveBase):
    """GET /employee/leave/wfh/policy/  (+ my usage this week)"""

    def get(self, request):
        data = eng.wfh_policy_dict(self.company)
        used = eng.wfh_quota_used(self.company, self.me.employee_code, timezone.localdate())
        data["my_week"] = {
            "used": used, "quota": data["weekly_quota_days"],
            "remaining": max(data["weekly_quota_days"] - used, 0),
        }
        data["workflow"] = eng.workflow_chain(self.company, "wfh")
        return _ok("my_wfh_policy", "WFH policy fetched successfully.", data)


class MyWFHListCreateView(EmployeeLeaveBase):
    """
    GET  /employee/leave/wfh/?status=
    POST /employee/leave/wfh/   {"wfh_date":"2026-10-12","reason":"..."}
    """

    def get(self, request):
        company, code = self.company, self.me.employee_code
        qs = WFHRequest.objects.filter(company=company, Employee_ID=code, is_active=True)
        if request.query_params.get("status"):
            qs = qs.filter(status__iexact=request.query_params["status"].strip())
        rows = list(qs.order_by("-wfh_date", "-id")[:500])
        acts = eng.actions_map(company, "wfh", [r.pk for r in rows])
        codes = {a.approver_code for lst in acts.values() for a in lst if a.approver_code}
        lookup = self._brief_lookup(codes)
        return _ok("my_wfh_list", "Your WFH requests fetched successfully.",
                   [eng.wfh_row(r, lookup, acts.get(r.pk, []), request, company) for r in rows])

    def post(self, request):
        company, me = self.company, self.me
        ser = SelfWFHSerializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data

        _, notice, error = eng.validate_wfh(company, me.employee_code, d["wfh_date"])
        if error is not None:
            return error

        actor = actor_label(me)
        with transaction.atomic():
            wfh = WFHRequest.objects.create(
                company=company, Employee_ID=me.employee_code, Name=me.name,
                wfh_date=d["wfh_date"], reason=d.get("reason"), notice_hours=notice,
                status="Pending", created_by=actor, updated_by=actor)
            eng.create_approval_actions(company, "wfh", wfh, actor)

        return _ok("my_wfh_created", "WFH request submitted for approval.",
                   _wfh_with_pipeline(self, wfh), http_status.HTTP_201_CREATED)


class MyWFHDetailView(EmployeeLeaveBase):
    """GET / PUT / PATCH / DELETE /employee/leave/wfh/<id>/  (edit & delete: Pending only)"""

    def _get(self, pk):
        return WFHRequest.objects.filter(
            company=self.company, Employee_ID=self.me.employee_code,
            is_active=True, pk=pk).first()

    def _nf(self):
        return _err("not_found", "WFH request not found.", http_status.HTTP_404_NOT_FOUND)

    def get(self, request, pk):
        wfh = self._get(pk)
        if wfh is None:
            return self._nf()
        return _ok("my_wfh_detail", "WFH request fetched successfully.",
                   _wfh_with_pipeline(self, wfh))

    def _update(self, request, pk, partial):
        wfh = self._get(pk)
        if wfh is None:
            return self._nf()
        if wfh.status != "Pending":
            return _err("only_pending_editable", "Only a Pending WFH request can be edited.",
                        http_status.HTTP_409_CONFLICT)

        ser = SelfWFHSerializer(wfh, data=request.data, partial=partial)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data

        notice = wfh.notice_hours
        new_date = d.get("wfh_date", wfh.wfh_date)
        if new_date != wfh.wfh_date:
            _, notice, error = eng.validate_wfh(
                self.company, wfh.Employee_ID, new_date, exclude_pk=wfh.pk)
            if error is not None:
                return error

        wfh.wfh_date, wfh.notice_hours = new_date, notice
        wfh.reason = d.get("reason", wfh.reason)
        wfh.updated_by = actor_label(self.me)
        wfh.id_version = (wfh.id_version or 1) + 1
        wfh.save()
        return _ok("my_wfh_updated", "WFH request updated.", _wfh_with_pipeline(self, wfh))

    def put(self, request, pk):
        return self._update(request, pk, False)

    def patch(self, request, pk):
        return self._update(request, pk, True)

    def delete(self, request, pk):
        wfh = self._get(pk)
        if wfh is None:
            return self._nf()
        if wfh.status != "Pending":
            return _err("only_pending_deletable",
                        "Only a Pending WFH request can be deleted. Use cancel instead.",
                        http_status.HTTP_409_CONFLICT)
        with transaction.atomic():
            ApprovalAction.objects.filter(
                company=self.company, request_type="wfh", request_id=wfh.pk).delete()
            wfh.delete()
        return _ok("my_wfh_deleted", "WFH request deleted.")


class MyWFHCancelView(EmployeeLeaveBase):
    """POST /employee/leave/wfh/<id>/cancel/"""

    def post(self, request, pk):
        wfh = WFHRequest.objects.filter(
            company=self.company, Employee_ID=self.me.employee_code,
            is_active=True, pk=pk).first()
        if wfh is None:
            return _err("not_found", "WFH request not found.", http_status.HTTP_404_NOT_FOUND)
        if wfh.status not in ("Pending", "Approved"):
            return _err("invalid_state", f"A {wfh.status} WFH request cannot be cancelled.",
                        http_status.HTTP_409_CONFLICT)
        if wfh.status == "Approved" and wfh.wfh_date < timezone.localdate():
            return _err("already_started", "This WFH day has already passed.",
                        http_status.HTTP_409_CONFLICT)

        with transaction.atomic():
            ApprovalAction.objects.filter(
                company=self.company, request_type="wfh", request_id=wfh.pk, status="Pending"
            ).update(status="Skipped")
            wfh.status = "Cancelled"
            wfh.updated_by = actor_label(self.me)
            wfh.id_version = (wfh.id_version or 1) + 1
            wfh.save()
        return _ok("my_wfh_cancelled", "WFH request cancelled.", _wfh_with_pipeline(self, wfh))


# ============================================================
# BALANCES / CALENDAR / POLICIES / WORKFLOW (read-only)
# ============================================================

class MyLeaveBalancesView(EmployeeLeaveBase):
    """GET /employee/leave/balances/?financial_year=2026-27"""

    def get(self, request):
        fy = request.query_params.get("financial_year") or eng.financial_year()
        if not eng.valid_fy(fy):
            return _err("invalid_input", "financial_year must look like 2026-27.")
        policy = eng.get_wfh_policy(self.company)
        used = eng.wfh_quota_used(self.company, self.me.employee_code, timezone.localdate())
        return _ok("my_leave_balances", "Leave balances fetched successfully.", {
            "title": f"Leave Quotas & WFH Balances (FY {fy})",
            "financial_year": fy,
            "balances": eng.balances_for(self.company, self.me.employee_code, fy),
            "weekly_wfh_cap": {
                "quota_days": policy.weekly_quota_days, "used_this_week": used,
                "remaining_this_week": max(policy.weekly_quota_days - used, 0),
            },
        })


class MyLeaveCalendarView(EmployeeLeaveBase):
    """
    GET /employee/leave/calendar/?month=10&year=2026&scope=team|me
    team (default): colleagues' APPROVED leave / WFH (no reasons) + my own incl. pending
    me: only my own
    """

    def get(self, request):
        start, end, error = eng.parse_calendar_range(request.query_params)
        if error:
            return _err("invalid_input", error)

        scope = request.query_params.get("scope", "team")
        me = self.me.employee_code

        if scope == "me":
            days = eng.build_calendar(self.company, start, end, include_pending=True,
                                      only_employee=me, request=request)
        else:
            days = eng.build_calendar(self.company, start, end, include_pending=False,
                                      request=request, hide_reasons=True)
            mine = {d["date"]: d for d in eng.build_calendar(
                self.company, start, end, include_pending=True, only_employee=me,
                request=request)}
            # add my own pending items on top of the approved team view
            for d in days:
                for kind in ("on_leave", "wfh"):
                    have = {x["request_ref"] for x in d[kind]}
                    for x in mine[d["date"]][kind]:
                        if x["request_ref"] not in have:
                            d[kind].append(x)
                d["on_leave_count"], d["wfh_count"] = len(d["on_leave"]), len(d["wfh"])
                d["full_attendance"] = not (
                    d["on_leave"] or d["wfh"] or d["is_holiday"] or d["is_weekly_off"])

        return _ok("my_leave_calendar", "Leave calendar fetched successfully.", {
            "title": "Organization Leave & Absence Calendar",
            "start_date": start, "end_date": end, "scope": scope, "days": days,
        })


class MyPoliciesView(EmployeeLeaveBase):
    """GET /employee/leave/policies/"""

    def get(self, request):
        company = self.company
        eng.ensure_default_policies(company)
        from .leave_models import LeavePolicy
        pols = LeavePolicy.objects.filter(company=company, is_active=True)
        return _ok("my_policies", "Policies fetched successfully.", {
            "title": "Leave & Remote Work Policy Framework",
            "policies": eng.policy_framework(company),
            "leave_types": [eng.leave_policy_dict(p) for p in pols],
            "wfh": eng.wfh_policy_dict(company),
        })


class MyWorkflowView(EmployeeLeaveBase):
    """GET /employee/leave/workflow/?request_type=leave|wfh"""

    def get(self, request):
        rtype = request.query_params.get("request_type")
        if rtype and rtype not in ("leave", "wfh"):
            return _err("invalid_input", "request_type must be leave or wfh.")
        types = [rtype] if rtype else ["leave", "wfh"]
        return _ok("my_workflow", "Approval workflow fetched successfully.", {
            "title": "Automated Multi-Tier Approval Chain",
            "chains": {t: eng.workflow_chain(self.company, t) for t in types},
        })


# ============================================================
# MANAGER / HOD APPROVALS
# ============================================================

class MyApprovalsPendingView(EmployeeLeaveBase):
    """
    GET /employee/leave/approvals/pending/
    Requests whose CURRENT tier is assigned to me (as reporting manager / HOD).
    """

    def get(self, request):
        company, code = self.company, self.me.employee_code
        mine = ApprovalAction.objects.filter(
            company=company, approver_code=code, status="Pending"
        ).order_by("created_at")

        out = []
        for a in mine:
            model = LeaveRequest if a.request_type == "leave" else WFHRequest
            req = model.objects.filter(
                company=company, pk=a.request_id, is_active=True, status="Pending").first()
            if req is None:
                continue
            current = eng.current_pending_action(company, a.request_type, req)
            if current is None or current.pk != a.pk:
                continue          # an earlier tier is still pending

            acts = eng.actions_map(company, a.request_type, [req.pk]).get(req.pk, [])
            codes = {req.Employee_ID} | {x.approver_code for x in acts if x.approver_code}
            lookup = employee_map(company, codes)
            row = (eng.leave_row(req, lookup, acts, request) if a.request_type == "leave"
                   else eng.wfh_row(req, lookup, acts, request, company))
            row["request_type"] = a.request_type
            row["approval_id"] = a.pk
            out.append(row)

        return _ok("my_pending_approvals", "Pending approvals fetched successfully.", out)


class MyApprovalDecisionView(EmployeeLeaveBase):
    """
    POST /employee/leave/approvals/<approval_id>/approve/   {"review_comment": ""}
    POST /employee/leave/approvals/<approval_id>/reject/
    """

    decision = "approve"

    def post(self, request, approval_id):
        company = self.company
        action = ApprovalAction.objects.filter(company=company, pk=approval_id).first()
        if action is None or action.approver_code != self.me.employee_code:
            return _err("not_found", "Approval not found.", http_status.HTTP_404_NOT_FOUND)

        model = LeaveRequest if action.request_type == "leave" else WFHRequest
        req = model.objects.filter(company=company, pk=action.request_id, is_active=True).first()
        if req is None:
            return _err("not_found", "Request not found.", http_status.HTTP_404_NOT_FOUND)

        current = eng.current_pending_action(company, action.request_type, req)
        if req.status != "Pending" or current is None or current.pk != action.pk:
            return _err("not_current_tier", "This tier is not waiting for your action.",
                        http_status.HTTP_409_CONFLICT)

        if self.decision == "approve" and action.request_type == "leave":
            err = eng.check_leave_balance(
                company, req.Employee_ID, req.leave_type, req.from_date,
                req.total_days, exclude_pk=req.pk)
            if err is not None:
                return err

        with transaction.atomic():
            extra, error = eng.process_tier(
                self.me, company, action.request_type, req, self.decision,
                request.data.get("review_comment"))
        if error is not None:
            return error

        req.refresh_from_db()
        row = (_leave_with_pipeline(self, req) if action.request_type == "leave"
               else _wfh_with_pipeline(self, req))
        msg = f"Request {extra['final'].lower()}." if extra.get("final") else "Tier approved."
        return _ok(f"my_tier_{self.decision}", msg, {**row, **extra})


class MyApprovalRejectView(MyApprovalDecisionView):
    decision = "reject"

