# Statutory Compliance & Legal Governance tests.   python manage.py test People.tests_compliance
from datetime import timedelta
from decimal import Decimal

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase
from django.utils import timezone
from rest_framework.test import APIClient

from Employee.models import Department, EmployeeDT, EmployeeRole, Payroll

from .models import Branch, EmployeeExtra
from .tests import MEDIA, client, mk_company

A = "/api/compliance"
E = "/employee/compliance"
TODAY = timezone.localdate()


def pdf(name="doc.pdf"):
    return SimpleUploadedFile(name, b"%PDF-1.4 compliance", content_type="application/pdf")


def prev_month(n=1):
    y, m = TODAY.year, TODAY.month - n
    while m <= 0:
        y, m = y - 1, m + 12
    return y, m


@MEDIA
class ComplianceTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("c@x.com"), mk_company("d@x.com")
        self.a, self.o = client(self.co), client(self.other)
        self.pune = Branch.objects.create(company=self.co, name="Pune HQ")
        self.mum = Branch.objects.create(company=self.co, name="Mumbai BKC")
        self.dept = Department.objects.create(company=self.co, name="Technology")
        self.emps = {}
        for k, n in (("rahul", "Rahul Sharma"), ("priya", "Priya Nair"), ("elena", "Elena Rostova"),
                     ("viewer", "Vik Viewer")):
            r = self.a.post("/api/people/directory/", {
                "name": n, "email": f"{k}@x.com", "designation": "Engineer", "department": self.dept.id,
                "date_of_joining": str(TODAY - timedelta(days=500)), "create_login": True, "password": "pw123456"},
                format="json")
            self.assertEqual(r.status_code, 201, r.content)
            self.emps[k] = EmployeeDT.objects.get(employee_code=r.json()["data"]["employee_code"])
        r = self.emps["rahul"]
        r.pf_number, r.esi_number, r.pan_number, r.PF_Percentage, r.TDS_Percentage = "MHPUN001/001", "3100012345", "ABCDE1234F", 12, 5
        r.save()
        EmployeeExtra.objects.filter(employee=r).update(uan_number="100200300400")
        self.emps["priya"].PF_Percentage = 12
        self.emps["priya"].save()
        role = EmployeeRole.objects.create(company=self.co, role_name="Payroll", role_code="pay", can_manage_payroll=True)
        ro = EmployeeRole.objects.create(company=self.co, role_name="RO", role_code="ro", can_view_payroll=True)
        self.emps["elena"].role = role
        self.emps["viewer"].role = ro
        self.rahul, self.priya = client(self.emps["rahul"]), client(self.emps["priya"])
        self.hr, self.viewer = client(self.emps["elena"]), client(self.emps["viewer"])
        py, pm = prev_month(1)
        for emp, pf, esi, tds in ((self.emps["rahul"], 1800, 150, 2500), (self.emps["priya"], 1800, 0, 0)):
            Payroll.objects.create(Employee_ID=emp.employee_code, name=emp.name, company=self.co, month=pm, year=py,
                                   gross_salary=Decimal("50000"), PF_deduction=pf, ESI_deduction=esi, TDS_deduction=tds,
                                   total_deductions=pf + esi + tds, net_salary=Decimal("45000"))

    def j(self, r, code):
        self.assertEqual(r.status_code, code, r.content)
        return r.json()

    def reg(self, **kw):
        d = {"reg_type": "PF", "number": "MHPUN0012345000"}
        d.update(kw)
        return self.j(self.a.post(f"{A}/registrations/", d, format="json"), 201)["data"]

    # ------------------------------------------------------------------ auth
    def test_authentication_and_authorization(self):
        urls = [f"{A}/{x}/" for x in ("dashboard", "pf", "esi", "pt", "tds", "labour", "alerts", "meta",
                                      "registrations", "filings", "documents", "licenses", "inspections",
                                      "reminders", "form16")]
        anon = APIClient()
        for u in urls:
            self.assertEqual(anon.get(u).status_code, 401, u)
            self.assertEqual(self.rahul.get(u).status_code, 403, u)       # employee without payroll/employees role
            self.assertEqual(self.a.get(u).status_code, 200, u)
            self.assertEqual(self.hr.get(u).status_code, 200, u)          # payroll manager
            self.assertEqual(self.viewer.get(u).status_code, 200, u)      # payroll view-only
            self.assertEqual(self.o.get(u).status_code, 200, u)
        body = {"reg_type": "PF", "number": "X1"}
        self.assertEqual(self.viewer.post(f"{A}/registrations/", body, format="json").status_code, 403)
        self.assertEqual(self.hr.post(f"{A}/registrations/", body, format="json").status_code, 201)
        rid = self.hr.get(f"{A}/registrations/").json()["data"][0]["id"]
        self.assertEqual(self.viewer.delete(f"{A}/registrations/{rid}/").status_code, 403)
        # company isolation
        self.assertEqual(self.o.get(f"{A}/registrations/{rid}/").status_code, 404)
        self.assertEqual(self.o.patch(f"{A}/registrations/{rid}/", {"number": "Z"}, format="json").status_code, 404)
        self.assertEqual(self.o.get(f"{A}/registrations/").json()["data"], [])
        for u in (f"{E}/profile/", f"{E}/deductions/", f"{E}/form16/"):
            self.assertEqual(anon.get(u).status_code, 401, u)
            self.assertEqual(self.a.get(u).status_code, 403, u)           # company admin token is not an employee
            self.assertEqual(self.rahul.get(u).status_code, 200, u)

    # --------------------------------------------------------- registrations
    def test_registrations(self):
        pf = self.reg(state="Maharashtra", branch=self.pune.id, valid_until=str(TODAY + timedelta(days=400)))
        self.assertEqual(pf["due_day"], 15)
        pt = self.reg(reg_type="PT", number="27123456789P", state="Maharashtra", state_code="mh")
        self.assertEqual((pt["state_code"], pt["due_day"]), ("MH", 0))
        for bad in ({"reg_type": "PF", "number": "mhpun0012345000"}, {"reg_type": "NOPE", "number": "1"},
                    {"reg_type": "PF", "number": ""}, {"reg_type": "PF", "number": "2", "branch": 99999},
                    {"reg_type": "PF", "number": "3", "due_day": 40},
                    {"reg_type": "PF", "number": "4", "registered_on": "2026-05-01", "valid_until": "2026-01-01"}):
            self.assertEqual(self.a.post(f"{A}/registrations/", bad, format="json").status_code, 400, bad)
        self.assertEqual(len(self.a.get(f"{A}/registrations/?reg_type=PT").json()["data"]), 1)
        self.assertEqual(len(self.a.get(f"{A}/registrations/?search=27123").json()["data"]), 1)
        self.assertEqual(self.a.patch(f"{A}/registrations/{pf['id']}/", {"authority": "EPFO Pune"}, format="json").status_code, 200)
        self.assertEqual(self.a.post(f"{A}/registrations/{pf['id']}/update/", {"due_day": 20}, format="json").json()["data"]["due_day"], 20)
        self.assertEqual(self.a.post(f"{A}/registrations/{pt['id']}/delete/").status_code, 200)
        self.assertEqual(self.a.get(f"{A}/registrations/{pt['id']}/").status_code, 404)

    # --------------------------------------------------------------- filings
    def test_filings_lifecycle(self):
        pf = self.reg(state="Maharashtra")
        pt = self.reg(reg_type="PT", number="PT-1", state="Maharashtra", state_code="MH")
        y, m = prev_month(1)
        c = self.j(self.a.post(f"{A}/filings/", {"filing_type": "PF_ECR", "registration": pf["id"], "period_month": m,
                   "period_year": y, "amount_payable": 3600}, format="json"), 201)["data"]
        self.assertEqual((c["code"], c["description"], c["status"]), ("PF-ECR", "EPF Monthly ECR Filing", "PENDING_PAYMENT"))
        ny, nm = (y + 1, 1) if m == 12 else (y, m + 1)
        self.assertEqual(c["due_date"], f"{ny}-{nm:02d}-15")                       # due day from the registration
        p = self.j(self.a.post(f"{A}/filings/", {"filing_type": "PT", "registration": pt["id"], "period_month": m,
                   "period_year": y, "amount_payable": 2500}, format="json"), 201)["data"]
        self.assertEqual(p["code"], "PT-MH")
        self.assertTrue(p["due_date"].endswith(str(__import__("calendar").monthrange(ny, nm)[1])))     # month end
        # validation + duplicates
        bad = lambda d: self.a.post(f"{A}/filings/", d, format="json").status_code
        self.assertEqual(bad({"filing_type": "PF_ECR", "registration": pf["id"], "period_month": m, "period_year": y}), 400)  # dup
        self.assertEqual(bad({"filing_type": "PF_ECR", "registration": pt["id"], "period_month": 1, "period_year": 2026}), 400)  # wrong reg type
        self.assertEqual(bad({"filing_type": "PF_ECR", "period_month": 13, "period_year": 2026}), 400)
        self.assertEqual(bad({"filing_type": "OTHER", "period_month": 1, "period_year": 2026}), 400)         # needs description
        self.assertEqual(bad({"filing_type": "ZZZ", "period_month": 1, "period_year": 2026}), 400)
        self.assertEqual(bad({"filing_type": "TDS_24Q", "financial_year": "2026-28", "quarter": 1}), 400)
        self.assertEqual(bad({"filing_type": "PF_ECR", "period_month": 1, "period_year": 2026, "amount_payable": -5}), 400)
        # record payment
        fid = c["id"]
        self.assertEqual(self.a.post(f"{A}/filings/{fid}/record_payment/", {}, format="json").status_code, 400)       # challan needed
        r = self.j(self.a.post(f"{A}/filings/{fid}/record_payment/", {"challan_no": "ECR1098475893", "receipt": pdf("chal.pdf")},
                               format="multipart"), 200)["data"]
        self.assertEqual((r["status"], r["status_label"], r["amount_paid"], r["paid_late"]), ("FILED_PAID", "Filed & Paid", 3600.0, __import__("datetime").date.fromisoformat(c["due_date"]) < TODAY))   # date-independent: late only if paid after the due date
        self.assertTrue(r["receipt"]["download_url"])
        self.assertEqual(self.a.get(f"{A}/filings/{fid}/receipt/").status_code, 200)
        self.assertEqual(self.a.post(f"{A}/filings/{fid}/record_payment/", {"challan_no": "X"}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/filings/{p['id']}/record_payment/", {"challan_no": "ecr1098475893"}, format="json").status_code, 400)  # dup challan
        self.assertEqual(self.a.post(f"{A}/filings/{p['id']}/mark_filed/", {}, format="json").json()["data"]["status"], "PENDING_PAYMENT")
        self.assertEqual(self.a.post(f"{A}/filings/{fid}/reopen/").json()["data"]["status"], "PENDING_PAYMENT")
        # tds quarter + generate
        tan = self.reg(reg_type="TDS", number="PNEA12345B")
        t = self.j(self.a.post(f"{A}/filings/", {"filing_type": "TDS_24Q", "registration": tan["id"], "financial_year": "2026-27",
                   "quarter": 1}, format="json"), 201)["data"]
        self.assertEqual((t["due_date"], t["status"].startswith("PENDING")), ("2026-07-31", True))
        self.assertEqual(self.a.post(f"{A}/filings/{t['id']}/record_payment/", {"challan_no": "q"}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/filings/{t['id']}/mark_filed/", {"filed_on": "2026-07-20"}, format="json").json()["data"]["status"], "FILED")
        g = self.j(self.a.post(f"{A}/filings/generate/", {"month": m, "year": y}, format="json"), 200)["data"]
        self.assertEqual((len(g["created"]), len(g["skipped"])), (0, 2))              # PF + PT already exist
        esic = self.reg(reg_type="ESIC", number="31000123450001099")
        g = self.j(self.a.post(f"{A}/filings/generate/", {"month": m, "year": y}, format="json"), 201)["data"]
        self.assertEqual([f["filing_type"] for f in g["created"]], ["ESIC"])
        self.assertEqual(g["created"][0]["amount_payable"], 150.0)                    # from payroll ESI_deduction
        g2 = self.j(self.a.post(f"{A}/filings/generate/", {"financial_year": "2026-27", "quarter": 2}, format="json"), 201)["data"]
        self.assertEqual(g2["created"][0]["due_date"], "2026-10-31")
        self.assertEqual(self.a.post(f"{A}/filings/generate/", {"month": 5}, format="json").status_code, 400)
        calc = self.j(self.a.get(f"{A}/filings/calculate/?month={m}&year={y}"), 200)["data"]
        self.assertEqual((calc["pf_deducted"], calc["esi_deducted"], calc["tds_deducted"], calc["employees"]), (3600.0, 150.0, 2500.0, 2))
        self.assertFalse(self.a.get(f"{A}/filings/calculate/?month=1&year=2001").json()["data"]["payroll_processed"])
        # list filters / update / delete
        self.assertEqual(len(self.a.get(f"{A}/filings/?filing_type=PT").json()["data"]), 1)
        self.assertEqual(len(self.a.get(f"{A}/filings/?search=PF-ECR").json()["data"]), 1)
        self.assertEqual(self.a.patch(f"{A}/filings/{p['id']}/", {"remarks": "Sent to CA", "amount_payable": 4200}, format="json").json()["data"]["amount_payable"], 4200.0)
        self.assertEqual(self.a.post(f"{A}/filings/{p['id']}/delete/").status_code, 200)
        self.assertEqual(self.o.get(f"{A}/filings/{fid}/").status_code, 404)

    # ------------------------------------------------- dashboard + tabs + alerts
    def test_dashboard_tabs_alerts(self):
        d0 = self.j(self.a.get(f"{A}/dashboard/"), 200)["data"]["kpis"]
        self.assertIsNone(d0["compliance_score"]["value"])
        self.assertEqual(d0["pf_active_members"]["value"], 2)                       # rahul (pf no.) + priya (12%)
        self.assertEqual(d0["pf_active_members"]["total_employees"], 4)
        pf = self.reg(state="Maharashtra")
        esic = self.reg(reg_type="ESIC", number="3100ESIC")
        y, m = prev_month(2)
        mk = lambda ft, reg, mm, yy, **kw: self.a.post(f"{A}/filings/", {"filing_type": ft, "registration": reg["id"],
                                                                         "period_month": mm, "period_year": yy, **kw}, format="json").json()["data"]
        old = mk("PF_ECR", pf, m, y)                                     # due ~ last month -> overdue
        done = mk("ESIC", esic, m, y)
        self.a.post(f"{A}/filings/{done['id']}/record_payment/", {"challan_no": "ESI1", "payment_date": done["due_date"]}, format="json")
        py, pm = prev_month(0)
        soon = mk("PF_ECR", pf, pm, py, due_date=str(TODAY + timedelta(days=4)))
        kp = self.j(self.a.get(f"{A}/dashboard/"), 200)
        k = kp["data"]["kpis"]
        self.assertEqual(k["compliance_score"]["filings_due"], 2)
        self.assertEqual((k["compliance_score"]["value"], k["compliance_score"]["overdue"]), (50, 1))
        self.assertEqual(k["next_filing_due"]["date"], soon["due_date"])
        self.assertEqual(k["next_filing_due"]["days_left"], 4)
        self.assertEqual(len(kp["data"]["filings"]), 3)
        self.assertEqual(kp["meta"]["total"], 3)
        self.assertEqual(len(self.a.get(f"{A}/dashboard/?status=FILED_PAID").json()["data"]["filings"]), 1)
        # penalties flow into the score card
        self.a.patch(f"{A}/filings/{old['id']}/", {"penalty_amount": 500}, format="json")
        self.assertIn("500", self.a.get(f"{A}/dashboard/").json()["data"]["kpis"]["compliance_score"]["subtitle"])
        # alerts
        al = self.j(self.a.get(f"{A}/alerts/"), 200)
        kinds = [a["kind"] for a in al["data"]]
        self.assertEqual(kinds[0], "FILING_OVERDUE")
        self.assertIn("FILING_DUE", kinds)
        self.assertIn("4 days remaining to finalize EPF Monthly ECR Filing", " ".join(a["message"] for a in al["data"]))
        self.assertEqual(al["summary"]["CRITICAL"], 1)
        self.assertEqual(len(self.a.get(f"{A}/alerts/?severity=CRITICAL").json()["data"]), 1)
        # tabs
        pft = self.j(self.a.get(f"{A}/pf/"), 200)["data"]
        self.assertEqual((pft["members"]["covered"], pft["members"]["with_uan"], pft["members"]["without_uan"]), (2, 1, 1))
        self.assertEqual(len(pft["monthly"]), 12)
        self.assertEqual(sum(x["employee_pf_deducted"] for x in pft["monthly"]), 3600.0)
        self.assertEqual(len(pft["pending_filings"]), 2)
        esit = self.j(self.a.get(f"{A}/esi/"), 200)["data"]
        self.assertEqual(esit["members"]["covered"], 1)
        self.assertEqual(self.a.get(f"{A}/pt/").json()["data"]["registrations"], [])
        tds = self.j(self.a.get(f"{A}/tds/?financial_year=2026-27"), 200)["data"]
        self.assertEqual([q["label"] for q in tds["quarters"]], ["Q1", "Q2", "Q3", "Q4"])
        self.assertEqual(self.a.get(f"{A}/tds/?financial_year=bad").status_code, 400)
        self.assertEqual(self.a.get(f"{A}/meta/").json()["data"]["registrations"][0]["number"], self.a.get(f"{A}/registrations/").json()["data"][0]["number"])

    # -------------------------------------------------------------- documents
    def test_documents(self):
        d = self.j(self.a.post(f"{A}/documents/", {"title": "Form A - Aug 2026", "doc_type": "FORM_A", "period_month": 8,
                   "period_year": 2026, "branch": self.pune.id, "file": pdf("forma.pdf")}, format="multipart"), 201)["data"]
        self.assertEqual((d["doc_type_label"], d["period_label"], d["branch"]["name"]), ("Form A", "August 2026", "Pune HQ"))
        self.assertEqual(self.a.post(f"{A}/documents/", {"title": "form a - aug 2026", "doc_type": "FORM_A", "period_month": 8,
                         "period_year": 2026, "branch": self.pune.id, "file": pdf()}, format="multipart").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/documents/", {"title": "No file"}, format="multipart").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/documents/", {"title": "Bad", "file": SimpleUploadedFile("a.exe", b"x")}, format="multipart").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/documents/", {"title": "T", "doc_type": "ZZ", "file": pdf()}, format="multipart").status_code, 400)
        self.a.post(f"{A}/documents/", {"title": "ECR slip", "doc_type": "ECR_SLIP", "file": pdf()}, format="multipart")
        self.assertEqual(len(self.a.get(f"{A}/documents/?doc_type=ECR_SLIP").json()["data"]), 1)
        self.assertEqual(len(self.a.get(f"{A}/documents/?year=2026&month=8").json()["data"]), 1)
        self.assertEqual(self.a.get(f"{A}/documents/{d['id']}/download/").status_code, 200)
        self.assertEqual(self.a.patch(f"{A}/documents/{d['id']}/", {"notes": "signed"}, format="json").json()["data"]["notes"], "signed")
        self.assertEqual(self.o.get(f"{A}/documents/{d['id']}/download/").status_code, 404)
        self.assertEqual(self.a.delete(f"{A}/documents/{d['id']}/").status_code, 200)
        self.assertEqual(len(self.a.get(f"{A}/documents/").json()["data"]), 1)

    # ----------------------------------------------------------------- labour
    def test_labour_and_reminders(self):
        self.assertEqual(self.a.get(f"{A}/labour/").json()["data"]["banner"]["message"], "No labour licences recorded yet.")
        mk = lambda **k: self.a.post(f"{A}/licenses/", {"license_type": "SHOPS_ESTABLISHMENT", **k}, format="multipart")
        l1 = self.j(mk(license_number="SE-001", branch=self.pune.id, valid_until=str(TODAY + timedelta(days=300)), file=pdf()), 201)["data"]
        self.j(mk(license_number="SE-002", branch=self.mum.id, valid_until=str(TODAY + timedelta(days=200))), 201)
        self.assertEqual(mk(license_number="se-001").status_code, 400)
        self.assertEqual(mk(license_number="X", issued_on="2026-05-01", valid_until="2026-01-01").status_code, 400)
        b = self.j(self.a.get(f"{A}/labour/"), 200)["data"]
        self.assertTrue(b["banner"]["all_current"])
        self.assertEqual(b["banner"]["message"], "All Shops & Commercial Establishments licenses for Mumbai BKC and Pune HQ are current and active.")
        l3 = self.j(mk(license_number="SE-003", valid_until=str(TODAY + timedelta(days=10))), 201)["data"]
        self.assertEqual((l3["state"], l3["days_left"]), ("EXPIRING", 10))
        l4 = self.j(mk(license_number="SE-004", valid_until=str(TODAY - timedelta(days=3))), 201)["data"]
        self.assertEqual(l4["state"], "EXPIRED")
        b = self.a.get(f"{A}/labour/").json()["data"]
        self.assertFalse(b["banner"]["all_current"])
        self.assertEqual((b["summary"]["expired"], b["summary"]["expiring"], b["summary"]["active"]), (1, 1, 2))
        self.assertEqual(len(self.a.get(f"{A}/licenses/?state=EXPIRED").json()["data"]), 1)
        kinds = {a["kind"] for a in self.a.get(f"{A}/alerts/").json()["data"]}
        self.assertTrue({"LICENSE_EXPIRED", "LICENSE_EXPIRING"} <= kinds)
        self.assertEqual(self.a.post(f"{A}/licenses/{l4['id']}/renew/", {"valid_until": str(TODAY - timedelta(days=9))}, format="json").status_code, 400)
        r = self.j(self.a.post(f"{A}/licenses/{l4['id']}/renew/", {"valid_until": str(TODAY + timedelta(days=365))}, format="json"), 200)["data"]
        self.assertEqual(r["state"], "ACTIVE")
        self.assertEqual(self.a.get(f"{A}/licenses/{l1['id']}/download/").status_code, 200)
        # inspections
        i = self.j(self.a.post(f"{A}/inspections/", {"inspection_date": str(TODAY - timedelta(days=5)), "branch": self.pune.id,
                   "authority": "Labour Dept", "outcome": "OBSERVATIONS", "observations": "Register B missing",
                   "action_due_date": str(TODAY + timedelta(days=3)), "penalty_amount": 1000, "report": pdf("r.pdf")},
                   format="multipart"), 201)["data"]
        self.assertEqual(self.a.post(f"{A}/inspections/", {"inspection_date": str(TODAY - timedelta(days=5)), "branch": self.pune.id,
                         "authority": "Labour Dept"}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/inspections/", {"inspection_date": str(TODAY), "action_due_date": str(TODAY - timedelta(days=1))}, format="json").status_code, 400)
        self.assertIn("INSPECTION_OPEN", {a["kind"] for a in self.a.get(f"{A}/alerts/").json()["data"]})
        self.assertEqual(self.a.get(f"{A}/labour/").json()["data"]["summary"]["penalties"], 1000.0)
        self.assertEqual(self.a.get(f"{A}/inspections/{i['id']}/download/").status_code, 200)
        self.assertEqual(self.a.post(f"{A}/inspections/{i['id']}/close/").json()["data"]["status"], "CLOSED")
        self.assertNotIn("INSPECTION_OPEN", {a["kind"] for a in self.a.get(f"{A}/alerts/").json()["data"]})
        self.assertEqual(len(self.a.get(f"{A}/inspections/?status=CLOSED").json()["data"]), 1)
        # reminders
        rm = self.j(self.a.post(f"{A}/reminders/", {"title": "Renew Fire NOC", "message": "Call vendor", "due_date": str(TODAY + timedelta(days=5)),
                    "severity": "WARNING"}, format="json"), 201)["data"]
        self.assertEqual(self.a.post(f"{A}/reminders/", {"title": "renew fire noc", "due_date": str(TODAY + timedelta(days=5))}, format="json").status_code, 400)
        self.assertIn("REMINDER", {a["kind"] for a in self.a.get(f"{A}/alerts/").json()["data"]})
        self.assertTrue(self.a.post(f"{A}/reminders/{rm['id']}/complete/").json()["data"]["is_done"])
        self.assertNotIn("REMINDER", {a["kind"] for a in self.a.get(f"{A}/alerts/").json()["data"]})
        self.assertEqual(len(self.a.get(f"{A}/reminders/?done=true").json()["data"]), 1)
        self.assertFalse(self.a.post(f"{A}/reminders/{rm['id']}/reopen/").json()["data"]["is_done"])
        self.assertEqual(self.a.delete(f"{A}/reminders/{rm['id']}/").status_code, 200)

    # ------------------------------------------------ form 16 + employee app
    def test_form16_and_employee_app(self):
        fy = "2025-26"
        code = self.emps["rahul"].employee_code
        f = self.j(self.a.post(f"{A}/form16/", {"employee_code": code, "financial_year": fy, "gross_income": 900000,
                   "tds_deducted": 30000, "file": pdf("f16.pdf")}, format="multipart"), 201)["data"]
        self.assertEqual(f["employee"]["employee_code"], code)
        for bad in ({"employee_code": code, "financial_year": fy, "file": pdf()},                     # dup
                    {"employee_code": code, "financial_year": "2025-27", "file": pdf()},              # bad FY
                    {"employee_code": "NOPE", "financial_year": fy, "file": pdf()},
                    {"employee_code": self.emps["priya"].employee_code, "financial_year": fy}):       # no file
            self.assertEqual(self.a.post(f"{A}/form16/", bad, format="multipart").status_code, 400, bad)
        pr = self.j(self.a.post(f"{A}/form16/", {"employee_code": self.emps["priya"].employee_code, "financial_year": fy,
                    "file": pdf(), "is_published": "false"}, format="multipart"), 201)["data"]
        self.assertEqual(len(self.a.get(f"{A}/form16/?financial_year={fy}&published=true").json()["data"]), 1)
        self.assertEqual(self.a.get(f"{A}/form16/{f['id']}/download/").status_code, 200)
        # employee app
        mine = self.j(self.rahul.get(f"{E}/form16/"), 200)["data"]
        self.assertEqual([x["id"] for x in mine], [f["id"]])
        self.assertEqual(self.rahul.get(f"{E}/form16/{f['id']}/download/").status_code, 200)
        self.assertEqual(self.rahul.get(f"{E}/form16/{pr['id']}/").status_code, 404)                  # not his
        self.assertEqual(self.priya.get(f"{E}/form16/").json()["data"], [])                          # unpublished
        self.a.patch(f"{A}/form16/{pr['id']}/", {"is_published": True}, format="json")
        self.assertEqual(len(self.priya.get(f"{E}/form16/").json()["data"]), 1)
        prof = self.j(self.rahul.get(f"{E}/profile/"), 200)["data"]
        self.assertEqual((prof["uan_number"], prof["pf_number"], prof["pan_number_masked"], prof["tds_applicable"]),
                         ("100200300400", "MHPUN001/001", "******234F", True))
        self.assertFalse(self.priya.get(f"{E}/profile/").json()["data"]["esi_applicable"])
        py, pm = prev_month(1)
        fy_now = f"{py if pm >= 4 else py - 1}-{str((py if pm >= 4 else py - 1) + 1)[2:]}"
        ded = self.j(self.rahul.get(f"{E}/deductions/?financial_year={fy_now}"), 200)
        self.assertEqual((len(ded["data"]), ded["summary"]["pf"], ded["summary"]["esi"], ded["summary"]["tds"]), (1, 1800.0, 150.0, 2500.0))
        self.assertEqual(self.rahul.get(f"{E}/deductions/?financial_year=zzz").status_code, 400)
        self.assertEqual(self.priya.get(f"{E}/deductions/?financial_year={fy_now}").json()["summary"]["tds"], 0.0)
        # tds tab shows form16 coverage
        t = self.a.get(f"{A}/tds/?financial_year={fy_now}").json()["data"]["form16"]
        self.assertEqual(t["eligible_employees"], 1)
        self.assertEqual(self.a.post(f"{A}/form16/{f['id']}/delete/").status_code, 200)
        self.assertEqual(self.rahul.get(f"{E}/form16/").json()["data"], [])
