# ============================================================
# ADDITIVE tests - HR MIS & Workforce Analytics (Reports & MIS)
#   python manage.py test People.tests_reports
# ============================================================
import csv
import io
from datetime import date, datetime, 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.leave_engine import ensure_default_policies
from Company.models import company_details
from Employee.leave_models import LeavePolicy, ReportingHierarchy
from Employee.models import (AttendanceEmp, Department, EMP_check_in_check_out, EmployeeAccount, EmployeeDT,
                             EmployeeRole, LeaveRequest, Payroll)
from Employee.performance_models import PerfRatingHistory
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People.exit_models import ExitInterview
from People.models import ExitClearance
from People.reports_models import ExitReasonGroup, ReportBenchmark, ReportExport
from Recruitment.models import CandidateProfile, InterviewRound, Offer, StageHistory
from Training.models import TrainingAttendance, TrainingCertificate, TrainingEnrollment, TrainingProgram, TrainingSession

R = "/api/reports"
ME = "/employee/reports"
FY = "financial_year=2026-27"


@override_settings(MEDIA_ROOT="/tmp/reports_test_media")
class RBase(APITestCase):

    def mk_company(self, n):
        return company_details.objects.create(email=f"rp{n}@x.com", password="pw", contact_no=f"93000000{n:02d}",
                                              status=True, is_verified=True)

    def mk_emp(self, code, name, role=None, dept=None, gender=None, dob=None, doj=None, basic=None, loc="Pune", active=True):
        e = EmployeeDT.objects.create(company=self.co, employee_code=code, name=name, email=f"{code}@x.com",
                                      Designation="Engineer", department=dept, Gender=gender, Date_of_Birth=dob,
                                      Date_of_Joining=doj, Basic_Salary=Decimal(basic) if basic else None,
                                      Work_Location=loc, is_active=active, Employee_Type="Full-time")
        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.pay_role = EmployeeRole.objects.create(company=self.co, role_name="Pay", role_code="pay",
                                                    can_view_employees=True, can_view_payroll=True)
        self.view_role = EmployeeRole.objects.create(company=self.co, role_name="V", role_code="v", can_view_employees=True)
        eng, sales = (Department.objects.create(company=self.co, name=n) for n in ("Engineering", "Sales"))
        self.asha = self.mk_emp("EMP001", "Asha", dept=eng, gender="Female", dob=date(1996, 5, 10), doj=date(2022, 1, 10), basic="60000")
        self.ravi = self.mk_emp("EMP002", "Ravi", dept=eng, gender="Male", dob=date(1990, 3, 3), doj=date(2020, 3, 1), basic="90000")
        self.meera = self.mk_emp("EMP003", "Meera", dept=sales, gender="Female", dob=date(1994, 7, 7), doj=date(2023, 6, 1), basic="50000", loc="Mumbai")
        self.karan = self.mk_emp("EMP004", "=cmd|' /C calc'!A0", dept=sales, gender="Male", dob=date(1988, 1, 1), doj=date(2019, 2, 1), basic="70000", loc="Mumbai")
        self.hr = self.mk_emp("EMP100", "Elena", role=self.hr_role)
        self.payu = self.mk_emp("EMP101", "Payman", role=self.pay_role)
        self.viewer = self.mk_emp("EMP102", "Viewer", role=self.view_role)
        self.stranger = self.mk_emp("EMP103", "Stranger")
        self.outsider = EmployeeDT.objects.create(company=self.other, employee_code="EMP900", name="Out", email="o@x.com")
        ReportingHierarchy.objects.create(company=self.co, Employee_ID="EMP001", manager_code="EMP002")

        self.admin = client_for(company_token(self.co))
        self.hr_c = client_for(employee_token(self.hr))
        self.pay_c = client_for(employee_token(self.payu))
        self.view_c = client_for(employee_token(self.viewer))
        self.str_c = client_for(employee_token(self.stranger))
        self.asha_c = client_for(employee_token(self.asha))
        self.ravi_c = client_for(employee_token(self.ravi))
        self.other_admin = client_for(company_token(self.other))

    # ---- data seeders ----
    def seed_payroll(self):
        for (m, vals) in ((8, (62000, 91000, 50000, 72000)), (9, (65000, 95000, 52000, 74000))):
            for e, g in zip((self.asha, self.ravi, self.meera, self.karan), vals):
                Payroll.objects.create(Employee_ID=e.employee_code, name=e.name, company=self.co, month=m, year=2026,
                                       basic_salary=e.Basic_Salary, present_days=22, gross_salary=Decimal(g),
                                       total_deductions=Decimal("5000"), net_salary=Decimal(g - 5000))

    def seed_attendance(self):
        for e, days, absent, late in ((self.asha, 22, 2, 2), (self.ravi, 22, 0, 0)):
            for i in range(days):
                d = date(2026, 9, 1) + timedelta(days=i)
                AttendanceEmp.objects.create(Employee_ID=e.employee_code, company=self.co, Name=e.name, date=d, status="Present")
                t = "10:30:00" if (e is self.asha and i < late) else "09:20:00"
                EMP_check_in_check_out.objects.create(Employee_ID=e.employee_code, company=self.co, Name=e.name, login_date=d, login_time=t)
            for j in range(absent):
                AttendanceEmp.objects.create(Employee_ID=e.employee_code, company=self.co, Name=e.name,
                                             date=date(2026, 9, 25) + timedelta(days=j), status="Absent")

    def seed_leave(self):
        ensure_default_policies(self.co)
        self.pol = LeavePolicy.objects.filter(company=self.co, annual_quota__gt=0).first()
        self.pol.annual_quota, self.pol.encashable, self.pol.max_encashable_days = Decimal("10"), True, Decimal("6")
        self.pol.save()
        LeaveRequest.objects.create(company=self.co, Employee_ID="EMP001", Name="Asha", leave_type=self.pol.leave_type,
                                    from_date=date(2026, 9, 8), to_date=date(2026, 9, 12), total_days=Decimal("5"), status="Approved")
        LeaveRequest.objects.create(company=self.co, Employee_ID="EMP001", Name="Asha", leave_type=self.pol.leave_type,
                                    from_date=date(2026, 10, 1), to_date=date(2026, 10, 1), total_days=Decimal("1"), status="Pending")

    def seed_recruitment(self):
        now = timezone.now()
        spec = [("LinkedIn", "JOINED", True, "Accepted"), ("LinkedIn", "INTERVIEW", True, "Declined"),
                ("LinkedIn", "APPLIED", False, None), ("Referral", "OFFER_ACCEPTED", True, "Accepted")]
        for i, (src, stage, interviewed, offer) in enumerate(spec, 1):
            c = EmployeeDT.objects.create(company=self.co, employee_code=f"CAN{i}", name=f"Cand{i}", email=f"c{i}@x.com",
                                          candidate_id=f"CAN-30{i}", candidate_source=src, candidate_status=stage,
                                          applied_position="Dev")
            p = CandidateProfile.objects.create(company=self.co, candidate=c)
            CandidateProfile.objects.filter(pk=p.pk).update(created_at=now - timedelta(days=18))
            if interviewed:
                InterviewRound.objects.create(company=self.co, interview_id=f"INT-{i}", candidate=c, round_name="R1", scheduled_at=now)
            if offer:
                Offer.objects.create(company=self.co, offer_id=f"OFF-{i}", candidate=c, offered_ctc_lpa=Decimal("12"),
                                     status=offer, sent_at=now)
            if stage == "JOINED":
                StageHistory.objects.create(company=self.co, candidate=c, to_stage="JOINED")

    def seed_training(self):
        pr = TrainingProgram.objects.create(company=self.co, code="TRN-01", title="Cloud Native Architecture & Kubernetes",
                                            trainer_name="External Specialist", duration_hours=Decimal("16"), status="Ongoing",
                                            category="Technical", audience_label="Engineers", start_date=date(2026, 9, 1))
        TrainingProgram.objects.create(company=self.co, code="TRN-02", title="Leadership", duration_hours=Decimal("12"),
                                       status="Completed", category="Leadership", start_date=date(2026, 5, 1))
        sess = TrainingSession.objects.create(company=self.co, program=pr, title="Day 1", session_date=date(2026, 9, 10))
        for e, hrs, fb, st in ((self.asha, "16", "4.5", "Completed"), (self.ravi, "8", "5.0", "Completed"), (self.meera, "0", None, "Enrolled")):
            en = TrainingEnrollment.objects.create(company=self.co, program=pr, employee=e, status=st, feedback_rating=fb,
                                                   completed_on=date(2026, 9, 12) if fb else None)
            if Decimal(hrs):
                TrainingAttendance.objects.create(company=self.co, session=sess, enrollment=en, status="Present", hours_attended=Decimal(hrs))
        en = TrainingEnrollment.objects.get(employee=self.asha)
        TrainingCertificate.objects.create(company=self.co, employee=self.asha, program=pr, enrollment=en,
                                           certificate_no="CERT-1", verification_code="V1", title="Cloud", issued_on=date(2026, 9, 12))

    def seed_perf(self):
        for e, r in ((self.asha, "5.0"), (self.ravi, "4.2"), (self.meera, "4.6"), (self.karan, "3.4"), (self.hr, "2.5")):
            rt = Decimal(r)
            PerfRatingHistory.objects.create(company=self.co, employee=e, financial_year="2026-27", rating=rt,
                                             rating_bucket=int(rt), period_label="H1 2026", source="manual")

    def seed_exits(self):
        spec = [("EMP201", "Relocation"), ("EMP202", "Relocation"), ("EMP203", "Compensation")]
        for code, reason in spec:
            e = self.mk_emp(code, f"Ex{code}", doj=date(2020, 1, 1), active=False)
            x = ExitClearance.objects.create(company=self.co, employee=e, resignation_date=date(2026, 7, 1),
                                             last_working_day=date(2026, 8, 15), status="Completed", items=[])
            ExitInterview.objects.create(company=self.co, exit=x, status="Completed", reason_for_leaving=reason, overall_rating=Decimal("4"))


