# Payroll Inputs & Compensation Coordination tests.   python manage.py test PayrollHub
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 BankAccount, Department, EmployeeDT, EmployeeRole, Payroll
from People.tests import MEDIA, client, mk_company
from Timesheet.models import OvertimeClaim

from .models import Loan, PayrollCycle, Payslip

A = "/api/payroll-hub"
E = "/employee/payroll-hub"
T = timezone.localdate()
PM, PY = (T.month - 1, T.year) if T.month > 1 else (12, T.year - 1)       # last month = the cycle under test


def pdf(name="bill.pdf"):
    return SimpleUploadedFile(name, b"%PDF-1.4 bill", content_type="application/pdf")


@MEDIA
class PayrollHubTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("ph@x.com"), mk_company("pi@x.com")
        self.a, self.o = client(self.co), client(self.other)
        self.dept = Department.objects.create(company=self.co, name="Technology")
        self.emps = {}
        for k, n in (("rahul", "Rahul Sharma"), ("priya", "Priya Patil"), ("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(T - 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"])
        self.code = {k: v.employee_code for k, v in self.emps.items()}
        self.emps["elena"].role = EmployeeRole.objects.create(company=self.co, role_name="Payroll", role_code="pay", can_manage_payroll=True)
        self.emps["viewer"].role = EmployeeRole.objects.create(company=self.co, role_name="RO", role_code="ro", can_view_payroll=True)
        self.hr, self.viewer = client(self.emps["elena"]), client(self.emps["viewer"])
        self.rahul, self.priya = client(self.emps["rahul"]), client(self.emps["priya"])
        for k in ("rahul", "priya"):
            e = self.emps[k]
            Payroll.objects.create(Employee_ID=e.employee_code, name=e.name, company=self.co, month=PM, year=PY,
                                   present_days=22, gross_salary=Decimal("150000"), full_day_salary=Decimal("150000"),
                                   PF_deduction=Decimal("1800"), TDS_deduction=Decimal("12200"), total_deductions=Decimal("14000"),
                                   net_salary=Decimal("136000"), status="Unpaid")
            BankAccount.objects.create(employee=e, bank_name="HDFC Bank", account_number=f"5010{e.id:06d}", ifsc_code="HDFC0000001")

    def j(self, r, code):
        self.assertEqual(r.status_code, code, r.content)
        return r.json()

    def comp(self, **kw):
        return self.j(self.a.post(f"{A}/components/", kw, format="json"), 201)["data"]

    def inp(self, c=None, **kw):
        d = {"employee_code": self.code["rahul"], "month": PM, "year": PY, "input_type": "BONUS", "amount": 4500,
             "label": "Spot Bonus"} | kw
        return (c or self.a).post(f"{A}/inputs/", d, format="json")

    # ------------------------------------------------------------------ auth
    def test_authentication_and_authorization(self):
        anon = APIClient()
        urls = [f"{A}/{x}/" for x in ("dashboard", "meta", "settings", "components", "inputs", "variable-pay", "deductions",
                                      "loans", "cycles", "payslips")]
        for u in urls:
            self.assertEqual(anon.get(u).status_code, 401, u)
            self.assertEqual(self.rahul.get(u).status_code, 403, u)
            self.assertEqual(self.a.get(u).status_code, 200, u)
            self.assertEqual(self.hr.get(u).status_code, 200, u)
            self.assertEqual(self.viewer.get(u).status_code, 200, u)
        self.assertEqual(self.viewer.post(f"{A}/components/", {"code": "X", "name": "X"}, format="json").status_code, 403)
        self.assertEqual(self.viewer.put(f"{A}/settings/", {"loan_max_emi_percent": 40}, format="json").status_code, 403)
        self.assertEqual(self.hr.put(f"{A}/settings/", {"loan_max_emi_percent": 40}, format="json").status_code, 200)
        self.assertEqual(self.hr.put(f"{A}/settings/", {"loan_max_emi_percent": 400}, format="json").status_code, 400)
        for u in (f"{E}/home/", f"{E}/payslips/", f"{E}/inputs/", f"{E}/variable-pay/", f"{E}/deductions/", f"{E}/loans/",
                  f"{E}/salary-structure/", f"{E}/ytd/"):
            self.assertEqual(anon.get(u).status_code, 401, u)
            self.assertEqual(self.a.get(u).status_code, 403, u)
            self.assertEqual(self.rahul.get(u).status_code, 200, u)
        c = self.comp(code="BASIC", name="Basic Salary", component_type="EARNING", calc_method="PERCENT_OF_GROSS", calc_value=50)
        self.assertEqual(self.o.get(f"{A}/components/{c['id']}/").status_code, 404)
        self.assertEqual(self.o.get(f"{A}/components/").json()["data"], [])

    # ------------------------------------------------------------- salary structure
    def test_salary_structure(self):
        basic = self.comp(code="basic", name="Basic Salary", component_type="EARNING", calc_method="PERCENT_OF_GROSS", calc_value=50, tax_treatment="Taxable as per Income Tax slab")
        self.assertEqual((basic["code"], basic["calculation_basis"], basic["type_label"]), ("BASIC", "50% of Monthly Gross", "Earning (Fixed)"))
        hra = self.comp(code="HRA", name="House Rent Allowance (HRA)", component_type="EARNING", calc_method="PERCENT_OF_COMPONENT", calc_value=50, base_component=basic["id"])
        self.assertEqual(hra["calculation_basis"], "50% of Basic Salary")
        sp = self.comp(code="SPECIAL", name="Special Allowance", component_type="EARNING", calc_method="BALANCING")
        self.assertEqual(sp["type_label"], "Earning (Balancing)")
        epf = self.comp(code="EPF", name="Employee Provident Fund (EPF)", component_type="DEDUCTION", calc_method="PERCENT_OF_BASIC", calc_value=12, cap_amount=1800)
        self.assertEqual(epf["calculation_basis"], "12% of Basic (capped at ₹1,800 or actuals)")
        self.comp(code="PT", name="Professional Tax (PT)", component_type="DEDUCTION", calc_method="FIXED_AMOUNT", calc_value=200)
        b = self.j(self.a.get(f"{A}/components/preview/?gross=150000"), 200)["data"]
        amt = {x["code"]: x["amount"] for x in b["lines"]}
        self.assertEqual(amt, {"BASIC": 75000.0, "HRA": 37500.0, "SPECIAL": 37500.0, "EPF": 1800.0, "PT": 200.0})
        self.assertEqual((b["total_earnings"], b["total_deductions"], b["net_in_hand"]), (150000.0, 2000.0, 148000.0))
        for bad in ({"code": "BASIC", "name": "dup", "calc_method": "FIXED_AMOUNT"},
                    {"code": "X1", "name": "Second balancing", "component_type": "EARNING", "calc_method": "BALANCING"},
                    {"code": "X2", "name": "Bad pct", "calc_method": "PERCENT_OF_GROSS", "calc_value": 150},
                    {"code": "X3", "name": "No base", "calc_method": "PERCENT_OF_COMPONENT", "calc_value": 10},
                    {"code": "X4", "name": "Ded balancing", "component_type": "DEDUCTION", "calc_method": "BALANCING"},
                    {"code": "", "name": "n"}, {"code": "X5", "name": ""}):
            self.assertEqual(self.a.post(f"{A}/components/", bad, format="json").status_code, 400, bad)
        self.assertEqual(self.a.get(f"{A}/components/preview/").status_code, 400)
        self.assertEqual(len(self.a.get(f"{A}/components/?component_type=DEDUCTION").json()["data"]), 2)
        eb = self.j(self.a.get(f"{A}/components/employee_breakup/?employee={self.code['rahul']}"), 200)["data"]
        self.assertEqual(eb["monthly_gross"], 150000.0)
        self.assertEqual(self.a.patch(f"{A}/components/{epf['id']}/", {"calc_value": 12, "cap_amount": 1800}, format="json").status_code, 200)
        ids = [c["id"] for c in self.a.get(f"{A}/components/").json()["data"]][::-1]
        self.assertEqual([c["id"] for c in self.j(self.a.post(f"{A}/components/reorder/", {"ids": ids}, format="json"), 200)["data"]], ids)
        self.assertEqual(self.a.post(f"{A}/components/{hra['id']}/delete/").status_code, 200)
        # employee sees the structure + own breakup
        s = self.j(self.rahul.get(f"{E}/salary-structure/"), 200)["data"]
        self.assertEqual(len(s["components"]), 4)
        self.assertEqual(s["my_breakup"]["monthly_gross"], 150000.0)

    # ------------------------------------------------------------------ inputs
    def test_inputs_and_employee_claims(self):
        r = self.j(self.inp(label="Referral Incentive Bonus", input_type="INCENTIVE", amount=25000), 201)["data"]
        self.assertEqual((r["status"], r["direction"], r["adjustment_type"]), ("APPROVED", "EARNING", "Referral Incentive Bonus"))
        lop = self.j(self.inp(input_type="LOP", days=0, amount=0, label=None, remarks="Clean attendance"), 201)["data"]
        self.assertEqual((lop["status"], lop["status_label"], lop["direction"]), ("VERIFIED", "Verified (0 Days)", "INFO"))
        for bad in ({"amount": 0}, {"amount": -5}, {"input_type": "ZZ"}, {"employee_code": "NOPE"}, {"month": 13},
                    {"input_type": "LOP", "days": 40}):
            self.assertEqual(self.inp(**bad).status_code, 400, bad)
        self.assertEqual(self.inp(label="referral incentive bonus", input_type="INCENTIVE", amount=25000).status_code, 400)  # dup
        pend = self.j(self.inp(status="PENDING_REVIEW", label="Travel", input_type="REIMBURSEMENT", amount=14200, employee_code=self.code["priya"]), 201)["data"]
        OvertimeClaim.objects.create(company=self.co, employee=self.emps["rahul"], month=PM, year=PY, approved_hours=Decimal("6.5"),
                                     calculated_pay=Decimal("4500"), status="Passed to Payroll", remarks="6.5 hours verified release weekend sprint")
        lst = self.j(self.a.get(f"{A}/inputs/?month={PM}&year={PY}"), 200)
        self.assertEqual(len(lst["data"]), 4)                                         # 3 inputs + 1 timesheet overtime
        ot = next(x for x in lst["data"] if x["source_type"] == "TIMESHEET_OVERTIME")
        self.assertEqual((ot["amount"], ot["readonly"], ot["status"]), (4500.0, True, "APPROVED"))
        self.assertEqual(lst["summary"]["PENDING_REVIEW"], 1)
        self.assertEqual(len(self.a.get(f"{A}/inputs/?month={PM}&year={PY}&include_timesheet=false").json()["data"]), 3)
        self.assertEqual(len(self.a.get(f"{A}/inputs/?employee={self.code['priya']}&month={PM}&year={PY}").json()["data"]), 1)
        # decisions
        self.assertEqual(self.a.post(f"{A}/inputs/{pend['id']}/reject/", {}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/inputs/{pend['id']}/reject/", {"remarks": "No receipt"}, format="json").json()["data"]["status"], "REJECTED")
        self.assertEqual(self.a.post(f"{A}/inputs/{pend['id']}/approve/").json()["data"]["status"], "APPROVED")
        b = self.j(self.a.post(f"{A}/inputs/bulk_approve/", {"ids": [r["id"], 99999]}, format="json"), 200)["data"]
        self.assertEqual(b["skipped"], [99999])
        self.assertEqual(self.a.patch(f"{A}/inputs/{r['id']}/", {"remarks": "Meera closure"}, format="json").status_code, 200)
        self.assertEqual(self.a.get(f"{A}/inputs/{r['id']}/").json()["data"]["remarks"], "Meera closure")
        # employee claims
        c = self.j(self.rahul.post(f"{E}/inputs/", {"label": "Client dinner", "amount": 3200, "remarks": "Mumbai BKC", "month": PM, "year": PY, "attachment": pdf()}, format="multipart"), 201)["data"]
        self.assertEqual((c["status"], c["source"], c["input_type"]), ("PENDING_REVIEW", "EMPLOYEE", "REIMBURSEMENT"))
        self.assertTrue(c["attachment"])
        self.assertEqual(self.rahul.post(f"{E}/inputs/", {"label": "client dinner", "amount": 3200, "month": PM, "year": PY}, format="json").status_code, 400)
        self.assertEqual(self.rahul.post(f"{E}/inputs/", {"label": "x", "amount": 0, "month": PM, "year": PY}, format="json").status_code, 400)
        self.assertEqual(self.rahul.patch(f"{E}/inputs/{c['id']}/", {"amount": 3300}, format="json").json()["data"]["amount"], 3300.0)
        self.assertEqual(self.priya.patch(f"{E}/inputs/{c['id']}/", {"amount": 1}, format="json").status_code, 404)
        self.assertEqual(self.rahul.patch(f"{E}/inputs/{r['id']}/", {"amount": 1}, format="json").status_code, 403)   # HR-entered row
        self.assertEqual(len(self.rahul.get(f"{E}/inputs/?month={PM}&year={PY}").json()["data"]), 2)                  # LOP hidden
        self.a.post(f"{A}/inputs/{c['id']}/approve/")
        self.assertEqual(self.rahul.post(f"{E}/inputs/{c['id']}/delete/").status_code, 403)                           # decided
        c2 = self.rahul.post(f"{E}/inputs/", {"label": "Taxi", "amount": 500, "month": PM, "year": PY}, format="json").json()["data"]
        self.assertEqual(self.rahul.delete(f"{E}/inputs/{c2['id']}/").status_code, 200)
        self.a.put(f"{A}/settings/", {"allow_employee_claims": False}, format="json")
        self.assertEqual(self.rahul.post(f"{E}/inputs/", {"label": "Z", "amount": 5, "month": PM, "year": PY}, format="json").status_code, 403)

    # ------------------------------------------------------- variable pay / deductions
    def test_variable_pay_and_deductions(self):
        v = self.j(self.a.post(f"{A}/variable-pay/", {"employee_code": self.code["rahul"], "period_label": "Q2 2026", "target_amount": 50000, "achievement_percent": 115}, format="json"), 201)["data"]
        self.assertEqual((v["payable_bonus"], v["status"], v["period"]), (57500.0, "DRAFT", "Q2 2026"))
        self.assertEqual(self.a.post(f"{A}/variable-pay/", {"employee_code": self.code["rahul"], "period_label": "q2 2026", "target_amount": 1}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/variable-pay/", {"employee_code": self.code["priya"], "period_label": "Q2 2026", "target_amount": 0}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/variable-pay/", {"employee_code": self.code["priya"], "period_label": "Q2 2026", "target_amount": 10, "achievement_percent": 900}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/variable-pay/{v['id']}/approve/", {}, format="json").status_code, 400)       # needs payout month
        ap = self.j(self.a.post(f"{A}/variable-pay/{v['id']}/approve/", {"payout_month": PM, "payout_year": PY}, format="json"), 200)["data"]
        self.assertEqual((ap["status"], ap["payout_period"]), ("APPROVED", f"{['', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][PM]} {PY}"))
        self.assertEqual(self.a.delete(f"{A}/variable-pay/{v['id']}/").status_code, 403)
        self.assertEqual(self.a.patch(f"{A}/variable-pay/{v['id']}/", {"achievement_percent": 100}, format="json").status_code, 200)
        self.assertEqual(self.a.get(f"{A}/variable-pay/{v['id']}/").json()["data"]["payable_bonus"], 50000.0)
        self.assertEqual(len(self.rahul.get(f"{E}/variable-pay/").json()["data"]), 1)
        self.assertEqual(self.priya.get(f"{E}/variable-pay/").json()["data"], [])
        self.assertEqual(self.a.post(f"{A}/variable-pay/{v['id']}/mark_paid/").json()["data"]["status"], "PAID")
        self.assertEqual(self.a.patch(f"{A}/variable-pay/{v['id']}/", {"remarks": "x"}, format="json").status_code, 400)
        v2 = self.j(self.a.post(f"{A}/variable-pay/", {"employee_code": self.code["priya"], "period_label": "Q2 2026", "target_amount": 75000, "status": "PENDING_APPROVAL"}, format="json"), 201)["data"]
        self.assertEqual(self.a.post(f"{A}/variable-pay/{v2['id']}/reject/", {"remarks": "Target missed"}, format="json").json()["data"]["status"], "REJECTED")
        self.assertEqual(self.a.delete(f"{A}/variable-pay/{v2['id']}/").status_code, 200)
        # deductions
        d = self.j(self.a.post(f"{A}/deductions/", {"employee_code": self.code["priya"], "head": "Notice Period Shortfall", "amount": 12400, "reason": "Early release agreed recovery"}, format="json"), 201)["data"]
        self.assertEqual((d["status"], d["status_label"]), ("PENDING_APPROVAL", "Pending Approval"))
        self.assertEqual(self.a.post(f"{A}/deductions/", {"employee_code": self.code["priya"], "head": "notice period shortfall", "amount": 12400}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/deductions/", {"employee_code": self.code["priya"], "head": "x", "amount": 5, "exit_fnf_id": 999}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/deductions/{d['id']}/approve/", {}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/deductions/{d['id']}/mark_fnf/").json()["data"]["status"], "PENDING_FNF")
        self.assertEqual(len(self.priya.get(f"{E}/deductions/").json()["data"]), 1)
        self.assertEqual(self.a.post(f"{A}/deductions/{d['id']}/approve/", {"month": PM, "year": PY}, format="json").json()["data"]["status"], "APPROVED")
        self.assertEqual(self.a.post(f"{A}/deductions/{d['id']}/waive/", {"remarks": "Waived by CHRO"}, format="json").json()["data"]["status"], "WAIVED")
        self.assertEqual(len(self.a.get(f"{A}/deductions/?status=WAIVED").json()["data"]), 1)

    # ------------------------------------------------------------------ loans
    def test_loans(self):
        l = self.j(self.a.post(f"{A}/loans/", {"employee_code": self.code["rahul"], "principal": 100000, "tenure_months": 10, "start_month": PM, "start_year": PY, "purpose": "Home repair"}, format="json"), 201)["data"]
        self.assertTrue(l["loan_id"].startswith(f"LN-{T.year}-"))
        self.assertEqual((l["status"], l["monthly_emi"], l["balance_remaining"], l["emis_left"], l["tenure_label"]), ("ACTIVE", 10000.0, 100000.0, 10, "10 Months"))
        det = self.j(self.a.get(f"{A}/loans/{l['id']}/"), 200)["data"]
        self.assertEqual((len(det["schedule"]), det["schedule"][0]["period"][:3]), (10, ["", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][PM]))
        for bad in ({"principal": 100000, "tenure_months": 10}, {"principal": 0, "tenure_months": 10, "start_month": PM, "start_year": PY},
                    {"principal": 100000, "tenure_months": 0, "start_month": PM, "start_year": PY},
                    {"principal": 100000, "tenure_months": 999, "start_month": PM, "start_year": PY},
                    {"principal": 100000, "tenure_months": 10, "start_month": PM, "start_year": PY},                   # duplicate
                    {"principal": 900000, "tenure_months": 6, "start_month": PM, "start_year": PY},                    # EMI > 50% of gross
                    {"principal": 1000, "tenure_months": 2, "start_month": PM, "start_year": PY, "interest_rate": 99}):
            self.assertEqual(self.a.post(f"{A}/loans/", {"employee_code": self.code["rahul"], **bad}, format="json").status_code, 400, bad)
        ir = self.j(self.a.post(f"{A}/loans/", {"employee_code": self.code["priya"], "principal": 60000, "tenure_months": 6, "interest_rate": 12, "start_month": PM, "start_year": PY}, format="json"), 201)["data"]
        sch = self.a.get(f"{A}/loans/{ir['id']}/schedule/").json()["data"]["schedule"]
        self.assertEqual(round(sum(x["principal"] for x in sch), 2), 60000.0)
        self.assertGreater(sum(x["interest"] for x in sch), 0)
        # employee request -> approval
        req = self.j(self.priya.post(f"{E}/loans/", {"loan_type": "SALARY_ADVANCE", "principal": 30000, "tenure_months": 3, "purpose": "Medical"}, format="json"), 201)["data"]
        self.assertEqual((req["status"], req["requested_by_employee"]), ("PENDING", True))
        self.assertEqual(self.priya.post(f"{E}/loans/", {"loan_type": "SALARY_ADVANCE", "principal": 20000, "tenure_months": 2}, format="json").status_code, 400)  # one pending
        self.assertEqual(self.priya.post(f"{E}/loans/", {"principal": 99999999, "tenure_months": 3}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/loans/{req['id']}/approve/", {}, format="json").status_code, 400)             # start month needed
        ap = self.j(self.a.post(f"{A}/loans/{req['id']}/approve/", {"start_month": PM, "start_year": PY}, format="json"), 200)["data"]
        self.assertEqual((ap["status"], ap["emis_left"]), ("ACTIVE", 3))
        self.assertEqual(self.priya.post(f"{E}/loans/{req['id']}/cancel/").status_code, 403)
        c = self.priya.post(f"{E}/loans/", {"loan_type": "LOAN", "principal": 12000, "tenure_months": 4}, format="json").json()["data"]
        self.assertEqual(self.priya.post(f"{E}/loans/{c['id']}/cancel/").json()["data"]["status"], "CANCELLED")
        rj = self.priya.post(f"{E}/loans/", {"loan_type": "LOAN", "principal": 9000, "tenure_months": 3}, format="json").json()["data"]
        self.assertEqual(self.a.post(f"{A}/loans/{rj['id']}/reject/", {}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/loans/{rj['id']}/reject/", {"remarks": "Policy"}, format="json").json()["data"]["status"], "REJECTED")
        self.assertEqual(self.a.delete(f"{A}/loans/{rj['id']}/").status_code, 200)
        self.assertEqual(self.a.delete(f"{A}/loans/{l['id']}/").status_code, 403)
        self.assertEqual(self.a.patch(f"{A}/loans/{l['id']}/", {"principal": 1}, format="json").status_code, 400)
        out = self.a.get(f"{A}/loans/outstanding/?employee={self.code['rahul']}").json()
        self.assertEqual(out["summary"]["total_outstanding"], 100000.0)
        self.assertEqual(self.a.get(f"{A}/loans/").json()["summary"]["active_loans"], 3)
        ml = self.j(self.rahul.get(f"{E}/loans/"), 200)
        self.assertEqual((len(ml["data"]), ml["summary"]["monthly_emi"]), (1, 10000.0))
        self.assertEqual(self.rahul.get(f"{E}/loans/{req['id']}/").status_code, 404)
        sk = self.j(self.a.post(f"{A}/loans/{l['id']}/skip_installment/", {"installment_no": 1}, format="json"), 200)["data"]
        self.assertEqual((len(sk["schedule"]), sk["emis_left"]), (11, 10))
        fc = self.j(self.a.post(f"{A}/loans/{l['id']}/foreclose/", {"remarks": "Paid in full"}, format="json"), 200)
        self.assertEqual((fc["data"]["status"], fc["settled_amount"]), ("FORECLOSED", 100000.0))
        self.assertEqual(self.a.post(f"{A}/loans/{l['id']}/foreclose/").status_code, 400)

    # ----------------------------------------------------------- full lifecycle
    def test_cycle_payslips_and_employee_app(self):
        # structure with PT so statutory liabilities include PT
        self.comp(code="PT", name="Professional Tax (PT)", component_type="DEDUCTION", calc_method="FIXED_AMOUNT", calc_value=200)
        cp = f"{PM:02d}-{PY}"
        cyc = self.j(self.a.get(f"{A}/cycles/{cp}/"), 200)["data"]
        self.assertEqual([s["state"] for s in cyc["steps"]], ["current", "pending", "pending", "pending"])
        # adjustments that must reach the payslip
        self.inp(label="Referral Incentive Bonus", input_type="INCENTIVE", amount=25000)
        self.inp(input_type="LOP", days=0, amount=0, label=None)
        pend = self.inp(status="PENDING_REVIEW", label="Travel", input_type="REIMBURSEMENT", amount=14200, employee_code=self.code["priya"]).json()["data"]
        OvertimeClaim.objects.create(company=self.co, employee=self.emps["rahul"], month=PM, year=PY, approved_hours=Decimal("6.5"),
                                     calculated_pay=Decimal("4500"), status="Passed to Payroll")
        vp = self.a.post(f"{A}/variable-pay/", {"employee_code": self.code["rahul"], "period_label": "Q2 2026", "target_amount": 50000, "achievement_percent": 115}, format="json").json()["data"]
        self.a.post(f"{A}/variable-pay/{vp['id']}/approve/", {"payout_month": PM, "payout_year": PY}, format="json")
        ded = self.a.post(f"{A}/deductions/", {"employee_code": self.code["rahul"], "head": "Notice Period Shortfall", "amount": 1000, "month": PM, "year": PY, "status": "PENDING_APPROVAL"}, format="json").json()["data"]
        self.a.post(f"{A}/deductions/{ded['id']}/approve/", {"month": PM, "year": PY}, format="json")
        loan = self.a.post(f"{A}/loans/", {"employee_code": self.code["rahul"], "principal": 100000, "tenure_months": 10, "start_month": PM, "start_year": PY}, format="json").json()["data"]
        # live payslip = payroll row + approved inputs + overtime + variable pay - PT - deduction - EMI
        ps = self.j(self.a.get(f"{A}/payslips/{self.code['rahul']}/?month={PM}&year={PY}"), 200)["data"]
        self.assertEqual(ps["gross_salary"], 150000 + 25000 + 4500 + 57500)
        codes = {d["code"] for d in ps["deductions"]}
        self.assertEqual(codes, {"PF", "TDS", "PT", "DEDUCTION", "LOAN_EMI"})
        self.assertEqual(ps["total_deductions"], 1800 + 12200 + 200 + 1000 + 10000)
        self.assertEqual(ps["net_payable"], ps["gross_salary"] - ps["total_deductions"])
        self.assertFalse(ps["released"])
        # dashboard
        dash = self.j(self.a.get(f"{A}/dashboard/?month={PM}&year={PY}"), 200)["data"]
        k = dash["kpis"]
        self.assertEqual(k["statutory_liabilities"]["subtitle"], "EPF + PT + TDS")
        self.assertEqual(k["statutory_liabilities"]["value"], 2 * (1800 + 12200 + 200))
        self.assertEqual(k["payroll_status"]["value"], "Open")
        self.assertGreater(k["net_disbursable_salary"]["value"], 0)
        self.assertTrue(k["total_monthly_ctc"]["display"].endswith("Lakhs"))
        self.assertGreaterEqual(len(dash["inputs"]), 3)
        # freeze requires payroll; blocks edits
        self.assertEqual(self.a.post(f"{A}/cycles/{cp}/validate/").json()["data"]["advanced"], False)                   # not frozen -> advisory
        v0 = self.a.post(f"{A}/cycles/{cp}/validate/").json()["data"]
        self.assertFalse(v0["passed"])
        self.assertIn("INPUT_PENDING", {i["code"] for i in v0["issues"]})
        self.assertEqual(self.a.post(f"{A}/cycles/{cp}/bank_file/").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/cycles/{cp}/release/").status_code, 400)
        fr = self.j(self.a.post(f"{A}/cycles/{cp}/freeze/", {"release_on": str(T + timedelta(days=3))}, format="json"), 200)["data"]
        self.assertEqual(fr["status_label"], "Frozen")
        self.assertEqual(self.inp(label="Late bonus", amount=10).status_code, 400)                                        # frozen
        self.assertEqual(self.a.post(f"{A}/inputs/{pend['id']}/approve/").status_code, 409)
        self.assertEqual(self.a.post(f"{A}/cycles/{cp}/freeze/").status_code, 400)
        v1 = self.j(self.a.post(f"{A}/cycles/{cp}/validate/"), 200)["data"]
        self.assertFalse(v1["passed"])
        self.a.post(f"{A}/cycles/{cp}/unfreeze/")
        self.a.post(f"{A}/inputs/{pend['id']}/approve/")
        self.a.post(f"{A}/cycles/{cp}/freeze/", {"release_on": str(T + timedelta(days=3))}, format="json")
        v2 = self.j(self.a.post(f"{A}/cycles/{cp}/validate/"), 200)["data"]
        self.assertEqual((v2["passed"], v2["advanced"], v2["cycle"]["status"]), (True, True, "VERIFIED"))
        self.assertEqual(v2["cycle"]["status_sub"], "Ready for Bank Transfer")
        self.assertEqual([s["state"] for s in v2["cycle"]["steps"]], ["done", "done", "current", "pending"])
        self.a.put(f"{A}/settings/", {"bank_portal_name": "HDFC Portal"}, format="json")
        self.assertEqual(self.a.get(f"{A}/cycles/{cp}/").json()["data"]["steps"][2]["detail"], "Ready for HDFC Portal")
        bf = self.j(self.a.post(f"{A}/cycles/{cp}/bank_file/"), 201)
        self.assertEqual((bf["data"]["bank_file_count"], bf["data"]["status"]), (2, "BANK_FILE_READY"))
        csv_resp = self.a.get(f"{A}/cycles/{cp}/bank_file_download/")
        self.assertEqual(csv_resp.status_code, 200)
        self.assertIn(b"Employee Code,Beneficiary Name", csv_resp.content)
        self.assertIn(b"HDFC Bank", csv_resp.content)
        # scheduled release in the future needs force
        self.assertEqual(self.a.post(f"{A}/cycles/{cp}/release/").status_code, 400)
        self.assertEqual(self.rahul.get(f"{E}/payslips/").json()["data"], [])                                             # not released yet
        rel = self.j(self.a.post(f"{A}/cycles/{cp}/release/", {"force": True}, format="json"), 200)
        self.assertEqual((rel["released"], rel["data"]["status"]), (2, "RELEASED"))
        self.assertEqual(Payslip.objects.filter(status="RELEASED").count(), 2)
        self.assertEqual(self.a.get(f"{A}/inputs/?month={PM}&year={PY}&include_timesheet=false").json()["summary"]["PROCESSED"], 2)
        self.assertEqual(self.a.get(f"{A}/loans/{loan['id']}/").json()["data"]["emis_paid"], 1)
        # payslips tab
        lst = self.j(self.a.get(f"{A}/payslips/?month={PM}&year={PY}"), 200)
        self.assertEqual((len(lst["data"]), lst["summary"]["released"]), (2, 2))
        self.assertEqual(len(self.a.get(f"{A}/payslips/?month={PM}&year={PY}&search=priya").json()["data"]), 1)
        self.assertEqual(self.a.get(f"{A}/payslips/{self.code['rahul']}/pdf/?month={PM}&year={PY}")["Content-Type"], "application/pdf")
        self.assertEqual(self.a.get(f"{A}/payslips/{self.code['rahul']}/?month=1&year=2001").status_code, 404)
        self.assertEqual(self.a.post(f"{A}/cycles/{cp}/unfreeze/").status_code, 400)
        # employee app
        mine = self.j(self.rahul.get(f"{E}/payslips/"), 200)["data"]
        self.assertEqual(len(mine), 1)
        pid = mine[0]["id"]
        det = self.j(self.rahul.get(f"{E}/payslips/{pid}/"), 200)["data"]
        self.assertEqual(det["net_payable"], ps["net_payable"])
        self.assertEqual(self.rahul.get(f"{E}/payslips/{pid}/pdf/")["Content-Type"], "application/pdf")
        self.assertEqual(self.priya.get(f"{E}/payslips/{pid}/").status_code, 404)
        fy = f"{PY if PM >= 4 else PY - 1}-{str((PY if PM >= 4 else PY - 1) + 1)[2:]}"
        ytd = self.j(self.rahul.get(f"{E}/ytd/?financial_year={fy}"), 200)["data"]
        self.assertEqual((ytd["payslips"], ytd["net_pay"], ytd["deductions_by_code"]["PF"]), (1, ps["net_payable"], 1800.0))
        self.assertEqual(self.rahul.get(f"{E}/ytd/?financial_year=bad").status_code, 400)
        self.assertEqual(self.rahul.get(f"{E}/payslips/?financial_year={fy}").json()["meta"]["total"], 1)
        home = self.rahul.get(f"{E}/home/").json()["data"]
        self.assertEqual((home["latest_payslip"]["id"], home["loan_outstanding"]), (pid, 90000.0))
        # revoke -> hidden, items return to approved, EMI back to scheduled
        rv = self.j(self.a.post(f"{A}/cycles/{cp}/revoke/"), 200)["data"]
        self.assertEqual(rv["status"], "BANK_FILE_READY")
        self.assertEqual(self.rahul.get(f"{E}/payslips/").json()["data"], [])
        self.assertEqual(self.a.get(f"{A}/loans/{loan['id']}/").json()["data"]["emis_paid"], 0)
        self.assertEqual(self.a.post(f"{A}/cycles/{cp}/revoke/").status_code, 400)
        self.assertEqual(len(self.a.get(f"{A}/cycles/").json()["data"]), 1)
        self.assertEqual(self.o.get(f"{A}/cycles/{cp}/").json()["data"]["status"], "OPEN")                                # isolation
        self.assertEqual(self.a.get(f"{A}/cycles/13-2026/").status_code, 400)
        # generate action reuses the existing engine
        self.a.post(f"{A}/cycles/{cp}/unfreeze/")
        g = self.j(self.a.post(f"{A}/cycles/{cp}/generate_payroll/"), 200)["data"]
        self.assertIn("generated", g)
        self.assertEqual(PayrollCycle.objects.filter(company=self.co).count(), 1)
