# ============================================================
# ADDITIVE tests - Exit Management, Clearances & F&F
#   python manage.py test People.tests_exit
# ============================================================
from datetime import date, timedelta
from decimal import Decimal

from django.test import override_settings
from django.utils import timezone
from rest_framework.test import APIClient, APITestCase

from Company.models import company_details
from Employee.leave_models import ReportingHierarchy
from Employee.models import EmployeeAccount, EmployeeDT, EmployeeRole
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People.models import AssetAllocation, AssetMaster, EmployeeLetter, ExitClearance

X = "/api/exit"
ME = "/employee/exit"
MEDIA = override_settings(MEDIA_ROOT="/tmp/exit_test_media")


@MEDIA
class ExitBase(APITestCase):
    def mk_company(self, n):
        return company_details.objects.create(email=f"ex{n}@x.com", password="pw", contact_no=f"92000000{n:02d}",
                                             status=True, is_verified=True, Registered_Company_Name="Zenith Corp",
                                             Company_address="Pune")

    def mk_emp(self, company, code, name, role=None, joined=date(2023, 1, 10), basic="60000", desig="Engineer"):
        e = EmployeeDT.objects.create(company=company, employee_code=code, name=name, email=f"{code}@x.com",
                                      Designation=desig, Date_of_Joining=joined, Basic_Salary=Decimal(basic))
        EmployeeAccount.objects.create(employee=e, role=role)
        return e

    def setUp(self):
        self.co, self.other = self.mk_company(1), self.mk_company(2)
        self.hr_role = EmployeeRole.objects.create(
            company=self.co, role_name="HR", role_code="hr", can_view_employees=True, can_create_employees=True,
            can_edit_employees=True, can_delete_employees=True)
        self.view_role = EmployeeRole.objects.create(company=self.co, role_name="V", role_code="v",
                                                     can_view_employees=True)
        self.vikram = self.mk_emp(self.co, "EMP0504", "Vikram Rao", desig="Enterprise Account Executive")
        self.rahul = self.mk_emp(self.co, "EMP0248", "Rahul Sharma", joined=date(2018, 6, 1))
        self.amit = self.mk_emp(self.co, "EMP0099", "Amit Joshi")
        self.itlead = self.mk_emp(self.co, "EMP0200", "IT Lead")
        self.hr = self.mk_emp(self.co, "EMP0001", "Elena Rostova", role=self.hr_role)
        self.viewer = self.mk_emp(self.co, "EMP0777", "Viewer", role=self.view_role)
        self.stranger = self.mk_emp(self.co, "EMP0888", "Stranger")
        self.outsider = self.mk_emp(self.other, "EMP0999", "Outsider")
        ReportingHierarchy.objects.create(company=self.co, Employee_ID="EMP0504", manager_code="EMP0099")
        self.admin = client_for(company_token(self.co))
        self.hr_c = client_for(employee_token(self.hr))
        self.view_c = client_for(employee_token(self.viewer))
        self.vik_c = client_for(employee_token(self.vikram))
        self.amit_c = client_for(employee_token(self.amit))
        self.it_c = client_for(employee_token(self.itlead))
        self.str_c = client_for(employee_token(self.stranger))
        self.other_admin = client_for(company_token(self.other))

    def resign(self, code="EMP0504", **kw):
        body = {"employee_code": code, "resignation_date": "2026-08-15", "reason": "Family relocation",
                "notice_period_days": 45, **kw}
        r = self.admin.post(f"{X}/resignations/", body, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        return r.json()["data"]

    def approve_all(self, xid, client=None):
        c = client or self.admin
        for d in ("HR", "IT", "Finance", "Admin"):
            r = c.post(f"{X}/clearances/{xid}/approve/", {"department": d, "remarks": "ok"}, format="json")
            self.assertEqual(r.status_code, 200, r.json())


class AuthTests(ExitBase):
    def test_auth_matrix(self):
        for url in (f"{X}/dashboard/", f"{X}/resignations/", f"{X}/clearances/", f"{X}/fnf/",
                    f"{X}/interviews/", f"{X}/letters/", f"{X}/meta/"):
            self.assertEqual(APIClient().get(url).status_code, 401, url)
            self.assertEqual(self.str_c.get(url).status_code, 403, url)
            self.assertEqual(self.view_c.get(url).status_code, 200, url)
            self.assertEqual(self.admin.get(url).status_code, 200, url)
        r = self.view_c.post(f"{X}/resignations/", {"employee_code": "EMP0504"}, format="json")
        self.assertEqual(r.status_code, 403)
        self.assertEqual(self.hr_c.post(f"{X}/resignations/", {"employee_code": "EMP0504"}, format="json").status_code, 201)

    def test_employee_endpoints_need_employee_token(self):
        self.assertEqual(APIClient().get(f"{ME}/status/").status_code, 401)
        self.assertIn(self.admin.get(f"{ME}/status/").status_code, (401, 403))

    def test_company_isolation(self):
        x = self.resign()
        o = self.other_admin
        self.assertEqual(o.get(f"{X}/resignations/{x['id']}/").status_code, 404)
        self.assertEqual(o.get(f"{X}/clearances/{x['id']}/").status_code, 404)
        self.assertEqual(o.get(f"{X}/resignations/").json()["meta"]["total"], 0)
        r = o.post(f"{X}/resignations/", {"employee_code": "EMP0504"}, format="json")
        self.assertEqual(r.status_code, 400)


class ResignationTests(ExitBase):
    def test_create_defaults_and_effects(self):
        x = self.resign()
        self.assertEqual(x["approval_status"], "Accepted")
        self.assertEqual(x["notice_period"], "45 Days")
        self.assertEqual(x["last_working_day"], "2026-09-29")
        self.assertEqual(x["clearance_status"], "0/4 Approved")
        self.vikram.refresh_from_db()
        self.assertEqual((self.vikram.Resignation_Status, self.vikram.Resignation_Date), ("Resigned", "2026-08-15"))
        dup = self.admin.post(f"{X}/resignations/", {"employee_code": "EMP0504"}, format="json")
        self.assertEqual(dup.status_code, 409)

    def test_validation(self):
        bad = [{"employee_code": "NOPE"}, {"employee_code": "EMP0248", "separation_type": "x"},
               {"employee_code": "EMP0248", "resignation_date": "2026-08-15", "last_working_day": "2026-08-01"},
               {"employee_code": "EMP0248", "notice_period_days": 10, "notice_waived_days": 20},
               {"employee_code": "EMP0248", "handover_to_code": "EMP0248"},
               {"employee_code": "EMP0248", "clearance_departments": []}]
        for b in bad:
            self.assertEqual(self.admin.post(f"{X}/resignations/", b, format="json").status_code, 400, b)

    def test_crud_filters_and_delete_rules(self):
        x = self.resign()
        r = self.admin.patch(f"{X}/resignations/{x['id']}/", {"last_working_day": "2026-10-10", "hr_remarks": "ok",
                                                            "handover_to_code": "EMP0099"}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        self.assertEqual(r.json()["data"]["handover_to"]["employee_code"], "EMP0099")
        self.vikram.refresh_from_db()
        self.assertEqual(self.vikram.Last_Working_Day, "2026-10-10")
        self.assertEqual(self.admin.post(f"{X}/resignations/{x['id']}/update/", {"reason": "x"}, format="json").status_code, 200)
        q = f"{X}/resignations/?approval_status=Accepted&active=true&search=vikram"
        self.assertEqual(self.admin.get(q).json()["meta"]["total"], 1)
        self.assertEqual(self.admin.get(f"{X}/resignations/?approval_status=Submitted").json()["meta"]["total"], 0)
        self.assertEqual(self.admin.delete(f"{X}/resignations/{x['id']}/").status_code, 409)
        self.admin.post(f"{X}/resignations/{x['id']}/withdraw/", {"reason": "Stays"}, format="json")
        self.vikram.refresh_from_db()
        self.assertIsNone(self.vikram.Resignation_Status)
        self.assertEqual(self.admin.patch(f"{X}/resignations/{x['id']}/", {"reason": "z"}, format="json").status_code, 409)
        self.assertEqual(self.admin.delete(f"{X}/resignations/{x['id']}/").status_code, 200)
        self.assertEqual(self.admin.get(f"{X}/resignations/{x['id']}/").status_code, 404)

    def test_accept_reject_flow(self):
        a = self.resign(submit_for_approval=True)
        self.assertEqual(a["approval_status"], "Submitted")
        self.vikram.refresh_from_db()
        self.assertIsNone(self.vikram.Resignation_Status)
        self.assertEqual(self.admin.post(f"{X}/clearances/{a['id']}/approve/", {"department": "HR"}, format="json").status_code, 409)
        r = self.admin.post(f"{X}/resignations/{a['id']}/accept/", {"notice_waived_days": 10}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        self.assertEqual(r.json()["data"]["approval_status"], "Accepted")
        self.vikram.refresh_from_db()
        self.assertEqual(self.vikram.Resignation_Status, "Resigned")
        self.assertEqual(self.admin.post(f"{X}/resignations/{a['id']}/accept/", {}, format="json").status_code, 409)

        b = self.admin.post(f"{X}/resignations/", {"employee_code": "EMP0248", "submit_for_approval": True}, format="json").json()["data"]
        self.assertEqual(self.admin.post(f"{X}/resignations/{b['id']}/reject/", {}, format="json").status_code, 400)
        r = self.admin.post(f"{X}/resignations/{b['id']}/reject/", {"reason": "Project critical"}, format="json")
        self.assertEqual(r.json()["data"]["approval_status"], "Rejected")
        self.assertEqual(self.admin.delete(f"{X}/resignations/{b['id']}/").status_code, 200)

    def test_complete_gating(self):
        x = self.resign()
        r = self.admin.post(f"{X}/resignations/{x['id']}/complete/", {}, format="json")
        self.assertEqual(r.json()["code"], "NOT_CLEARED")
        self.approve_all(x["id"])
        r = self.admin.post(f"{X}/resignations/{x['id']}/complete/", {}, format="json")
        self.assertEqual(r.json()["code"], "FNF_PENDING")
        fid = self.admin.post(f"{X}/fnf/generate/", {"exit_id": x["id"]}, format="json").json()["data"]["id"]
        self.admin.post(f"{X}/fnf/{fid}/approve/", {}, format="json")
        r = self.admin.post(f"{X}/resignations/{x['id']}/complete/", {}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        self.vikram.refresh_from_db()
        self.assertEqual((self.vikram.is_active, self.vikram.Employee_Status), (False, "Exited"))
        self.assertFalse(EmployeeAccount.objects.get(employee=self.vikram).is_login_enabled)

    def test_legacy_case_from_profile360_is_visible(self):
        ExitClearance.objects.create(company=self.co, employee=self.rahul, resignation_date=date(2026, 8, 1),
                                     last_working_day=date(2026, 9, 1), items=[
            {"department": "IT", "title": "t", "cleared": True}, {"department": "HR", "title": "t", "cleared": False}])
        rows = self.admin.get(f"{X}/resignations/?approval_status=Accepted").json()["data"]
        self.assertEqual(len(rows), 1)
        self.assertEqual(rows[0]["clearance_status"], "1/2 Approved")
        self.assertEqual(rows[0]["notice_period_days"], 30)
        self.assertEqual(ExitClearance.objects.get().items[0].get("status"), None)   # untouched by reading


class ClearanceTests(ExitBase):
    def test_flow_and_status_rollup(self):
        x = self.resign()
        c = self.admin.get(f"{X}/clearances/{x['id']}/").json()["data"]
        self.assertEqual(c["summary"], "0 / 4 Done")
        self.assertEqual([i["heading"] for i in c["items"]][:2], ["1. HR Clearance", "2. IT Clearance"])
        r = self.admin.post(f"{X}/clearances/{x['id']}/approve/", {"department": "HR", "remarks": "Notice served"}, format="json")
        self.assertEqual(r.json()["data"]["summary"], "1 / 4 Done")
        self.assertEqual(ExitClearance.objects.get().status, "In Progress")
        r = self.admin.post(f"{X}/clearances/{x['id']}/reject/", {"department": "IT"}, format="json")
        self.assertEqual(r.status_code, 400)
        r = self.admin.post(f"{X}/clearances/{x['id']}/reject/", {"department": "IT", "remarks": "Laptop missing"}, format="json")
        self.assertEqual([i["status"] for i in r.json()["data"]["items"]][:2], ["Approved", "Rejected"])
        self.admin.post(f"{X}/clearances/{x['id']}/reset/", {"department": "IT"}, format="json")
        self.assertEqual(self.admin.post(f"{X}/clearances/{x['id']}/approve/", {"department": "Legal"}, format="json").status_code, 400)
        self.approve_all(x["id"])
        self.assertEqual(ExitClearance.objects.get().status, "Cleared")
        self.assertEqual(self.admin.get(f"{X}/clearances/?employee_code=EMP0504").json()["meta"]["total"], 1)

    def test_pending_assets_block_it_clearance(self):
        x = self.resign()
        a = AssetMaster.objects.create(company=self.co, asset_tag="ZH-IT-1", device_name="Dell Laptop", category="Laptop", purchase_cost=Decimal("50000"))
        AssetAllocation.objects.create(company=self.co, asset=a, employee=self.vikram)
        c = self.admin.get(f"{X}/clearances/{x['id']}/").json()["data"]
        self.assertEqual(c["pending_assets"][0]["asset_tag"], "ZH-IT-1")
        r = self.admin.post(f"{X}/clearances/{x['id']}/approve/", {"department": "IT"}, format="json")
        self.assertEqual(r.status_code, 409)
        self.assertIn("ZH-IT-1", r.json()["message"])
        r = self.admin.post(f"{X}/clearances/{x['id']}/approve/", {"department": "IT", "force": True}, format="json")
        self.assertEqual(r.status_code, 200)

    def test_item_crud(self):
        x = self.resign()
        r = self.admin.post(f"{X}/clearances/{x['id']}/items/", {"department": "Legal", "approver_code": "EMP0099"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        self.assertEqual(r.json()["data"]["total"], 5)
        self.assertEqual(self.admin.post(f"{X}/clearances/{x['id']}/items/", {"department": "legal"}, format="json").status_code, 409)
        r = self.admin.patch(f"{X}/clearances/{x['id']}/items/Legal/", {"title": "NDA signed", "approver_code": ""}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertEqual(self.admin.patch(f"{X}/clearances/{x['id']}/items/Nope/", {}, format="json").status_code, 404)
        r = self.admin.delete(f"{X}/clearances/{x['id']}/items/Legal/")
        self.assertEqual(r.json()["data"]["total"], 4)

    def test_custom_departments_and_manager_item(self):
        r = self.admin.post(f"{X}/resignations/", {"employee_code": "EMP0504", "include_manager_clearance": True}, format="json")
        c = self.admin.get(f"{X}/clearances/{r.json()['data']['id']}/").json()["data"]
        mgr = [i for i in c["items"] if i["department"] == "Reporting Manager"][0]
        self.assertEqual(mgr["approver_code"], "EMP0099")


class FnFTests(ExitBase):
    def test_calculator_components(self):
        # Rahul: joined 2018-06-01, LWD 2026-09-30 -> 8.3 years, basic 60000, per day 2000
        x = self.resign("EMP0248", resignation_date="2026-08-15", last_working_day="2026-09-30", notice_period_days=30)
        r = self.admin.post(f"{X}/fnf/preview/", {"exit_id": x["id"], "bonus": 5000, "advance_recovery": 1000}, format="json")
        d = r.json()["data"]
        self.assertEqual(d["earnings"]["pending_salary_days"], 30.0)
        self.assertEqual(d["earnings"]["pending_salary"], 60000.0)
        # gratuity: 8 completed years (+0.33 rounds down) x 60000 x 15/26
        self.assertEqual(d["earnings"]["gratuity"], round(60000 * 15 / 26 * 8, 2))
        self.assertEqual(d["deductions"]["notice_shortfall_days"], 0.0)         # 46 days served >= 30
        self.assertEqual(d["net_payable"], round(60000 + 60000 * 15 / 26 * 8 + 5000 - 1000, 2))
        self.assertTrue(any("clearances" in w for w in d["components"]["warnings"]))

    def test_notice_shortfall_and_no_gratuity(self):
        x = self.resign("EMP0504", resignation_date="2026-09-01", last_working_day="2026-09-15", notice_period_days=45)
        d = self.admin.post(f"{X}/fnf/preview/", {"exit_id": x["id"]}, format="json").json()["data"]
        self.assertEqual(d["deductions"]["notice_shortfall_days"], 31.0)         # 45 - 14
        self.assertEqual(d["deductions"]["notice_recovery"], 62000.0)
        self.assertEqual(d["earnings"]["gratuity"], 0.0)
        self.assertIn("Not eligible", d["components"]["gratuity_note"])
        self.assertEqual(self.admin.post(f"{X}/fnf/preview/", {"exit_id": x["id"], "bonus": -5}, format="json").status_code, 400)

    def test_leave_encashment(self):
        from Company.leave_engine import ensure_default_policies
        from Employee.leave_models import LeavePolicy
        ensure_default_policies(self.co)
        p = LeavePolicy.objects.filter(company=self.co, annual_quota__gt=0).first()
        p.encashable, p.max_encashable_days = True, Decimal("5")
        p.save()
        x = self.resign("EMP0504", last_working_day=str(date(2026, 9, 30)))
        d = self.admin.post(f"{X}/fnf/preview/", {"exit_id": x["id"]}, format="json").json()["data"]
        self.assertEqual(d["earnings"]["leave_encashment_days"], 5.0)
        self.assertEqual(d["earnings"]["leave_encashment"], 10000.0)

    def test_lifecycle_generate_edit_approve_pay(self):
        x = self.resign()
        g = self.admin.post(f"{X}/fnf/generate/", {"exit_id": x["id"], "overrides": {"bonus": 1000}}, format="json")
        self.assertEqual(g.status_code, 201, g.json())
        f = g.json()["data"]
        self.assertTrue(f["statement_no"].startswith("FNF-"))
        self.assertEqual(f["status_label"], "Calculation Ready")
        self.assertEqual(self.admin.get(f"{X}/fnf/?exit_id={x['id']}").json()["data"][0]["statement"]["id"], f["id"])
        r = self.admin.patch(f"{X}/fnf/{f['id']}/", {"other_deductions": 500, "remarks": "Adjusted"}, format="json")
        self.assertEqual(r.json()["data"]["net_payable"], round(f["net_payable"] - 500, 2))
        r = self.admin.post(f"{X}/fnf/generate/", {"exit_id": x["id"], "asset_recovery": 100}, format="json")
        self.assertEqual(r.status_code, 200)                        # regenerate keeps one statement
        self.assertEqual(r.json()["data"]["id"], f["id"])
        self.assertEqual(r.json()["data"]["deductions"]["other_deductions"], 500.0)   # manual kept
        self.assertEqual(self.admin.post(f"{X}/fnf/{f['id']}/approve/", {}, format="json").json()["code"], "NOT_CLEARED")
        self.approve_all(x["id"])
        self.assertEqual(self.admin.post(f"{X}/fnf/{f['id']}/mark-paid/", {}, format="json").status_code, 409)
        self.assertEqual(self.admin.post(f"{X}/fnf/{f['id']}/approve/", {}, format="json").json()["data"]["status"], "Approved")
        self.assertEqual(self.admin.patch(f"{X}/fnf/{f['id']}/", {"bonus": 1}, format="json").status_code, 409)
        self.assertEqual(self.admin.delete(f"{X}/fnf/{f['id']}/").status_code, 409)
        st = self.admin.get(f"{X}/fnf/{f['id']}/statement/").json()["data"]
        self.assertEqual(st["employee"]["employee_code"], "EMP0504")
        r = self.admin.post(f"{X}/fnf/{f['id']}/mark-paid/", {"payment_mode": "NEFT", "payment_reference": "UTR123"}, format="json")
        self.assertEqual(r.json()["data"]["status"], "Paid")
        self.assertEqual(self.admin.get(f"{X}/fnf/?status=Paid").json()["meta"]["total"], 1)

    def test_draft_delete_and_regenerate(self):
        x = self.resign()
        f = self.admin.post(f"{X}/fnf/generate/", {"exit_id": x["id"]}, format="json").json()["data"]
        self.assertEqual(self.admin.post(f"{X}/fnf/{f['id']}/delete/", {}, format="json").status_code, 200)
        self.assertEqual(self.admin.get(f"{X}/fnf/{f['id']}/").status_code, 404)
        self.assertEqual(self.admin.post(f"{X}/fnf/generate/", {"exit_id": x["id"]}, format="json").status_code, 201)

    def test_recalculate_and_payroll_processed(self):
        from Employee.models import Payroll
        x = self.resign("EMP0504", last_working_day="2026-09-20")
        f = self.admin.post(f"{X}/fnf/generate/", {"exit_id": x["id"]}, format="json").json()["data"]
        self.assertEqual(f["earnings"]["pending_salary_days"], 20.0)
        try:
            Payroll.objects.create(Employee_ID="EMP0504", name="Vikram Rao", company=self.co, month=9, year=2026,
                                   basic_salary=Decimal("60000"), present_days=20, gross_salary=Decimal("40000"),
                                   net_salary=Decimal("40000"))
        except Exception:
            self.skipTest("Payroll fixture not creatable in this schema")
        r = self.admin.post(f"{X}/fnf/{f['id']}/recalculate/", {}, format="json").json()["data"]
        self.assertEqual(r["earnings"]["pending_salary_days"], 0.0)
        self.assertTrue(r["components"]["payroll_already_processed"])


class InterviewTests(ExitBase):
    def test_crud_and_summary(self):
        x = self.resign()
        r = self.admin.post(f"{X}/interviews/", {"exit_id": x["id"], "scheduled_for": "2026-09-10"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        iid = r.json()["data"]["id"]
        self.assertEqual(self.admin.post(f"{X}/interviews/", {"exit_id": x["id"]}, format="json").status_code, 409)
        self.assertEqual(self.admin.patch(f"{X}/interviews/{iid}/", {"status": "Completed"}, format="json").status_code, 400)
        self.assertEqual(self.admin.patch(f"{X}/interviews/{iid}/", {"overall_rating": 6}, format="json").status_code, 400)
        r = self.admin.patch(f"{X}/interviews/{iid}/", {
            "status": "Completed", "overall_rating": 4.5, "reason_for_leaving": "Relocation",
            "feedback": "Great team environment and challenging engineering problems. Moving due to family relocation.",
            "would_recommend": True, "would_rejoin": True}, format="json")
        d = r.json()["data"]
        self.assertEqual(d["rating_label"], "4.5 / 5.0 Workplace Rating")
        self.assertEqual(d["employee_title"], "Vikram Rao (Enterprise Account Executive)")
        self.assertEqual(d["conducted_on"], str(timezone.localdate()))
        s = self.admin.get(f"{X}/interviews/summary/").json()["data"]
        self.assertEqual((s["completed"], s["average_rating"], s["would_recommend_percent"]), (1, 4.5, 100.0))
        self.assertEqual(s["reasons"], {"Relocation": 1})
        self.assertEqual(self.admin.get(f"{X}/interviews/?employee_code=EMP0504&status=Completed").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.delete(f"{X}/interviews/{iid}/").status_code, 200)
        self.assertEqual(self.admin.get(f"{X}/interviews/{iid}/").status_code, 404)


class LettersDashboardTests(ExitBase):
    def test_exit_letters_need_clearance(self):
        x = self.resign()
        body = {"exit_id": x["id"], "letter_type": "RELIEVING_EXPERIENCE"}
        r = self.admin.post(f"{X}/letters/generate/", body, format="json")
        self.assertEqual(r.json()["code"], "NOT_CLEARED")
        self.approve_all(x["id"])
        r = self.admin.post(f"{X}/letters/generate/", body, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        d = r.json()["data"]
        self.assertTrue(d["letter_ref"].startswith("REL-"))
        self.assertIn("29 September 2026", d["body"])
        self.assertEqual(d["recipient"]["label"], "Vikram Rao (EMP0504)")
        r = self.admin.post(f"{X}/letters/generate/", {"exit_id": x["id"], "letter_type": "EXPERIENCE_CERTIFICATE"}, format="json")
        self.assertEqual(r.status_code, 201)
        lst = self.admin.get(f"{X}/letters/?exit_only=true").json()
        self.assertEqual(lst["meta"]["total"], 2)
        self.assertEqual(self.admin.get(f"{X}/letters/{d['id']}/pdf/").status_code, 200)
        # non-exit letters still work through the same vault
        r = self.admin.post(f"{X}/letters/generate/", {"recipient_code": "EMP0248", "letter_type": "APPOINTMENT"}, format="json")
        self.assertEqual(r.status_code, 201)
        self.assertEqual(self.admin.get(f"{X}/letters/").json()["meta"]["total"], 3)

    def test_force_and_unaccepted(self):
        a = self.resign(submit_for_approval=True)
        r = self.admin.post(f"{X}/letters/generate/", {"exit_id": a["id"], "letter_type": "RELIEVING_EXPERIENCE"}, format="json")
        self.assertEqual(r.status_code, 409)
        self.admin.post(f"{X}/resignations/{a['id']}/accept/", {}, format="json")
        r = self.admin.post(f"{X}/letters/generate/", {"exit_id": a["id"], "letter_type": "RELIEVING_EXPERIENCE", "force": True}, format="json")
        self.assertEqual(r.status_code, 201)

    def test_dashboard_cards_and_pipeline(self):
        d = self.admin.get(f"{X}/dashboard/").json()["data"]
        self.assertEqual(d["cards"]["notice_period_active"]["value"], 0)
        self.assertEqual(d["cards"]["fnf_settlement_status"]["label"], "-")
        x = self.resign()
        for dep in ("HR", "IT", "Finance"):
            self.admin.post(f"{X}/clearances/{x['id']}/approve/", {"department": dep}, format="json")
        self.admin.post(f"{X}/fnf/generate/", {"exit_id": x["id"]}, format="json")
        d = self.admin.get(f"{X}/dashboard/").json()["data"]
        c = d["cards"]
        self.assertEqual(c["notice_period_active"]["label"], "1")
        self.assertEqual(c["average_notice_period"]["label"], "45 Days")
        self.assertEqual(c["departmental_clearances"]["label"], "3 / 4 Done")
        self.assertEqual(c["departmental_clearances"]["caption"], "HR, IT, Finance, Admin")
        self.assertEqual(c["fnf_settlement_status"]["label"], "Pending")
        self.admin.post(f"{X}/clearances/{x['id']}/approve/", {"department": "Admin"}, format="json")
        c = self.admin.get(f"{X}/dashboard/").json()["data"]["cards"]
        self.assertEqual(c["fnf_settlement_status"]["label"], "Ready")
        row = self.admin.get(f"{X}/dashboard/").json()["data"]["pipeline"][0]
        self.assertEqual(row["employee_subtitle"], "EMP0504 • Enterprise Account Executive")
        self.assertEqual(row["notice_period"], "45 Days")
        self.assertEqual(row["clearance_status"], "4/4 Approved")
        self.assertEqual(row["fnf_status"], "Calculation Ready")
        self.assertTrue(row["actions"]["relieving_letter_ready"])


class EmployeeSelfServiceTests(ExitBase):
    def test_resign_withdraw_flow(self):
        self.assertFalse(self.vik_c.get(f"{ME}/status/").json()["data"]["has_exit"])
        self.assertEqual(self.vik_c.post(f"{ME}/resign/", {}, format="json").status_code, 400)
        r = self.vik_c.post(f"{ME}/resign/", {"reason": "Family relocation", "resignation_date": "2026-08-15"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        d = r.json()["data"]
        self.assertEqual((d["approval_status"], d["requested_by"]), ("Submitted", "Employee"))
        self.assertNotIn("hr_remarks", d)
        self.assertEqual(self.vik_c.post(f"{ME}/resign/", {"reason": "again"}, format="json").status_code, 409)
        r = self.vik_c.patch(f"{ME}/resign/", {"reason": "Moving cities"}, format="json")
        self.assertEqual(r.json()["data"]["reason"], "Moving cities")
        self.assertEqual(self.vik_c.get(f"{ME}/clearances/").json()["data"], None)
        self.assertEqual(self.vik_c.post(f"{ME}/interview/", {"feedback": "x"}, format="json").status_code, 409)
        self.assertEqual(self.vik_c.post(f"{ME}/withdraw/", {"reason": "Changed mind"}, format="json").status_code, 200)
        self.assertEqual(self.vik_c.post(f"{ME}/withdraw/", {}, format="json").status_code, 404)
        self.assertTrue(self.vik_c.get(f"{ME}/status/").json()["data"]["can_resign"])
        self.assertEqual(self.vik_c.post(f"{ME}/resign/", {"reason": "Again later"}, format="json").status_code, 201)

    def test_hr_accepts_then_employee_sees_everything(self):
        rid = self.vik_c.post(f"{ME}/resign/", {"reason": "Relocation", "resignation_date": "2026-08-15"}, format="json").json()["data"]["id"]
        self.assertEqual(self.hr_c.get(f"{X}/resignations/?approval_status=Submitted").json()["meta"]["total"], 1)
        self.assertEqual(self.hr_c.post(f"{X}/resignations/{rid}/accept/", {}, format="json").status_code, 200)
        self.assertEqual(self.vik_c.patch(f"{ME}/resign/", {"reason": "late"}, format="json").status_code, 409)
        self.assertEqual(self.vik_c.post(f"{ME}/withdraw/", {}, format="json").status_code, 409)
        st = self.vik_c.get(f"{ME}/status/").json()["data"]
        self.assertEqual(st["clearances"]["summary"], "0 / 4 Done")
        self.assertEqual(st["fnf"]["status_label"], "Not Generated")
        self.assertIsNone(self.vik_c.get(f"{ME}/fnf/").json()["data"]["status"])
        # interview form
        r = self.vik_c.post(f"{ME}/interview/", {"overall_rating": 4.5, "reason_for_leaving": "Relocation",
                                                 "feedback": "Great team.", "would_recommend": True}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        self.assertEqual(r.json()["data"]["submitted_by"], "Employee")
        self.assertEqual(self.vik_c.post(f"{ME}/interview/", {"feedback": "again"}, format="json").status_code, 409)
        self.assertEqual(self.vik_c.get(f"{ME}/interview/").json()["data"]["status"], "Completed")
        self.assertEqual(self.admin.get(f"{X}/interviews/").json()["meta"]["total"], 1)
        # F&F hidden until approved
        self.approve_all(rid)
        f = self.hr_c.post(f"{X}/fnf/generate/", {"exit_id": rid}, format="json").json()["data"]
        mine = self.vik_c.get(f"{ME}/fnf/").json()["data"]
        self.assertFalse(mine["released"])
        self.assertNotIn("net_payable", mine)
        self.hr_c.post(f"{X}/fnf/{f['id']}/approve/", {}, format="json")
        mine = self.vik_c.get(f"{ME}/fnf/").json()["data"]
        self.assertTrue(mine["released"])
        self.assertEqual(mine["net_payable"], f["net_payable"])
        # letters via the existing vault endpoint
        self.hr_c.post(f"{X}/letters/generate/", {"exit_id": rid, "letter_type": "RELIEVING_EXPERIENCE"}, format="json")
        self.assertEqual(self.vik_c.get(f"{ME}/status/").json()["data"]["letters_issued"], 1)
        self.assertEqual(self.vik_c.get("/employee/vault/letters/").status_code, 200)

    def test_clearance_approver_authorization(self):
        rid = self.resign()["id"]
        self.admin.patch(f"{X}/clearances/{rid}/items/IT/", {"approver_code": "EMP0200"}, format="json")
        tasks = self.it_c.get(f"{ME}/clearances/tasks/").json()["data"]
        self.assertEqual([(t["exit_id"], t["department"]) for t in tasks], [(rid, "IT")])
        self.assertEqual(self.str_c.get(f"{ME}/clearances/tasks/").json()["data"], [])
        # not my item
        r = self.it_c.post(f"{ME}/clearances/{rid}/approve/", {"department": "Finance"}, format="json")
        self.assertEqual(r.status_code, 403)
        self.assertEqual(self.str_c.post(f"{ME}/clearances/{rid}/approve/", {"department": "IT"}, format="json").status_code, 403)
        # the employee cannot approve their own clearance
        self.assertEqual(self.vik_c.post(f"{ME}/clearances/{rid}/approve/", {"department": "IT"}, format="json").status_code, 404)
        # reject needs remarks, approve works
        self.assertEqual(self.it_c.post(f"{ME}/clearances/{rid}/reject/", {"department": "IT"}, format="json").status_code, 400)
        r = self.it_c.post(f"{ME}/clearances/{rid}/approve/", {"department": "IT", "remarks": "Laptop returned"}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        self.assertEqual(self.admin.get(f"{X}/clearances/{rid}/").json()["data"]["items"][1]["remarks"], "Laptop returned")
        # approvers cannot force past pending assets
        a = AssetMaster.objects.create(company=self.co, asset_tag="T1", device_name="Laptop", category="Laptop")
        AssetAllocation.objects.create(company=self.co, asset=a, employee=self.vikram)
        self.it_c.post(f"{ME}/clearances/{rid}/reject/", {"department": "IT", "remarks": "x"}, format="json")
        r = self.it_c.post(f"{ME}/clearances/{rid}/approve/", {"department": "IT", "force": True}, format="json")
        self.assertEqual(r.status_code, 409)

    def test_manager_team_view_and_reporting_manager_task(self):
        r = self.admin.post(f"{X}/resignations/", {"employee_code": "EMP0504", "include_manager_clearance": True}, format="json")
        rid = r.json()["data"]["id"]
        team = self.amit_c.get(f"{ME}/team/").json()["data"]
        self.assertEqual([t["employee"]["employee_code"] for t in team["results"]], ["EMP0504"])
        self.assertNotIn("reason", team["results"][0])
        self.assertEqual(self.str_c.get(f"{ME}/team/").json()["data"]["count"], 0)
        tasks = self.amit_c.get(f"{ME}/clearances/tasks/?pending=true").json()["data"]
        self.assertEqual(tasks[0]["department"], "Reporting Manager")
        self.assertEqual(self.amit_c.post(f"{ME}/clearances/{rid}/approve/", {"department": "Reporting Manager"}, format="json").status_code, 200)