class AuthTests(RBase):
    TABS = ("hr-mis", "recruitment", "attendance", "leave", "payroll", "employees", "performance", "training", "exit")

    def test_matrix(self):
        for url in [f"{R}/meta/"] + [f"{R}/{t}/" for t in self.TABS] + [f"{R}/benchmarks/", f"{R}/exit-reason-groups/", f"{R}/exports/"]:
            self.assertEqual(APIClient().get(url).status_code, 401, url)
            self.assertEqual(self.str_c.get(url).status_code, 403, url)
            expect_view = 403 if url.endswith("/payroll/") else 200
            self.assertEqual(self.view_c.get(url).status_code, expect_view, url)
            self.assertEqual(self.admin.get(url).status_code, 200, url)
        self.assertEqual(self.pay_c.get(f"{R}/payroll/").status_code, 200)

    def test_write_permissions_and_isolation(self):
        body = {"key": "x_target", "value": 5}
        self.assertEqual(self.view_c.post(f"{R}/benchmarks/", body, format="json").status_code, 403)
        self.assertEqual(self.hr_c.post(f"{R}/benchmarks/", body, format="json").status_code, 201)
        bid = self.hr_c.get(f"{R}/benchmarks/").json()["data"][0]["id"]
        self.assertEqual(self.other_admin.get(f"{R}/benchmarks/{bid}/").status_code, 404)
        self.assertEqual(self.other_admin.get(f"{R}/benchmarks/").json()["meta"]["total"], 0)
        self.assertEqual(self.view_c.delete(f"{R}/benchmarks/{bid}/").status_code, 403)

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

    def test_bad_period_params(self):
        for q in ("financial_year=bad", "month=2026-13", "from=2026-05-01&to=2026-01-01"):
            self.assertEqual(self.admin.get(f"{R}/hr-mis/?{q}").status_code, 400, q)


