# ============================================================
# ADDITIVE: Exit Management, Clearances & F&F - Admin / HR API
# ------------------------------------------------------------
# Mounted at /api/exit/   (see People/exit_urls.py)
# Auth: Company Admin token, or an employee whose role has the
#       existing "employees" checkboxes (can_view / create / edit /
#       delete _employees) - exactly like the rest of the People API.
#
# Screen tab                 -> endpoint(s)
# -----------------------------------------------------------
# Exit Dashboard             -> GET  dashboard/ , GET meta/
# Resignations & Notice      -> CRUD resignations/
#                               POST resignations/<id>/accept | reject | withdraw | complete
# Departmental Clearances    -> GET  clearances/ , clearances/<exit_id>/
#                               POST clearances/<exit_id>/approve | reject | reset
#                               POST clearances/<exit_id>/items/ ,
#                               PATCH|DELETE clearances/<exit_id>/items/<department>/
# Full & Final (F&F)         -> GET  fnf/ , fnf/<id>/ , fnf/<id>/statement/
#                               POST fnf/generate/ , fnf/preview/
#                               PATCH fnf/<id>/ , POST fnf/<id>/recalculate|approve|mark-paid
#                               DELETE fnf/<id>/
# Exit Interviews            -> CRUD interviews/ , GET interviews/summary/
# Relieving & Experience     -> /letters/  = the EXISTING letter vault (list, generate,
#                               pdf, revoke ...). Relieving / experience letters need
#                               100% clearance (or force=true).
# ============================================================

from datetime import timedelta

from django.db import transaction
from django.db.models import Avg, Count, Q
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.views import APIView
from rest_framework.viewsets import ViewSet

from . import exit_engine as en
from .common import (CrudBase, PeopleAuthMixin, emp_by_code, err, iso, next_seq, ok, paginate, to_bool, to_date,
                     to_decimal, to_int)
from .exit_models import ExitFnF, ExitInterview, ExitResignationDetail
from .letters import issue_letter
from .models import ExitClearance
from .views_vault import GeneratedLetterViewSet


def case_qs(company):
    return ExitClearance.objects.filter(company=company, is_active=True).select_related(
        "employee", "employee__department", "detail", "detail__handover_to")


def find_case(company, pk=None, employee_code=None, include_withdrawn=False):
    qs = case_qs(company)
    if not include_withdrawn:
        qs = qs.exclude(status="Withdrawn")
    if pk is not None:
        return qs.filter(pk=pk).first() if str(pk).isdigit() else None
    if employee_code:
        return qs.filter(employee__employee_code=employee_code).order_by("-id").first()
    return None


def conflict(ex):
    return err("CONFLICT", str(ex), 409)


# ============================================================
# META + DASHBOARD
# ============================================================

class ExitMetaView(PeopleAuthMixin, APIView):
    """GET /api/exit/meta/ - dropdown values for the screens."""

    def get(self, request):
        return ok("EXIT_META", "Exit metadata.", {
            "separation_types": [c for c, _ in ExitResignationDetail.SEPARATION],
            "approval_statuses": [c for c, _ in ExitResignationDetail.APPROVAL],
            "exit_statuses": [c for c, _ in ExitClearance.STATUS],
            "clearance_departments": [{"department": d, "title": t} for d, t in en.DEFAULT_DEPARTMENTS]
                                     + [{"department": en.MANAGER_DEPARTMENT[0], "title": en.MANAGER_DEPARTMENT[1],
                                         "optional": True}],
            "clearance_item_statuses": ["Pending", "Approved", "Rejected"],
            "fnf_statuses": [c for c, _ in ExitFnF.STATUS],
            "interview_statuses": [c for c, _ in ExitInterview.STATUS],
            "interview_modes": [c for c, _ in ExitInterview.MODE],
            "leaving_reasons": [c for c, _ in ExitInterview.REASONS],
            "exit_letter_types": list(en.EXIT_LETTER_TYPES),
            "default_notice_days": en.DEFAULT_NOTICE_DAYS,
        })


class ExitDashboardView(PeopleAuthMixin, APIView):
    """GET /api/exit/dashboard/ - the 4 cards + Active Resignation & Offboarding Pipeline."""

    def get(self, request):
        return ok("EXIT_DASHBOARD", "Exit dashboard.", en.dashboard(self.company(), request))


# ============================================================
# RESIGNATIONS & NOTICE
# ============================================================