class HrMisTests(RBase):
    def test_cards_and_department_table(self):
        self.seed_payroll()
        self.seed_exits()
        d = self.admin.get(f"{R}/hr-mis/?{FY}").json()["data"]
        c = d["cards"]
        self.assertEqual(c["active_headcount"]["value"], 8)
        # 3 exits; start headcount = 8 - 0 joins + 3 = 11; avg 9.5 -> 31.6 %
        self.assertEqual(c["annual_attrition_rate"]["value"], 31.6)
        self.assertEqual(c["annual_attrition_rate"]["caption"], "Industry benchmark: 14%")
        self.assertEqual(c["monthly_payroll_outflow"]["value"], 286000.0)
        self.assertEqual(c["monthly_payroll_outflow"]["label"], "₹2.9 Lakhs")
        rows = {r["department"]: r for r in d["department_table"]["rows"]}
        self.assertEqual((rows["Engineering"]["headcount"], rows["Sales"]["headcount"], rows["Unassigned"]["headcount"]), (2, 2, 4))
        self.assertEqual(rows["Engineering"]["percent_of_total"], 25.0)
        self.assertEqual(rows["Engineering"]["monthly_wage_bill"], 160000.0)
        self.assertEqual(d["department_table"]["wage_source"], "payroll")

    def test_payroll_masked_without_payroll_permission(self):
        self.seed_payroll()
        c = self.view_c.get(f"{R}/hr-mis/?{FY}").json()["data"]
        self.assertTrue(c["cards"]["monthly_payroll_outflow"]["restricted"])
        self.assertIsNone(c["cards"]["monthly_payroll_outflow"]["value"])
        self.assertIsNone(c["department_table"]["rows"][0]["monthly_wage_bill"])
        self.assertTrue(self.pay_c.get(f"{R}/hr-mis/?{FY}").json()["data"]["cards"]["monthly_payroll_outflow"]["value"])

    def test_time_to_hire_and_benchmark_override(self):
        self.seed_recruitment()
        d = self.admin.get(f"{R}/hr-mis/?from=2026-01-01&to=2099-12-31").json()["data"]
        self.assertEqual(d["cards"]["recruitment_turnaround"]["value"], 18.0)
        self.assertEqual(d["cards"]["recruitment_turnaround"]["label"], "18 Days")
        self.admin.post(f"{R}/benchmarks/", {"key": "industry_attrition_percent", "value": 12.5}, format="json")
        d = self.admin.get(f"{R}/hr-mis/?{FY}").json()["data"]
        self.assertEqual(d["cards"]["annual_attrition_rate"]["caption"], "Industry benchmark: 12.5%")


class TabTests(RBase):
    def test_recruitment(self):
        self.seed_recruitment()
        d = self.admin.get(f"{R}/recruitment/?from=2026-01-01&to=2099-12-31").json()["data"]
        ch = {r["source_channel"]: r for r in d["channels"]}
        li = ch["LinkedIn"]
        self.assertEqual((li["total_applied"], li["interviewed"], li["offers_released"], li["offers_accepted"]), (3, 2, 2, 1))
        self.assertEqual(li["offer_acceptance_percent"], 50.0)
        self.assertEqual(ch["Referral"]["offer_acceptance_label"], "100%")
        self.assertEqual(d["totals"]["applied"], 4)
        self.assertEqual(d["time_to_hire"]["average_days"], 18.0)
        self.assertEqual({f["stage"]: f["count"] for f in d["funnel"]}["JOINED"], 1)

    def test_attendance(self):
        self.seed_attendance()
        d = self.admin.get(f"{R}/attendance/?month=2026-09&muster=true").json()["data"]
        self.assertEqual(d["punctuality"]["check_ins"], 44)
        self.assertEqual(d["punctuality"]["on_time_check_ins"], 42)
        self.assertEqual(d["punctuality"]["rate_percent"], 95.5)
        self.assertEqual(d["punctuality"]["late_cutoff_time"], "09:45")
        self.assertEqual(d["summary"]["present"], 44)
        self.assertEqual(d["summary"]["absent"], 2)
        self.assertEqual(d["insight"], "Average workforce punctuality rate is 95.5% across all 1 regional hub.")
        m = {r["employee_code"]: r for r in d["muster"]["results"]}
        self.assertEqual(m["EMP001"]["punctuality_percent"], 90.9)
        self.assertEqual(m["EMP001"]["attendance_rate_percent"], 91.7)
        self.assertEqual(d["by_department"][0]["department"], "Engineering")
        narrowed = self.admin.get(f"{R}/attendance/?month=2026-09&employee_code=EMP002").json()["data"]
        self.assertEqual(narrowed["punctuality"]["rate_percent"], 100.0)
        self.admin.post(f"{R}/benchmarks/", {"key": "office_start_minutes", "value": 540}, format="json")   # 09:00 + 15
        strict = self.admin.get(f"{R}/attendance/?month=2026-09").json()["data"]
        self.assertEqual(strict["punctuality"]["late_cutoff_time"], "09:15")
        self.assertEqual(strict["punctuality"]["rate_percent"], 0.0)

    def test_leave_liability(self):
        self.seed_leave()
        d = self.admin.get(f"{R}/leave/?{FY}").json()["data"]
        # Asha: 10 - 5 approved - 1 pending = 4 -> 4 days x 2000; others 6 days: Ravi 18000, Meera 10000, Karan 14000
        self.assertEqual(d["liability"]["total_amount"], 8000 + 18000 + 10000 + 14000.0)
        t = {r["leave_type"]: r for r in d["by_leave_type"]}[self.pol.leave_type]
        self.assertEqual((t["requests"], t["approved_days"], t["pending_days"]), (2, 5.0, 1.0))
        self.assertTrue(t["encashable"])
        self.assertIn("projected at", d["insight"])
        self.assertEqual(d["monthly_trend"], [{"month": "2026-09", "approved_days": 5.0}])
        self.assertTrue(d["liability"]["as_of_label"].startswith("Q"))

    def test_payroll_tab(self):
        self.seed_payroll()
        d = self.pay_c.get(f"{R}/payroll/?{FY}").json()["data"]
        self.assertEqual(d["totals"]["gross"], 275000 + 286000.0)
        self.assertEqual(d["monthly_trend"][1]["mom_variance_percent"], 4.0)
        self.assertFalse(d["budget"]["configured"])
        self.assertIn("No annual payroll budget", d["insight"])
        self.admin.post(f"{R}/benchmarks/", {"key": "annual_payroll_budget", "value": 6000000, "financial_year": "2026-27"}, format="json")
        d = self.pay_c.get(f"{R}/payroll/?{FY}").json()["data"]
        self.assertEqual(d["budget"]["projected_annual_gross"], 3366000.0)       # 561000 / 2 months x 12
        self.assertEqual(d["budget"]["tracking_percent"], 56.1)
        self.assertEqual(d["insight"], "Gross annual payroll budget tracking at 56.1% of initial FY2026 forecast.")
        dept = {r["department"]: r for r in d["by_department_latest_month"]}
        self.assertEqual(dept["Engineering"]["gross"], 160000.0)

    def test_employees_tab(self):
        d = self.admin.get(f"{R}/employees/").json()["data"]
        self.assertEqual(d["headcount"], 8)
        self.assertEqual(d["gender_diversity"]["counts"]["Female"], 2)
        self.assertEqual(d["gender_diversity"]["percent"], {"Female": 50.0, "Male": 50.0})
        self.assertEqual(d["gender_diversity"]["unspecified"], 4)
        self.assertTrue(d["average_employee_tenure"]["label"].endswith("Years"))
        self.assertEqual(sum(b["count"] for b in d["age_bands"]), 4)

    def test_performance_tab(self):
        self.seed_perf()
        d = self.admin.get(f"{R}/performance/?{FY}").json()["data"]
        by = {r["rating"]: r for r in d["distribution"]}
        self.assertEqual((by[5]["percent"], by[4]["percent"], by[3]["percent"], by[2]["percent"]), (20.0, 40.0, 20.0, 20.0))
        self.assertEqual(by[4]["title"], "Rating 4 (Exceeds)")
        self.assertEqual(d["total_rated"], 5)
        narrowed = self.admin.get(f"{R}/performance/?{FY}&employee_code=EMP001,EMP002").json()["data"]
        self.assertEqual(narrowed["total_rated"], 2)

    def test_training_tab(self):
        self.seed_training()
        d = self.admin.get(f"{R}/training/?{FY}").json()["data"]
        c = d["cards"]
        self.assertEqual(c["training_hours_logged"]["label"], "24 Hrs")
        self.assertEqual((c["certificates_issued"]["value"], c["certificates_issued"]["caption"]), (1, "100% verified credentials"))
        self.assertEqual((c["active_courses"]["value"], c["active_courses"]["caption"]), (1, "Technical"))
        self.assertEqual(c["average_satisfaction"]["label"], "4.8 / 5.0")
        row = {r["code"]: r for r in d["catalog"]}["TRN-01"]
        self.assertEqual((row["duration_label"], row["enrolled_label"], row["status"]), ("16 Hours", "3 Engineers", "Ongoing"))
        self.assertEqual(len(d["catalog"]), 2)

    def test_exit_tab_defaults_then_saved_groups(self):
        self.seed_exits()
        d = self.admin.get(f"{R}/exit/?{FY}").json()["data"]
        self.assertFalse(d["groups_configured"])
        rows = {r["primary_exit_reason"]: r for r in d["rows"]}
        self.assertEqual(rows["Higher Education / Relocation"]["percent_of_total_exits"], 66.7)
        self.assertEqual(rows["Compensation / External Offer"]["preventable_label"], "65%")
        self.assertEqual(rows["Compensation / External Offer"]["key_retention_recommendation"], "Align tech bands to 75th percentile benchmark")
        self.assertEqual(d["interview_coverage_percent"], 100.0)
        r = self.admin.post(f"{R}/exit-reason-groups/seed-defaults/", {}, format="json")
        self.assertEqual(r.status_code, 201)
        self.assertEqual(self.admin.post(f"{R}/exit-reason-groups/seed-defaults/", {}, format="json").status_code, 409)
        self.assertTrue(self.admin.get(f"{R}/exit/?{FY}").json()["data"]["groups_configured"])