class ResignationViewSet(CrudBase):
    """
    GET    /api/exit/resignations/                ?status= ?approval_status= ?separation_type= ?employee_code=
                                                  ?active=true ?from= ?to= ?search= ?page= ?page_size=
    POST   /api/exit/resignations/                "Initiate Resignation" (HR / Admin)
           {employee_code, resignation_date?, last_working_day?, notice_period_days?, notice_waived_days?,
            reason?, separation_type?, handover_to_code?, handover_notes?, hr_remarks?,
            clearance_departments? [..], include_manager_clearance?, submit_for_approval?}
    GET    /api/exit/resignations/<id>/
    PATCH|PUT|POST(update/) /<id>/                edit dates, notice, reason, handover, remarks
    DELETE|POST(delete/)    /<id>/                only rejected / submitted / withdrawn cases
    POST   /<id>/accept/    {last_working_day?, notice_waived_days?, hr_remarks?}
    POST   /<id>/reject/    {reason}
    POST   /<id>/withdraw/  {reason?}
    POST   /<id>/complete/  {force?, skip_fnf?}   needs 100% clearance + approved F&F
    """

    code = "RESIGNATION"
    search_fields = ("employee__name", "employee__employee_code", "reason", "employee__Designation")
    permission_action_map = {"accept": "edit", "reject": "edit", "withdraw": "edit", "complete": "edit"}

    def scope(self):
        return case_qs(self.company())

    def build(self, x):
        return en.resignation_row(x, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("employee_code"):
            qs = qs.filter(employee__employee_code=p["employee_code"])
        if p.get("approval_status"):
            v = p["approval_status"]
            cond = Q(detail__approval_status=v)
            if v == "Accepted":                      # legacy cases (no detail row) count as accepted
                cond |= Q(detail__isnull=True)
            qs = qs.filter(cond)
        if p.get("separation_type"):
            qs = qs.filter(detail__separation_type=p["separation_type"])
        if to_bool(p.get("active")):
            qs = qs.filter(status__in=en.ACTIVE)
        try:
            if p.get("from"):
                qs = qs.filter(resignation_date__gte=to_date(p["from"]))
            if p.get("to"):
                qs = qs.filter(resignation_date__lte=to_date(p["to"]))
        except ValueError:
            pass
        return qs

    # ---- create ("Initiate Resignation") ----
    @transaction.atomic
    def create(self, request):
        d, actor, company = request.data, self.actor(), self.company()
        try:
            emp = emp_by_code(company, d.get("employee_code"))
            if ExitClearance.objects.filter(employee=emp, is_active=True, status__in=en.ACTIVE).exists():
                return err("EXISTS", "Exit is already in progress for this employee.", 409)

            res = to_date(d.get("resignation_date")) or timezone.localdate()
            notice = to_int(d.get("notice_period_days"), en.parse_notice_days(emp))
            waived = to_int(d.get("notice_waived_days"), 0)
            if notice < 0 or waived < 0 or waived > notice:
                raise ValueError("notice_waived_days must be between 0 and notice_period_days.")
            lwd = to_date(d.get("last_working_day")) or res + timedelta(days=notice - waived)
            if lwd < res:
                raise ValueError("last_working_day cannot be before resignation_date.")

            sep = d.get("separation_type") or "Resignation"
            if sep not in dict(ExitResignationDetail.SEPARATION):
                raise ValueError("Invalid separation_type. Allowed: "
                                 + ", ".join(dict(ExitResignationDetail.SEPARATION)))
            handover = emp_by_code(company, d.get("handover_to_code"), required=False)
            if handover is not None and handover.pk == emp.pk:
                raise ValueError("handover_to_code cannot be the resigning employee.")
            deps = d.get("clearance_departments")
            if deps is not None and (not isinstance(deps, list) or not deps
                                     or not all(isinstance(i, str) and i.strip() for i in deps)
                                     or len(set(deps)) != len(deps)):
                raise ValueError("clearance_departments must be a non-empty list of unique names.")
        except ValueError as ex:
            return err("VALIDATION", str(ex))

        submit = to_bool(d.get("submit_for_approval"))
        x = ExitClearance.objects.create(
            company=company, employee=emp, resignation_date=res, last_working_day=lwd, reason=d.get("reason"),
            items=en.default_items(emp, deps, to_bool(d.get("include_manager_clearance"))),
            status="Initiated", created_by=actor, updated_by=actor)
        ExitResignationDetail.objects.create(
            company=company, exit=x, separation_type=sep, notice_period_days=notice, notice_waived_days=waived,
            approval_status="Submitted" if submit else "Accepted", requested_by="HR",
            accepted_by=None if submit else actor, accepted_on=None if submit else timezone.localdate(),
            handover_to=handover, handover_notes=d.get("handover_notes"), hr_remarks=d.get("hr_remarks"),
            created_by=actor, updated_by=actor)
        if not submit:
            en.apply_exit_effects(x, actor)
        x = self.scope().get(pk=x.pk)
        return ok("RESIGNATION_CREATED", "Resignation recorded." if not submit else "Resignation submitted for approval.",
                  self.build(x), 201)

    # ---- update ----
    @transaction.atomic
    def partial_update(self, request, pk=None):
        x = self.scope().filter(pk=pk).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if x.status in ("Completed", "Withdrawn"):
            return err("CONFLICT", f"A {x.status.lower()} exit cannot be edited.", 409)
        d, actor = request.data, self.actor()
        det = en.get_detail(x, actor=actor)
        try:
            if "resignation_date" in d:
                x.resignation_date = to_date(d["resignation_date"]) or x.resignation_date
            if "last_working_day" in d:
                x.last_working_day = to_date(d["last_working_day"])
            if "reason" in d:
                x.reason = d["reason"]
            if "notice_period_days" in d:
                det.notice_period_days = to_int(d["notice_period_days"], det.notice_period_days)
            if "notice_waived_days" in d:
                det.notice_waived_days = to_int(d["notice_waived_days"], 0)
            if det.notice_waived_days > det.notice_period_days:
                raise ValueError("notice_waived_days cannot exceed notice_period_days.")
            if "separation_type" in d:
                if d["separation_type"] not in dict(ExitResignationDetail.SEPARATION):
                    raise ValueError("Invalid separation_type.")
                det.separation_type = d["separation_type"]
            if "handover_to_code" in d:
                h = emp_by_code(x.company, d["handover_to_code"] or None, required=False)
                if h is not None and h.pk == x.employee_id:
                    raise ValueError("handover_to_code cannot be the resigning employee.")
                det.handover_to = h
            for f in ("handover_notes", "hr_remarks"):
                if f in d:
                    setattr(det, f, d[f])
            if x.resignation_date and x.last_working_day and x.last_working_day < x.resignation_date:
                raise ValueError("last_working_day cannot be before resignation_date.")
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        x.updated_by = det.updated_by = actor
        x.save()
        det.save()
        if det.approval_status == "Accepted":          # keep the profile fields in sync
            e = x.employee
            e.Resignation_Date, e.Last_Working_Day = str(x.resignation_date), str(x.last_working_day or "")
            e.save()
        return ok("RESIGNATION_UPDATED", "Updated.", self.build(self.scope().get(pk=x.pk)))

    update = partial_update

    # ---- delete ----
    def destroy(self, request, pk=None):
        x = self.scope().filter(pk=pk).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        d = en.detail_or_virtual(x)
        if not (x.status == "Withdrawn" or d.approval_status in ("Submitted", "Rejected")):
            return err("CONFLICT", "Only withdrawn, rejected or not-yet-accepted resignations can be deleted. "
                                   "Withdraw it first.", 409)
        x.is_active, x.updated_by = False, self.actor()
        x.save()
        return ok("RESIGNATION_DELETED", "Deleted.", {"id": x.id})

    # ---- workflow ----
    @action(detail=True, methods=["post"])
    @transaction.atomic
    def accept(self, request, pk=None):
        x = self.scope().filter(pk=pk).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        det = en.get_detail(x)
        if x.status not in en.ACTIVE or det.approval_status != "Submitted":
            return err("CONFLICT", "Only a submitted resignation can be accepted.", 409)
        d, actor = request.data, self.actor()
        try:
            if d.get("last_working_day"):
                x.last_working_day = to_date(d["last_working_day"])
            if "notice_waived_days" in d:
                det.notice_waived_days = to_int(d["notice_waived_days"], 0)
            if det.notice_waived_days > det.notice_period_days:
                raise ValueError("notice_waived_days cannot exceed notice_period_days.")
            if x.last_working_day and x.last_working_day < x.resignation_date:
                raise ValueError("last_working_day cannot be before resignation_date.")
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        det.approval_status, det.accepted_by, det.accepted_on = "Accepted", actor, timezone.localdate()
        det.rejection_reason = None
        if d.get("hr_remarks"):
            det.hr_remarks = d["hr_remarks"]
        det.updated_by = x.updated_by = actor
        x.status = "In Progress"
        x.save()
        det.save()
        en.apply_exit_effects(x, actor)
        return ok("RESIGNATION_ACCEPTED", "Resignation accepted; notice period started.",
                  self.build(self.scope().get(pk=x.pk)))

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def reject(self, request, pk=None):
        x = self.scope().filter(pk=pk).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        det = en.get_detail(x)
        if x.status not in en.ACTIVE or det.approval_status != "Submitted":
            return err("CONFLICT", "Only a submitted resignation can be rejected.", 409)
        reason = str(request.data.get("reason") or "").strip()
        if not reason:
            return err("VALIDATION", "reason is required.", errors={"reason": ["This field is required."]})
        actor = self.actor()
        det.approval_status, det.rejection_reason = "Rejected", reason
        det.updated_by = x.updated_by = actor
        x.status = "Withdrawn"
        x.save()
        det.save()
        return ok("RESIGNATION_REJECTED", "Resignation rejected.", self.build(self.scope().get(pk=x.pk)))

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def withdraw(self, request, pk=None):
        x = self.scope().filter(pk=pk).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if x.status not in en.ACTIVE:
            return err("CONFLICT", f"This exit is already {x.status}.", 409)
        det, actor = en.get_detail(x), self.actor()
        was_accepted = det.approval_status == "Accepted"
        x.status, x.updated_by = "Withdrawn", actor
        x.save()
        if request.data.get("reason"):
            det.hr_remarks = request.data["reason"]
            det.save()
        if was_accepted:
            en.revert_exit_effects(x, actor)
        return ok("RESIGNATION_WITHDRAWN", "Resignation withdrawn.", self.build(self.scope().get(pk=x.pk)))

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def complete(self, request, pk=None):
        x = self.scope().filter(pk=pk).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        det = en.get_detail(x)
        if x.status not in en.ACTIVE or det.approval_status != "Accepted":
            return err("CONFLICT", "Only an accepted, active exit can be completed.", 409)
        force = to_bool(request.data.get("force"))
        if not en.all_cleared(x) and not force:
            return err("NOT_CLEARED", "All departmental clearances must be approved (or pass force=true).", 409)
        f = en.fnf_of(x)
        if not force and not to_bool(request.data.get("skip_fnf")) and (f is None or f.status not in ("Approved", "Paid")):
            return err("FNF_PENDING", "The F&F statement must be approved first (or pass skip_fnf=true).", 409)
        actor = self.actor()
        x.status, x.updated_by = "Completed", actor
        x.save()
        en.complete_exit_effects(x, actor)
        return ok("EXIT_COMPLETED", "Exit completed; login disabled.", self.build(self.scope().get(pk=x.pk)))


# ============================================================
# DEPARTMENTAL CLEARANCES
# ============================================================

class ClearanceViewSet(PeopleAuthMixin, ViewSet):
    """
    GET    /api/exit/clearances/                      ?employee_code= ?status= ?include_closed=true
    GET    /api/exit/clearances/<exit_id>/            the "Departmental Offboarding Clearances" card
    POST   /api/exit/clearances/<exit_id>/approve/    {department, remarks?, force?}   ("Approve IT")
    POST   /api/exit/clearances/<exit_id>/reject/     {department, remarks}
    POST   /api/exit/clearances/<exit_id>/reset/      {department}                     back to Pending
    POST   /api/exit/clearances/<exit_id>/items/      {department, title?, approver_code?}   add a department
    PATCH  /api/exit/clearances/<exit_id>/items/<department>/   {title?, remarks?, approver_code?}
    DELETE /api/exit/clearances/<exit_id>/items/<department>/
    IT / Admin cannot be approved while assets are still allocated to the employee (force=true overrides).
    """

    permission_action_map = {"approve": "edit", "reject": "edit", "reset": "edit", "add_item": "edit"}

    def _case(self, pk):
        return find_case(self.company(), pk)

    def list(self, request):
        p = request.query_params
        qs = case_qs(self.company()).exclude(status="Withdrawn")
        if not to_bool(p.get("include_closed")):
            qs = qs.filter(status__in=en.ACTIVE)
        if p.get("status"):
            qs = qs.filter(status=p["status"])
        if p.get("employee_code"):
            qs = qs.filter(employee__employee_code=p["employee_code"])
        rows, meta = paginate(request, qs.order_by("-id"), lambda x: en.clearance_detail(x, request))
        return ok("CLEARANCE_LIST", "Clearances.", rows, meta=meta)

    def retrieve(self, request, pk=None):
        x = self._case(pk)
        if x is None:
            return err("NOT_FOUND", "Exit case not found.", 404)
        return ok("CLEARANCE_DETAIL", "Clearances.", en.clearance_detail(x, request))

    def _set(self, request, pk, status):
        x = self._case(pk)
        if x is None:
            return err("NOT_FOUND", "Exit case not found.", 404)
        d = request.data
        try:
            en.set_item_status(x, d.get("department"), status, d.get("remarks"), self.actor(),
                               to_bool(d.get("force")))
        except en.ExitConflict as ex:
            return conflict(ex)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        return ok(f"CLEARANCE_{status.upper()}", f"{d.get('department')} clearance {status.lower()}.",
                  en.clearance_detail(self._case(pk), request))

    @action(detail=True, methods=["post"])
    def approve(self, request, pk=None):
        return self._set(request, pk, "Approved")

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        return self._set(request, pk, "Rejected")

    @action(detail=True, methods=["post"])
    def reset(self, request, pk=None):
        return self._set(request, pk, "Pending")

    @action(detail=True, methods=["post"], url_path="items")
    def add_item(self, request, pk=None):
        x = self._case(pk)
        if x is None:
            return err("NOT_FOUND", "Exit case not found.", 404)
        d = request.data
        dept = str(d.get("department") or "").strip()
        if not dept:
            return err("VALIDATION", "department is required.", errors={"department": ["This field is required."]})
        try:
            en.ensure_accepted(x)
            appr = emp_by_code(x.company, d.get("approver_code"), required=False)
        except en.ExitConflict as ex:
            return conflict(ex)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        items = list(x.items or [])
        if any(i.get("department", "").lower() == dept.lower() for i in items):
            return err("EXISTS", f"{dept} clearance already exists.", 409)
        items.append({"department": dept, "title": d.get("title") or f"{dept} clearance", "cleared": False,
                      "cleared_by": None, "cleared_at": None, "status": "Pending", "remarks": d.get("remarks"),
                      "approver_code": appr.employee_code if appr else None})
        x.items, x.updated_by = items, self.actor()
        en.recompute_status(x)
        x.save()
        return ok("CLEARANCE_ITEM_ADDED", "Clearance department added.", en.clearance_detail(x, request), 201)

    @action(detail=True, methods=["patch", "put", "post", "delete"], url_path=r"items/(?P<dept>[^/.]+)")
    def item_detail(self, request, pk=None, dept=None):
        x = self._case(pk)
        if x is None:
            return err("NOT_FOUND", "Exit case not found.", 404)
        try:
            en.ensure_accepted(x)
        except en.ExitConflict as ex:
            return conflict(ex)
        items = list(x.items or [])
        hit = next((i for i in items if i.get("department", "").lower() == str(dept).lower()), None)
        if hit is None:
            return err("NOT_FOUND", f"Clearance department '{dept}' not found.", 404)
        if request.method == "DELETE":
            if len(items) == 1:
                return err("CONFLICT", "At least one clearance department is required.", 409)
            items.remove(hit)
            x.items, x.updated_by = items, self.actor()
            en.recompute_status(x)
            x.save()
            return ok("CLEARANCE_ITEM_DELETED", "Clearance department removed.", en.clearance_detail(x, request))
        d = request.data
        try:
            if "approver_code" in d:
                a = emp_by_code(x.company, d["approver_code"] or None, required=False)
                hit["approver_code"] = a.employee_code if a else None
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        for f in ("title", "remarks"):
            if f in d:
                hit[f] = d[f]
        x.items, x.updated_by = items, self.actor()
        x.save()
        return ok("CLEARANCE_ITEM_UPDATED", "Clearance department updated.", en.clearance_detail(x, request))


# ============================================================
# FULL & FINAL (F&F)
# ============================================================

MONEY = ("pending_salary_days", "pending_salary", "leave_encashment_days", "leave_encashment", "gratuity", "bonus",
         "other_earnings", "notice_shortfall_days", "notice_recovery", "asset_recovery", "advance_recovery",
         "tds_deduction", "other_deductions")


class FnFViewSet(PeopleAuthMixin, ViewSet):
    """
    GET    /api/exit/fnf/                          ?exit_id= ?status= ?has_statement=true|false
                                                   every active exit + its statement (or null -> "Generate F&F Statement")
    POST   /api/exit/fnf/generate/                 {exit_id, overrides?{bonus, other_earnings, asset_recovery,
                                                    advance_recovery, tds_deduction, other_deductions, unpaid_days,
                                                    include_gratuity, ...}, remarks?}
    POST   /api/exit/fnf/preview/                  same payload, nothing saved (the calculator)
    GET    /api/exit/fnf/<id>/
    GET    /api/exit/fnf/<id>/statement/           printable statement
    PATCH|PUT|POST(update/) /<id>/                 edit any amount / remarks / status Draft|Calculated; totals recomputed
    POST   /api/exit/fnf/<id>/recalculate/         re-run the calculator (manual fields are kept)
    POST   /api/exit/fnf/<id>/approve/             {force?}   needs 100% clearance
    POST   /api/exit/fnf/<id>/mark-paid/           {paid_on?, payment_mode?, payment_reference?}
    DELETE|POST(delete/) /<id>/                    Draft / Calculated only
    """

    permission_action_map = {"generate": "create", "preview": "view", "recalculate": "edit", "approve": "edit",
                             "mark_paid": "edit", "statement": "view"}

    def _fnf(self, pk):
        if not str(pk).isdigit():
            return None
        return (ExitFnF.objects.filter(company=self.company(), pk=pk, is_active=True)
                .select_related("exit", "exit__employee", "exit__employee__department", "exit__detail").first())

    def _row(self, f, request):
        x = f.exit
        return {**en.fnf_row(f), "exit_id": x.id, "employee": en.emp_brief(x.employee, request),
                "resignation_date": iso(x.resignation_date), "last_working_day": iso(x.last_working_day),
                "clearance_status": en.clearance_label(x)}

    # ---- list ----
    def list(self, request):
        p = request.query_params
        qs = case_qs(self.company()).exclude(status="Withdrawn").filter(
            Q(detail__approval_status="Accepted") | Q(detail__isnull=True))
        if p.get("exit_id"):
            qs = qs.filter(pk=p["exit_id"]) if str(p["exit_id"]).isdigit() else qs.none()
        if p.get("status"):
            qs = qs.filter(fnf__status=p["status"])
        if p.get("has_statement"):
            qs = qs.filter(fnf__isnull=not to_bool(p["has_statement"]))

        def build(x):
            f = en.fnf_of(x)
            return {"exit_id": x.id, "employee": en.emp_brief(x.employee, request),
                    "heading": f"Employee: {x.employee.name} ({x.employee.employee_code}) • Resignation: {iso(x.resignation_date)}",
                    "resignation_date": iso(x.resignation_date), "last_working_day": iso(x.last_working_day),
                    "exit_status": x.status, "clearance_status": en.clearance_label(x),
                    "statement": en.fnf_row(f, with_components=False)}
        rows, meta = paginate(request, qs.order_by("-id"), build)
        return ok("FNF_LIST", "F&F statements.", rows, meta=meta)

    def retrieve(self, request, pk=None):
        f = self._fnf(pk)
        if f is None:
            return err("NOT_FOUND", "F&F statement not found.", 404)
        return ok("FNF_DETAIL", "F&F statement.", self._row(f, request))

    # ---- calculator ----
    def _overrides(self, d):
        ov = dict(d.get("overrides") or {})
        for k in en.MANUAL_FIELDS:
            if k in d and k not in ov:
                ov[k] = d[k]
        for k in en.AUTO_OVERRIDE_FIELDS + ("unpaid_days", "include_gratuity"):
            if k in d and k not in ov:
                ov[k] = d[k]
        for k, v in list(ov.items()):
            if k == "include_gratuity":
                continue
            to_decimal(v)                       # ValueError on junk
            if to_decimal(v, 0) < 0:
                raise ValueError(f"{k} cannot be negative.")
        return ov

    def _case_for(self, d):
        x = find_case(self.company(), d.get("exit_id")) if d.get("exit_id") else \
            find_case(self.company(), employee_code=d.get("employee_code"))
        return x

    @action(detail=False, methods=["post"])
    def preview(self, request):
        x = self._case_for(request.data)
        if x is None:
            return err("NOT_FOUND", "Exit case not found (send exit_id).", 404)
        try:
            r = en.calc_fnf(x, self._overrides(request.data))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        f = ExitFnF(**r["fields"], components=r["components"], status="Draft", statement_no="(preview)")
        return ok("FNF_PREVIEW", "F&F preview (not saved).", en.fnf_row(f))

    @action(detail=False, methods=["post"])
    @transaction.atomic
    def generate(self, request):
        d, actor = request.data, self.actor()
        x = self._case_for(d)
        if x is None:
            return err("NOT_FOUND", "Exit case not found (send exit_id).", 404)
        try:
            en.ensure_accepted(x) if x.status in en.ACTIVE else None
            if x.status not in en.ACTIVE and x.status != "Completed":
                raise en.ExitConflict(f"This exit is {x.status}.")
        except en.ExitConflict as ex:
            return conflict(ex)
        existing = en.fnf_of(x)
        if existing and existing.status in ("Approved", "Paid"):
            return err("CONFLICT", f"The F&F statement is already {existing.status}.", 409)
        try:
            ov = {k: getattr(existing, k) for k in en.MANUAL_FIELDS} if existing else {}
            ov.update(self._overrides(d))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        r = en.calc_fnf(x, ov)
        if existing:
            for k, v in r["fields"].items():
                setattr(existing, k, v)
            existing.components, existing.status, existing.updated_by = r["components"], "Calculated", actor
            if "remarks" in d:
                existing.remarks = d["remarks"]
            existing.save()
            f, code, status = existing, "FNF_RECALCULATED", 200
        else:
            f = ExitFnF.objects.create(
                company=x.company, exit=x, status="Calculated", components=r["components"], remarks=d.get("remarks"),
                statement_no=next_seq(ExitFnF, x.company, "statement_no", f"FNF-{timezone.localdate().year}-"),
                created_by=actor, updated_by=actor, **r["fields"])
            code, status = "FNF_GENERATED", 201
        return ok(code, "F&F statement generated.", self._row(self._fnf(f.pk), request), status)

    # ---- edit / recalc ----
    @transaction.atomic
    def partial_update(self, request, pk=None):
        f = self._fnf(pk)
        if f is None:
            return err("NOT_FOUND", "F&F statement not found.", 404)
        if f.status in ("Approved", "Paid"):
            return err("CONFLICT", f"An {f.status} statement is locked.", 409)
        d = request.data
        try:
            for k in MONEY:
                if k in d:
                    v = to_decimal(d[k], 0)
                    if v < 0:
                        raise ValueError(f"{k} cannot be negative.")
                    setattr(f, k, en.q2(v))
            if "status" in d:
                if d["status"] not in ("Draft", "Calculated"):
                    raise ValueError("status can only be set to Draft or Calculated here.")
                f.status = d["status"]
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        if "remarks" in d:
            f.remarks = d["remarks"]
        for k, v in en.totals({k: getattr(f, k) for k in MONEY}).items():
            setattr(f, k, v)
        f.updated_by = self.actor()
        f.save()
        return ok("FNF_UPDATED", "F&F statement updated.", self._row(self._fnf(pk), request))

    update = partial_update

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def recalculate(self, request, pk=None):
        f = self._fnf(pk)
        if f is None:
            return err("NOT_FOUND", "F&F statement not found.", 404)
        if f.status in ("Approved", "Paid"):
            return err("CONFLICT", f"An {f.status} statement is locked.", 409)
        try:
            ov = {k: getattr(f, k) for k in en.MANUAL_FIELDS}
            ov.update(self._overrides(request.data))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        r = en.calc_fnf(f.exit, ov)
        for k, v in r["fields"].items():
            setattr(f, k, v)
        f.components, f.status, f.updated_by = r["components"], "Calculated", self.actor()
        f.save()
        return ok("FNF_RECALCULATED", "F&F recalculated.", self._row(self._fnf(pk), request))

    # ---- approve / pay ----
    @action(detail=True, methods=["post"])
    def approve(self, request, pk=None):
        f = self._fnf(pk)
        if f is None:
            return err("NOT_FOUND", "F&F statement not found.", 404)
        if f.status != "Calculated":
            return err("CONFLICT", "Only a Calculated statement can be approved.", 409)
        if not en.all_cleared(f.exit) and not to_bool(request.data.get("force")):
            return err("NOT_CLEARED", "All departmental clearances must be approved first (or pass force=true).", 409)
        f.status, f.approved_by, f.approved_on, f.updated_by = "Approved", self.actor(), timezone.now(), self.actor()
        f.save()
        return ok("FNF_APPROVED", "F&F statement approved.", self._row(self._fnf(pk), request))

    @action(detail=True, methods=["post"], url_path="mark-paid")
    def mark_paid(self, request, pk=None):
        f = self._fnf(pk)
        if f is None:
            return err("NOT_FOUND", "F&F statement not found.", 404)
        if f.status != "Approved":
            return err("CONFLICT", "Only an Approved statement can be marked as paid.", 409)
        d = request.data
        try:
            f.paid_on = to_date(d.get("paid_on")) or timezone.localdate()
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        f.payment_mode, f.payment_reference = d.get("payment_mode"), d.get("payment_reference")
        f.status, f.updated_by = "Paid", self.actor()
        f.save()
        return ok("FNF_PAID", "F&F marked as paid.", self._row(self._fnf(pk), request))

    @action(detail=True, methods=["get"])
    def statement(self, request, pk=None):
        f = self._fnf(pk)
        if f is None:
            return err("NOT_FOUND", "F&F statement not found.", 404)
        x, e, r = f.exit, f.exit.employee, en.fnf_row(f)
        earn, ded = r["earnings"], r["deductions"]
        return ok("FNF_STATEMENT", "Full & Final Settlement Statement.", {
            "title": "Full & Final (F&F) Settlement Statement", "statement_no": f.statement_no,
            "status": f.status_label if hasattr(f, "status_label") else r["status_label"],
            "employee": en.emp_brief(e, request), "date_of_joining": iso(e.Date_of_Joining),
            "resignation_date": iso(x.resignation_date), "last_working_day": iso(x.last_working_day),
            "earnings": [
                {"label": "Pending salary", "days": earn["pending_salary_days"], "amount": earn["pending_salary"]},
                {"label": "Leave encashment", "days": earn["leave_encashment_days"], "amount": earn["leave_encashment"]},
                {"label": "Gratuity", "amount": earn["gratuity"]}, {"label": "Bonus", "amount": earn["bonus"]},
                {"label": "Other earnings", "amount": earn["other_earnings"]}],
            "deductions": [
                {"label": "Notice period recovery", "days": ded["notice_shortfall_days"], "amount": ded["notice_recovery"]},
                {"label": "Asset recovery", "amount": ded["asset_recovery"]},
                {"label": "Advance recovery", "amount": ded["advance_recovery"]},
                {"label": "TDS", "amount": ded["tds_deduction"]},
                {"label": "Other deductions", "amount": ded["other_deductions"]}],
            "gross_earnings": earn["total"], "total_deductions": ded["total"], "net_payable": r["net_payable"],
            "remarks": f.remarks, "approved_by": f.approved_by, "paid_on": r["paid_on"],
            "payment_reference": f.payment_reference})

    def destroy(self, request, pk=None):
        f = self._fnf(pk)
        if f is None:
            return err("NOT_FOUND", "F&F statement not found.", 404)
        if f.status in ("Approved", "Paid"):
            return err("CONFLICT", f"An {f.status} statement cannot be deleted.", 409)
        f.delete()
        return ok("FNF_DELETED", "F&F statement deleted.", {"id": int(pk)})


# ============================================================
# EXIT INTERVIEWS
# ============================================================

def apply_interview(iv, d, actor, creating):
    """Shared by the Admin and the Employee API. Raises ValueError."""
    if "status" in d:
        if d["status"] not in dict(ExitInterview.STATUS):
            raise ValueError("Invalid status. Allowed: " + ", ".join(dict(ExitInterview.STATUS)))
        iv.status = d["status"]
    if "mode" in d:
        if d["mode"] not in dict(ExitInterview.MODE):
            raise ValueError("Invalid mode. Allowed: " + ", ".join(dict(ExitInterview.MODE)))
        iv.mode = d["mode"]
    if "scheduled_for" in d:
        iv.scheduled_for = to_date(d["scheduled_for"])
    if "conducted_on" in d:
        iv.conducted_on = to_date(d["conducted_on"])
    if "conducted_by" in d:
        iv.conducted_by = d["conducted_by"]
    if "overall_rating" in d:
        r = to_decimal(d["overall_rating"])
        if r is not None and not (0 <= r <= 5):
            raise ValueError("overall_rating must be between 0 and 5.")
        iv.overall_rating = r
    if "reason_for_leaving" in d:
        if d["reason_for_leaving"] and d["reason_for_leaving"] not in dict(ExitInterview.REASONS):
            raise ValueError("Invalid reason_for_leaving. Allowed: " + ", ".join(dict(ExitInterview.REASONS)))
        iv.reason_for_leaving = d["reason_for_leaving"] or None
    for f in ("feedback", "liked_most", "improvement_suggestions"):
        if f in d:
            setattr(iv, f, d[f])
    for f in ("would_recommend", "would_rejoin"):
        if f in d:
            setattr(iv, f, None if d[f] in (None, "") else to_bool(d[f]))
    if iv.status == "Completed":
        iv.conducted_on = iv.conducted_on or timezone.localdate()
        iv.conducted_by = iv.conducted_by or actor
        if not str(iv.feedback or "").strip() and iv.overall_rating is None:
            raise ValueError("Add feedback or an overall_rating before completing the interview.")


class InterviewViewSet(CrudBase):
    """
    GET    /api/exit/interviews/                 ?status= ?employee_code= ?reason_for_leaving= ?search=
    POST   /api/exit/interviews/                 {exit_id | employee_code, status?, mode?, scheduled_for?, conducted_on?,
                                                  conducted_by?, overall_rating?, reason_for_leaving?, feedback?,
                                                  liked_most?, improvement_suggestions?, would_recommend?, would_rejoin?}
    GET    /api/exit/interviews/<id>/
    PATCH|PUT|POST(update/) /<id>/
    DELETE|POST(delete/)    /<id>/
    GET    /api/exit/interviews/summary/         average rating, reasons, recommend %
    """

    model = ExitInterview
    code = "EXIT_INTERVIEW"
    soft_delete = False
    search_fields = ("exit__employee__name", "exit__employee__employee_code", "feedback")
    permission_action_map = {"summary": "view"}

    def scope(self):
        return ExitInterview.objects.filter(company=self.company()).select_related(
            "exit", "exit__employee", "exit__employee__department")

    def build(self, iv):
        return en.interview_row(iv, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("employee_code"):
            qs = qs.filter(exit__employee__employee_code=p["employee_code"])
        if p.get("reason_for_leaving"):
            qs = qs.filter(reason_for_leaving=p["reason_for_leaving"])
        return qs

    def list(self, request):
        qs = self.filter(self.scope().filter(is_active=True), request.query_params)
        rows, meta = paginate(request, qs, self.build)
        return ok("EXIT_INTERVIEW_LIST", "Exit interviews.", rows, meta=meta)

    @transaction.atomic
    def create(self, request):
        d, actor = request.data, self.actor()
        x = find_case(self.company(), d.get("exit_id")) if d.get("exit_id") else \
            find_case(self.company(), employee_code=d.get("employee_code"))
        if x is None:
            return err("NOT_FOUND", "Exit case not found (send exit_id or employee_code).", 404)
        if en.interview_of(x) is not None:
            return err("EXISTS", "An exit interview already exists for this exit. Update it instead.", 409)
        iv = ExitInterview(company=x.company, exit=x, created_by=actor, updated_by=actor, submitted_by="HR")
        try:
            apply_interview(iv, d, actor, True)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        iv.save()
        return ok("EXIT_INTERVIEW_CREATED", "Exit interview recorded.", self.build(self.scope().get(pk=iv.pk)), 201)

    def partial_update(self, request, pk=None):
        iv = self.scope().filter(pk=pk).first()
        if iv is None:
            return err("NOT_FOUND", "Record not found.", 404)
        try:
            apply_interview(iv, request.data, self.actor(), False)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        iv.updated_by = self.actor()
        iv.save()
        return ok("EXIT_INTERVIEW_UPDATED", "Updated.", self.build(self.scope().get(pk=iv.pk)))

    update = partial_update

    @action(detail=False, methods=["get"])
    def summary(self, request):
        qs = self.scope().filter(is_active=True, status="Completed")
        agg = qs.aggregate(avg=Avg("overall_rating"), n=Count("id"),
                           rec=Count("id", filter=Q(would_recommend=True)),
                           rejoin=Count("id", filter=Q(would_rejoin=True)))
        n = agg["n"] or 0
        return ok("EXIT_INTERVIEW_SUMMARY", "Exit interview summary.", {
            "completed": n, "scheduled": self.scope().filter(is_active=True, status="Scheduled").count(),
            "average_rating": round(float(agg["avg"]), 1) if agg["avg"] is not None else None,
            "would_recommend_percent": round(agg["rec"] * 100 / n, 1) if n else None,
            "would_rejoin_percent": round(agg["rejoin"] * 100 / n, 1) if n else None,
            "reasons": {r: c for r, c in qs.exclude(reason_for_leaving__isnull=True)
                        .values_list("reason_for_leaving").annotate(c=Count("id"))}})


# ============================================================
# RELIEVING & EXPERIENCE  (existing letter vault, exit-aware)
# ============================================================

class ExitLetterViewSet(GeneratedLetterViewSet):
    """
    Same API as /api/people/generated-letters/ (list, types, preview, <id>/pdf, download, revoke ...)
    - "Generated Letters Vault & Dispatch Log": GET  /api/exit/letters/   (?exit_only=true for relieving/experience only)
    - POST /api/exit/letters/generate/   {exit_id | recipient_code, letter_type: RELIEVING_EXPERIENCE |
                                          EXPERIENCE_CERTIFICATE, force?, variables?}
      Exit letters are only issued when every departmental clearance is approved (force=true overrides).
    """

    code = "EXIT_LETTER"

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if to_bool(p.get("exit_only")):
            qs = qs.filter(letter_type__in=en.EXIT_LETTER_TYPES)
        return qs

    @action(detail=False, methods=["post"])
    def generate(self, request):
        d = request.data
        lt = str(d.get("letter_type") or "").upper()
        if lt not in en.EXIT_LETTER_TYPES:
            return super().generate(request)
        x = find_case(self.company(), d.get("exit_id")) if d.get("exit_id") else \
            find_case(self.company(), employee_code=d.get("recipient_code") or d.get("employee_code"))
        if x is None:
            return err("NOT_FOUND", "Exit case not found (send exit_id).", 404)
        if en.detail_or_virtual(x).approval_status != "Accepted":
            return err("CONFLICT", "The resignation is not accepted yet.", 409)
        if not en.all_cleared(x) and not to_bool(d.get("force")):
            return err("NOT_CLEARED", "All departmental clearances must be approved before the relieving documents "
                                      "are generated (or pass force=true).", 409)
        extra = {"last_working_day": (x.last_working_day or timezone.localdate()).strftime("%d %B %Y"),
                 "resignation_date": iso(x.resignation_date)}
        if isinstance(d.get("variables"), dict):
            extra.update(d["variables"])
        try:
            l = issue_letter(self.company(), x.employee, lt, self.actor(), extra, d.get("subject"), d.get("body"))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        return ok("LETTER_ISSUED", "Letter generated.", self.build(l) | {"body": l.body, "variables": l.variables}, 201)