class CrudTests(RBase):
    def test_benchmarks_crud(self):
        r = self.admin.post(f"{R}/benchmarks/", {"key": "industry_attrition_percent", "value": 14, "unit": "%",
                                                  "label": "Industry"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        bid = r.json()["data"]["id"]
        self.assertEqual(self.admin.post(f"{R}/benchmarks/", {"key": "industry_attrition_percent", "value": 9}, format="json").status_code, 409)
        fyrow = self.admin.post(f"{R}/benchmarks/", {"key": "industry_attrition_percent", "value": 9, "financial_year": "2026-27"}, format="json")
        self.assertEqual(fyrow.status_code, 201)                      # same key, different FY is allowed
        for bad in ({"key": "Bad Key", "value": 1}, {"key": "ok_key"}, {"key": "ok_key", "value": "x"},
                    {"key": "ok_key", "value": 1, "financial_year": "2026"}):
            self.assertEqual(self.admin.post(f"{R}/benchmarks/", bad, format="json").status_code, 400, bad)
        r = self.admin.patch(f"{R}/benchmarks/{bid}/", {"value": 15, "notes": "NASSCOM"}, format="json")
        self.assertEqual(r.json()["data"]["value"], 15.0)
        self.assertEqual(self.admin.patch(f"{R}/benchmarks/{bid}/", {"key": "other"}, format="json").status_code, 400)
        self.assertEqual(self.admin.patch(f"{R}/benchmarks/{fyrow.json()['data']['id']}/", {"financial_year": "2027-28"}, format="json").status_code, 400)
        self.assertEqual(self.admin.post(f"{R}/benchmarks/{bid}/update/", {"unit": "percent"}, format="json").status_code, 200)
        eff = {b["key"]: b for b in self.admin.get(f"{R}/benchmarks/effective/?{FY}").json()["data"]["benchmarks"]}
        self.assertEqual((eff["industry_attrition_percent"]["effective_value"], eff["industry_attrition_percent"]["source"]), (9.0, "saved"))
        self.assertEqual(eff["punctuality_grace_minutes"]["source"], "default")
        self.assertEqual(eff["annual_payroll_budget"]["source"], "not set")
        self.assertEqual(self.admin.get(f"{R}/benchmarks/?key=industry_attrition_percent&{FY}").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.delete(f"{R}/benchmarks/{bid}/").status_code, 200)
        self.assertEqual(self.admin.post(f"{R}/benchmarks/", {"key": "industry_attrition_percent", "value": 14}, format="json").status_code, 201)

    def test_exit_reason_groups_crud_and_no_double_counting(self):
        body = {"name": "Compensation", "reasons": ["Compensation", "Better Opportunity"], "preventable_percent": 65,
                "recommendation": "Align bands"}
        r = self.admin.post(f"{R}/exit-reason-groups/", body, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        gid = r.json()["data"]["id"]
        self.assertEqual(self.admin.post(f"{R}/exit-reason-groups/", {**body, "reasons": ["Health"]}, format="json").status_code, 409)   # name
        r = self.admin.post(f"{R}/exit-reason-groups/", {"name": "Pay 2", "reasons": ["Compensation"], "preventable_percent": 1}, format="json")
        self.assertEqual(r.status_code, 409)                                                           # reason already mapped
        self.assertIn("Compensation", r.json()["message"])
        for bad in ({"name": "X", "reasons": []}, {"name": "X", "reasons": ["Nope"]}, {"name": "X", "reasons": ["Health", "Health"]},
                    {"name": "X", "reasons": ["Health"], "preventable_percent": 120}, {"reasons": ["Health"]}):
            self.assertEqual(self.admin.post(f"{R}/exit-reason-groups/", bad, format="json").status_code, 400, bad)
        r = self.admin.patch(f"{R}/exit-reason-groups/{gid}/", {"preventable_percent": 70, "reasons": ["Compensation"]}, format="json")
        self.assertEqual((r.status_code, r.json()["data"]["preventable_percent"]), (200, 70.0))
        cov = self.admin.get(f"{R}/exit-reason-groups/coverage/").json()["data"]
        self.assertIn("Better Opportunity", cov["unmapped"])
        self.assertNotIn("Compensation", cov["unmapped"])
        self.assertEqual(self.admin.delete(f"{R}/exit-reason-groups/{gid}/").status_code, 200)
        self.assertEqual(self.admin.get(f"{R}/exit-reason-groups/{gid}/").status_code, 404)

    def test_unmapped_reasons_become_other_row(self):
        self.seed_exits()
        self.admin.post(f"{R}/exit-reason-groups/", {"name": "Comp", "reasons": ["Compensation"], "preventable_percent": 50}, format="json")
        rows = {r["primary_exit_reason"]: r for r in self.admin.get(f"{R}/exit/?{FY}").json()["data"]["rows"]}
        self.assertEqual(rows["Other / Unclassified"]["reasons"], ["Relocation"])
        self.assertEqual(rows["Comp"]["percent_of_total_exits"], 33.3)

    def test_exports_lifecycle(self):
        r = self.view_c.post(f"{R}/exports/", {"report_type": "employee_master"}, format="json")
        self.assertEqual(r.status_code, 403)
        r = self.hr_c.post(f"{R}/exports/", {"report_type": "employee_master", "file_format": "csv", "title": "Master Oct"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        x = r.json()["data"]
        self.assertEqual((x["row_count"], x["file_format"], x["status"]), (8, "csv", "Completed"))
        dl = self.view_c.get(x["download_url"])
        self.assertEqual(dl.status_code, 200)
        text = b"".join(dl.streaming_content).decode("utf-8-sig")
        rows = list(csv.reader(io.StringIO(text)))
        self.assertEqual(rows[0][:3], ["Employee Code", "Name", "Email"])
        self.assertNotIn("Aadhaar", rows[0])
        self.assertTrue(all("pan" not in h.lower() and "bank" not in h.lower() and "salary" not in h.lower() for h in rows[0]))
        self.assertIn("'=cmd|' /C calc'!A0", [r[1] for r in rows[1:]])         # formula injection neutralised
        self.assertEqual(self.admin.get(f"{R}/exports/{x['id']}/").json()["data"]["download_count"], 1)
        # edit only title / notes
        self.assertEqual(self.admin.patch(f"{R}/exports/{x['id']}/", {"file_format": "xlsx"}, format="json").status_code, 400)
        self.assertEqual(self.admin.patch(f"{R}/exports/{x['id']}/", {"notes": "for audit"}, format="json").json()["data"]["notes"], "for audit")
        # filters + xlsx + regenerate
        r = self.admin.post(f"{R}/exports/", {"report_type": "employee_master", "file_format": "xlsx",
                                              "filters": {"department": "Engineering"}}, format="json")
        self.assertEqual((r.status_code, r.json()["data"]["row_count"]), (201, 2))
        self.assertTrue(r.json()["data"]["file_name"].endswith(".xlsx"))
        import openpyxl
        wb = openpyxl.load_workbook(io.BytesIO(b"".join(self.admin.get(r.json()["data"]["download_url"]).streaming_content)))
        self.assertEqual(wb.active["A1"].value, "Employee Code")
        self.assertEqual(wb.active.max_row, 3)
        eid = r.json()["data"]["id"]
        Department.objects.filter(name="Engineering").update(name="Eng")
        self.assertEqual(self.admin.post(f"{R}/exports/{eid}/regenerate/", {}, format="json").json()["data"]["row_count"], 0)
        # list filters, isolation, delete removes the file
        self.assertEqual(self.admin.get(f"{R}/exports/?report_type=employee_master&file_format=csv").json()["meta"]["total"], 1)
        self.assertEqual(self.other_admin.get(f"{R}/exports/{x['id']}/download/").status_code, 404)
        path = ReportExport.objects.get(pk=x["id"]).file.path
        import os
        self.assertTrue(os.path.exists(path))
        self.assertEqual(self.admin.delete(f"{R}/exports/{x['id']}/").status_code, 200)
        self.assertFalse(os.path.exists(path))
        self.assertEqual(self.admin.get(f"{R}/exports/{x['id']}/download/").status_code, 404)

    def test_export_validation_and_recruitment(self):
        for bad in ({"report_type": "nope"}, {"report_type": "employee_master", "file_format": "pdf"},
                    {"report_type": "employee_master", "filters": {"status": "weird"}}, {"report_type": "employee_master", "filters": [1]},
                    {"report_type": "employee_master", "filters": {"joined_from": "bad"}}):
            self.assertEqual(self.admin.post(f"{R}/exports/", bad, format="json").status_code, 400, bad)
        self.seed_recruitment()
        r = self.admin.post(f"{R}/exports/", {"report_type": "recruitment_data", "filters": {"source": "linkedin"}}, format="json")
        self.assertEqual((r.status_code, r.json()["data"]["row_count"]), (201, 3))
        rows = list(csv.reader(io.StringIO(b"".join(self.admin.get(r.json()["data"]["download_url"]).streaming_content).decode("utf-8-sig"))))
        self.assertEqual(rows[0][0:2], ["Candidate Code", "Name"])
        self.assertIn("Accepted", [c for row in rows[1:] for c in row])
        self.assertEqual(ReportExport.objects.count(), 1)               # failed validations stored nothing


class EmployeeSelfServiceTests(RBase):
    def test_my_reports_are_own_data_only(self):
        self.seed_attendance()
        self.seed_leave()
        self.seed_payroll()
        self.seed_training()
        self.seed_perf()
        a = self.asha_c.get(f"{ME}/attendance/?month=2026-09").json()["data"]
        self.assertEqual(a["summary"]["present"], 22)
        self.assertEqual(a["punctuality"]["rate_percent"], 90.9)
        self.assertEqual([m["employee_code"] for m in a["muster"]["results"]], ["EMP001"])
        lv = self.asha_c.get(f"{ME}/leave/?{FY}").json()["data"]
        self.assertEqual(lv["liability"]["total_amount"], 8000.0)
        pr = self.asha_c.get(f"{ME}/payroll/?{FY}").json()["data"]
        self.assertEqual(pr["totals"]["gross"], 62000 + 65000.0)
        self.assertEqual(pr["budget"]["annual_budget"], None)
        self.assertEqual(pr["insight"], "Payroll summary for the selected employee(s).")
        tr = self.asha_c.get(f"{ME}/training/?{FY}").json()["data"]
        self.assertEqual(tr["cards"]["training_hours_logged"]["label"], "16 Hrs")
        self.assertEqual(tr["cards"]["certificates_issued"]["value"], 1)
        pf = self.asha_c.get(f"{ME}/performance/?{FY}").json()["data"]
        self.assertEqual(pf["total_rated"], 1)
        s = self.asha_c.get(f"{ME}/summary/?month=2026-09").json()["data"]
        self.assertEqual(s["employee"]["employee_code"], "EMP001")
        self.assertEqual(s["payroll"]["months_processed"], 1)          # summary was asked for 2026-09 only
        # another employee sees different, own numbers
        self.assertEqual(self.str_c.get(f"{ME}/attendance/?month=2026-09").json()["data"]["summary"]["present"], 0)
        self.assertEqual(self.str_c.get(f"{ME}/payroll/?{FY}").json()["data"]["totals"]["gross"], 0.0)

    def test_team_reports_for_managers(self):
        self.seed_attendance()
        self.seed_perf()
        self.seed_leave()
        t = self.ravi_c.get(f"{ME}/team/attendance/?month=2026-09").json()["data"]
        self.assertEqual([m["employee_code"] for m in t["muster"]["results"]], ["EMP001"])
        self.assertEqual(t["summary"]["present"], 22)
        s = self.ravi_c.get(f"{ME}/team/summary/?{FY}").json()["data"]
        self.assertEqual(s["team_size"], 1)
        p = self.ravi_c.get(f"{ME}/team/performance/?{FY}").json()["data"]
        self.assertEqual(p["total_rated"], 1)
        self.assertEqual(self.ravi_c.get(f"{ME}/team/leave/?{FY}").status_code, 200)
        self.assertEqual(self.ravi_c.get(f"{ME}/team/training/?{FY}").status_code, 200)
        # non managers are refused, payroll is never exposed for a team
        for t in ("summary", "attendance", "leave", "training", "performance"):
            r = self.str_c.get(f"{ME}/team/{t}/")
            self.assertEqual((r.status_code, r.json()["code"]), (403, "NOT_A_MANAGER"), t)
        self.assertEqual(self.ravi_c.get(f"{ME}/team/payroll/").status_code, 404)
        self.assertEqual(self.ravi_c.get(f"{ME}/attendance/?month=bad").status_code, 400)
