# python manage.py test EmployeeRelations
import json
import shutil
import tempfile
from datetime import timedelta

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase, override_settings
from django.utils import timezone
from rest_framework.test import APIClient

from Company.models import company_details
from Employee.models import EmployeeAccount, EmployeeDT, EmployeeRole

from EmployeeRelations import models as m
from EmployeeRelations.models import CaseDocument, DocumentAccessLog, ERCase

TMP = tempfile.mkdtemp()
m.vault_storage._location = TMP                            # never write confidential test files into the project
                                                          # (override_settings clears the cached path, so patch the source attribute)


def mk_company(email):
    return company_details.objects.create(email=email, password="x", contact_no=str(abs(hash(email)))[:10], Registered_Company_Name="Zenith " + email[:3],
                                          Company_address="Pune", status=True, is_verified=True)


def cli(u):
    c = APIClient()
    c.force_authenticate(user=u)
    return c


@override_settings(MEDIA_ROOT=TMP)
class RelationsTests(TestCase):
    @classmethod
    def tearDownClass(cls):
        shutil.rmtree(TMP, ignore_errors=True)
        super().tearDownClass()

    def setUp(self):
        self.co, self.other = mk_company("er1@x.com"), mk_company("er2@x.com")
        self.a = cli(self.co)
        self.hr_role = EmployeeRole.objects.create(company=self.co, role_name="HR Admin", role_code="hr", can_edit_employees=True, can_create_employees=True, can_delete_employees=True)
        self.view_role = EmployeeRole.objects.create(company=self.co, role_name="Staff", role_code="staff")            # default flags: view employees only
        self.elena = self.mk("Elena Rostova", "elena@z.com", self.hr_role)
        self.vikram = self.mk("Vikram Rao", "vikram@z.com", self.view_role)
        self.ananya = self.mk("Ananya Roy", "ananya@z.com", self.view_role)
        self.amit = self.mk("Amit Joshi", "amit@z.com", self.view_role)
        self.counsel = self.mk("Lata Counsel", "lata@z.com", self.view_role)
        self.P = lambda u, d=None, c=None: (c or self.a).post(u, d if d is not None else {}, format="json")

    def mk(self, name, email, role):
        e = EmployeeDT(company=self.co, name=name, email=email, password="secret1", Employee_Status="Activate", is_active=True)
        e.save()
        EmployeeAccount.objects.create(employee=e, role=role, is_login_enabled=True)
        return e

    def emp(self, e):
        u = EmployeeDT.objects.select_related("account", "account__role").get(pk=e.pk)
        u.role = u.account.role
        return cli(u)

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

    def case(self, emp=None, **kw):
        body = {"employee_code": (emp or self.vikram).employee_code, "category": "Disciplinary", "subject": "Notice period attendance non-compliance", "severity": "High"}
        body.update(kw)
        return self.j(self.P("/api/relations/cases/", body), 201)["data"]

    # ---------------- HR cases ----------------
    def test_case_crud_numbering_and_duplicates(self):
        c1 = self.case()
        c2 = self.case(self.ananya, category="Grievance", subject="Manager communication feedback", severity="Low")
        self.assertEqual((c1["case_id"], c2["case_id"], c1["status"], c1["action"]), ("CASE-01", "CASE-02", "Open", "Resolve Case"))
        self.assertEqual(self.P("/api/relations/cases/", {"employee_code": self.vikram.employee_code, "category": "disciplinary", "subject": "  notice period ATTENDANCE non-compliance "}).status_code, 400)
        self.assertEqual(self.P("/api/relations/cases/", {"employee_code": "NOPE", "category": "Grievance", "subject": "x"}).status_code, 400)
        for bad in ({"category": "Alien"}, {"subject": " "}, {"severity": "Huge"}, {"incident_date": "2999-01-01"}, {"target_date": "2000-01-01"}, {"source": "Bird"}):
            body = {"employee_code": self.ananya.employee_code, "category": "Misconduct", "subject": "Unique one", **bad}
            self.assertEqual(self.P("/api/relations/cases/", body).status_code, 400, bad)
        row = self.j(self.a.get(f"/api/relations/cases/{c1['id']}/"), 200)["data"]
        self.assertEqual((row["counts"]["notes"], row["timeline"][0]["type"]), (1, "Created"))
        self.j(self.a.patch(f"/api/relations/cases/{c1['id']}/", {"severity": "Critical", "description": "Absent 4 days"}, format="json"), 200)
        self.j(self.a.put(f"/api/relations/cases/{c1['id']}/", {"sub_category": "Attendance"}, format="json"), 200)
        self.j(self.P(f"/api/relations/cases/{c1['id']}/update/", {"target_date": str(timezone.localdate() + timedelta(days=10))}), 200)
        self.assertEqual(len(self.j(self.a.get("/api/relations/cases/?severity=Critical&employee=" + self.vikram.employee_code))["data"]), 1)
        self.assertEqual(len(self.j(self.a.get("/api/relations/cases/?search=communication"))["data"]), 1)
        self.assertEqual(len(self.j(self.a.get("/api/relations/cases/?status=Open&category=Grievance"))["data"]), 1)
        self.assertEqual(self.a.get("/api/relations/cases/?date_from=bad").status_code, 400)
        self.j(self.a.delete(f"/api/relations/cases/{c2['id']}/"), 200)
        self.assertEqual(self.a.get(f"/api/relations/cases/{c2['id']}/").status_code, 404)
        c3 = self.case(self.ananya, category="Misconduct", subject="Third")
        self.assertEqual(c3["case_id"], "CASE-03")                                                                       # numbers never reused
        self.j(self.P(f"/api/relations/cases/{c3['id']}/delete/"), 200)
        self.assertEqual(self.j(cli(self.other).get("/api/relations/cases/"), 200)["data"], [])                         # B2B
        self.assertEqual(cli(self.other).get(f"/api/relations/cases/{c1['id']}/").status_code, 404)

    def test_case_workflow_and_conflict_rules(self):
        c = self.case()
        u = f"/api/relations/cases/{c['id']}"
        self.assertEqual(self.P(f"{u}/assign/", {"investigator_code": self.vikram.employee_code}).status_code, 400)     # subject cannot investigate himself
        self.assertEqual(self.P(f"{u}/status/", {"status": "In Investigation"}).status_code, 400)                         # needs investigator
        a = self.j(self.P(f"{u}/assign/", {"investigator_code": self.elena.employee_code, "remarks": "Please investigate"}), 200)["data"]
        self.assertEqual((a["status"], a["assigned_investigator"]), ("In Investigation", "Elena Rostova"))
        self.assertEqual(self.P(f"{u}/resolve/", {"resolution_type": "Substantiated"}).status_code, 400)                  # summary missing
        self.assertEqual(self.P(f"{u}/resolve/", {"resolution_type": "Nope", "resolution_summary": "x"}).status_code, 400)
        self.assertEqual(self.P(f"{u}/close/").status_code, 409)                                                         # not resolved yet
        self.j(self.P(f"{u}/status/", {"status": "Pending Review", "remarks": "awaiting statement"}), 200)
        self.j(self.P(f"{u}/escalate/", {"remarks": "legal angle"}), 200)
        n = self.j(self.P(f"{u}/notes/", {"text": "Statement taken from supervisor"}), 201)["data"]
        self.assertTrue(n["is_internal"])
        self.assertEqual(self.P(f"{u}/notes/", {"text": " "}).status_code, 400)
        r = self.j(self.P(f"{u}/resolve/", {"resolution_type": "substantiated", "resolution_summary": "Written warning issued"}), 200)["data"]
        self.assertEqual((r["status"], r["action"], r["resolution_type"]), ("Resolved", "Closed", "Substantiated"))
        self.assertEqual(self.a.patch(f"{u}/", {"subject": "edit"}, format="json").status_code, 400)                      # locked after resolve
        self.assertEqual(self.P(f"{u}/assign/", {"investigator_code": self.amit.employee_code}).status_code, 409)
        self.assertEqual(self.P(f"{u}/reopen/", {}).status_code, 400)                                                    # remarks mandatory
        self.j(self.P(f"{u}/reopen/", {"remarks": "new evidence"}), 200)
        self.j(self.P(f"{u}/resolve/", {"resolution_type": "Settled", "resolution_summary": "Settled"}), 200)
        self.assertEqual(self.j(self.P(f"{u}/close/", {"remarks": "done"}), 200)["data"]["status"], "Closed")
        self.assertEqual(self.P(f"{u}/status/", {"status": "Open"}).status_code, 409)
        tl = self.j(self.a.get(f"{u}/notes/"), 200)["data"]
        self.assertGreaterEqual(len(tl), 8)
        self.assertEqual(self.j(self.a.get("/api/relations/cases/summary/"))["data"]["closed"], 1)
        # raised_by cannot investigate either
        c2 = self.case(self.ananya, category="Grievance", subject="Pay query", raised_by_code=self.amit.employee_code)
        self.assertEqual(self.P(f"/api/relations/cases/{c2['id']}/assign/", {"investigator_code": self.amit.employee_code}).status_code, 400)
        self.assertEqual(self.a.delete(f"/api/relations/cases/{c['id']}/").status_code, 200)                              # closed case without links can go
        c3 = self.case(self.ananya, category="Misconduct", subject="Linked")
        self.P(f"/api/relations/cases/{c3['id']}/assign/", {"investigator_code": self.elena.employee_code})
        self.assertEqual(self.a.delete(f"/api/relations/cases/{c3['id']}/").status_code, 409)                             # under investigation

    def test_grievances_complaints_tabs(self):
        g = self.j(self.P("/api/relations/grievances/", {"employee_code": self.ananya.employee_code, "category": "Disciplinary", "subject": "Unfair appraisal"}), 201)["data"]
        self.assertEqual(g["category"], "Grievance")                                                                      # category fixed by the tab
        self.assertEqual(len(self.j(self.a.get("/api/relations/grievances/"))["data"]), 1)
        self.assertEqual(len(self.j(self.a.get("/api/relations/complaints/"))["data"]), 0)
        banner = self.j(self.a.get("/api/relations/complaints/committee/"), 200)
        self.assertIn("Zero active formal", banner["message"])
        self.assertIn("meets quarterly", banner["message"])
        self.j(self.a.put("/api/relations/settings/", {"icc_presiding_officer_code": self.elena.employee_code, "icc_meeting_frequency": "Monthly"}, format="json"), 200)
        cp = self.j(self.P("/api/relations/complaints/", {"employee_code": self.vikram.employee_code, "subject": "Inappropriate comments", "sub_category": "POSH", "severity": "Critical"}), 201)["data"]
        self.assertEqual((cp["category"], cp["status"], cp["assigned_investigator"]), ("Complaint", "In Investigation", "Elena Rostova"))   # auto-assigned to ICC officer
        b2 = self.j(self.a.get("/api/relations/complaints/committee/"))
        self.assertEqual((b2["data"]["active_this_quarter"], "meets monthly" in b2["message"]), (1, True))
        self.assertEqual(self.a.get(f"/api/relations/grievances/{cp['id']}/").status_code, 404)                           # not a grievance
        self.assertEqual(len(self.j(self.a.get("/api/relations/cases/"))["data"]), 2)                                     # but both live in the one registry

    # ---------------- disciplinary ----------------
    def test_disciplinary_natural_justice(self):
        c = self.case()
        t = timezone.localdate()
        base = {"employee_code": self.vikram.employee_code, "action_type": "Inquiry", "charge": "Unauthorised absence", "case": c["case_id"]}
        self.assertEqual(self.P("/api/relations/disciplinary/", {**base, "notice_served_on": str(t), "hearing_date": str(t + timedelta(days=1))}).status_code, 400)   # notice period too short
        self.assertEqual(self.P("/api/relations/disciplinary/", {**base, "employee_code": self.ananya.employee_code}).status_code, 400)                                 # case is about someone else
        self.assertEqual(self.P("/api/relations/disciplinary/", {**base, "committee_codes": [self.vikram.employee_code]}).status_code, 400)                             # accused on committee
        self.assertEqual(self.P("/api/relations/disciplinary/", {**base, "action_type": "Dance"}).status_code, 400)
        d = self.j(self.P("/api/relations/disciplinary/", {**base, "notice_served_on": str(t - timedelta(days=5)), "hearing_date": str(t), "hearing_time": "11:00", "hearing_location": "Room 2",
                                                            "committee_codes": [self.elena.employee_code, self.amit.employee_code]}), 201)["data"]
        self.assertEqual((d["status"], len(d["committee"])), ("Hearing Scheduled", 2))
        self.assertEqual(self.P("/api/relations/disciplinary/", {**base, "notice_served_on": str(t - timedelta(days=5)), "hearing_date": str(t)}).status_code, 400)       # duplicate
        u = f"/api/relations/disciplinary/{d['id']}"
        self.assertEqual(self.P(f"{u}/decide/", {"outcome": "Exonerated"}).status_code, 409)                              # no decision before the hearing
        self.assertEqual(self.P(f"{u}/record-hearing/", {}).status_code, 400)
        self.assertEqual(self.j(self.P(f"{u}/record-hearing/", {"minutes": "Employee heard; witness examined"}), 200)["data"]["status"], "Hearing Held")
        self.assertEqual(self.P(f"{u}/decide/", {"outcome": "Penalty Imposed"}).status_code, 400)                         # penalty text needed
        dd = self.j(self.P(f"{u}/decide/", {"outcome": "Penalty Imposed", "penalty": "3 day suspension"}), 200)["data"]
        self.assertEqual((dd["status"], dd["outcome"], dd["decided_by"] is not None), ("Decision Issued", "Penalty Imposed", True))
        self.assertEqual(self.a.patch(f"{u}/", {"charge": "x"}, format="json").status_code, 400)                          # locked
        self.assertEqual(self.a.delete(f"{u}/").status_code, 409)
        self.j(self.P(f"{u}/appeal/", {"reason": "Disproportionate"}), 200)
        self.assertEqual(self.j(self.P(f"{u}/close/"), 200)["data"]["status"], "Closed")
        d2 = self.j(self.P("/api/relations/disciplinary/", {**base, "action_type": "Show Cause Notice"}), 201)["data"]
        self.assertEqual(d2["status"], "Notice Issued")
        self.assertEqual(self.P(f"/api/relations/disciplinary/{d2['id']}/schedule-hearing/", {"hearing_date": str(t + timedelta(days=1))}).status_code, 400)
        self.j(self.P(f"/api/relations/disciplinary/{d2['id']}/schedule-hearing/", {"hearing_date": str(t + timedelta(days=7)), "committee_codes": [self.elena.employee_code]}), 200)
        self.assertEqual(self.P(f"/api/relations/disciplinary/{d2['id']}/record-hearing/", {"minutes": "x"}).status_code, 409)   # hearing is in the future
        self.j(self.P(f"/api/relations/disciplinary/{d2['id']}/cancel/", {"reason": "Withdrawn by HR"}), 200)
        self.j(self.a.delete(f"/api/relations/disciplinary/{d2['id']}/"), 200)
        self.assertEqual(len(self.j(self.a.get(f"/api/relations/disciplinary/?case={c['case_id']}"))["data"]), 1)

    # ---------------- warnings ----------------
    def test_warnings_use_existing_letter_engine(self):
        t = timezone.localdate()
        body = {"employee_code": self.vikram.employee_code, "level": "written warning", "reason": "Unauthorized absenteeism during notice period", "incident_date": str(t - timedelta(days=3))}
        w = self.j(self.P("/api/relations/warnings/", body), 201)["data"]
        self.assertEqual((w["warning_id"], w["warning_level"], w["status"], w["has_letter"]), (f"WRN-{t.year}-01", "Written Warning", "Issued", True))
        self.assertIsNotNone(w["valid_until"])
        self.assertEqual(self.P("/api/relations/warnings/", {**body, "reason": " unauthorized  ABSENTEEISM during notice period "}).status_code, 400)      # duplicate
        for bad in ({"level": "Angry"}, {"reason": " "}, {"incident_date": "2999-01-01"}, {"employee_code": "X"}):
            self.assertEqual(self.P("/api/relations/warnings/", {**body, "reason": "other", **bad}).status_code, 400, bad)
        L = self.j(self.a.get(f"/api/relations/warnings/{w['id']}/letter/"), 200)["data"]
        self.assertIn("Unauthorized absenteeism", L["body"])
        self.assertIn("Vikram Rao", L["body"])
        self.assertTrue(L["pdf_url"].endswith(".pdf"))
        from People.models import EmployeeLetter
        self.assertEqual(EmployeeLetter.objects.filter(company=self.co, letter_type="DISCIPLINARY_WARNING").count(), 1)  # engine reused, not duplicated
        d = self.j(self.P("/api/relations/warnings/", {**body, "reason": "Second matter", "issue": False}), 201)["data"]
        self.assertEqual((d["warning_id"], d["status"]), (f"WRN-{t.year}-02", "Draft"))
        pv = self.j(self.a.get(f"/api/relations/warnings/{d['id']}/letter/"), 200)
        self.assertIn("preview", pv["message"].lower())
        self.j(self.a.patch(f"/api/relations/warnings/{d['id']}/", {"reason": "Second matter (edited)"}, format="json"), 200)
        self.assertEqual(self.a.patch(f"/api/relations/warnings/{w['id']}/", {"reason": "x"}, format="json").status_code, 400)       # issued = locked
        self.assertEqual(self.a.delete(f"/api/relations/warnings/{w['id']}/").status_code, 409)
        self.assertEqual(self.j(self.P(f"/api/relations/warnings/{d['id']}/issue/"), 200)["data"]["status"], "Issued")
        self.assertEqual(self.P(f"/api/relations/warnings/{d['id']}/issue/").status_code, 409)
        self.assertEqual(self.P(f"/api/relations/warnings/{d['id']}/withdraw/", {}).status_code, 400)
        self.j(self.P(f"/api/relations/warnings/{d['id']}/withdraw/", {"reason": "Issued in error"}), 200)
        self.j(self.a.delete(f"/api/relations/warnings/{d['id']}/"), 200)
        self.assertEqual(len(self.j(self.a.get("/api/relations/warnings/?active=true"))["data"]), 1)
        self.assertEqual(len(self.j(self.a.get("/api/relations/warnings/?level=Written Warning&employee=" + self.vikram.employee_code))["data"]), 1)          # the withdrawn + deleted draft is gone

    # ---------------- legal ----------------
    def test_legal_cases(self):
        t = timezone.localdate()
        s0 = self.j(self.a.get("/api/relations/legal-cases/summary/"), 200)
        self.assertIn("No active legal or industrial dispute claims pending against", s0["message"])
        l = self.j(self.P("/api/relations/legal-cases/", {"case_type": "labour tribunal", "title": "Wrongful termination claim", "employee_code": self.vikram.employee_code, "forum": "Pune Labour Court",
                                                          "court_case_number": "LC/2026/118", "filed_on": str(t - timedelta(days=20)), "next_hearing_date": str(t + timedelta(days=9)),
                                                          "claim_amount": 250000, "counsel_name": "Adv. Mehta"}), 201)["data"]
        self.assertEqual((l["legal_id"], l["case_type"], l["claimant"], l["is_active_dispute"]), (f"LEG-{t.year}-01", "Labour Tribunal", "Vikram Rao", True))
        for bad in ({"court_case_number": "lc/2026/118", "title": "Other"}, {"title": "wrongful termination CLAIM", "court_case_number": None}, {"case_type": "Duel"},
                    {"title": "n", "employee_code": None, "claimant": None}, {"title": "n2", "claim_amount": -5}, {"title": "n3", "filed_on": "2999-01-01"}, {"title": "n4", "next_hearing_date": str(t - timedelta(days=400))}):
            body = {"case_type": "Legal Notice", "title": "Another", "claimant": "Mr X", **bad}
            if bad.get("title") == "wrongful termination CLAIM":
                body = {"case_type": "Labour Tribunal", "title": "wrongful termination CLAIM", "employee_code": self.vikram.employee_code}
            self.assertEqual(self.P("/api/relations/legal-cases/", body).status_code, 400, bad)
        l2 = self.j(self.P("/api/relations/legal-cases/", {"case_type": "Legal Notice", "title": "Notice from ex-employee", "claimant": "Mr R. Kulkarni"}), 201)["data"]
        self.assertEqual(l2["legal_id"], f"LEG-{t.year}-02")
        summ = self.j(self.a.get("/api/relations/legal-cases/summary/"))["data"]
        self.assertEqual((summ["active"], summ["active_claim_amount"], len(summ["upcoming_hearings"])), (2, 250000.0, 1))
        u = f"/api/relations/legal-cases/{l['id']}"
        self.j(self.P(f"{u}/status/", {"status": "Hearing Scheduled"}), 200)
        self.assertEqual(self.P(f"/api/relations/legal-cases/{l2['id']}/status/", {"status": "Hearing Scheduled"}).status_code, 400)       # no hearing date
        self.assertEqual(self.P(f"{u}/status/", {"status": "Won"}).status_code, 400)                                      # outcome needed
        self.assertEqual(self.j(self.P(f"{u}/status/", {"status": "Settled", "outcome": "Settled for 1,50,000"}), 200)["data"]["is_active_dispute"], False)
        self.assertEqual(self.a.patch(f"{u}/", {"notes": "x"}, format="json").status_code, 400)
        self.assertEqual(self.P(f"{u}/reopen/", {}).status_code, 400)
        self.j(self.P(f"{u}/reopen/", {"remarks": "appeal filed"}), 200)
        self.j(self.a.patch(f"{u}/", {"counsel_name": "Adv. Shah"}, format="json"), 200)
        self.j(self.P(f"{u}/update/", {"notes": "hearing prep"}), 200)
        self.assertEqual(len(self.j(self.a.get("/api/relations/legal-cases/?active=true&case_type=Labour Tribunal"))["data"]), 1)
        self.assertEqual(self.a.delete(f"{u}/").status_code, 409)                                                         # under review
        self.j(self.a.delete(f"/api/relations/legal-cases/{l2['id']}/"), 200)

    # ---------------- vault ----------------
    def test_vault_restricted_logged_and_deduplicated(self):
        c = self.case()
        f = lambda name="statement.pdf", data=b"%PDF-1.4 statement": SimpleUploadedFile(name, data, content_type="application/pdf")
        url = "/api/relations/documents/"
        up = lambda **k: self.a.post(url, {"file": f(), "title": "Supervisor statement", "doc_type": "Statement", "case": c["case_id"], **k}, format="multipart")
        d = self.j(up(), 201)["data"]
        self.assertEqual((d["doc_type"], d["file_name"], d["confidentiality"], len(d["sha256"])), ("Statement", "statement.pdf", "Confidential", 64))
        self.assertNotIn("private_media", json.dumps(d))                                                                  # no storage path leaks
        self.assertEqual(up().status_code, 400)                                                                           # same file, same case
        self.assertEqual(self.a.post(url, {"file": f("other.pdf", b"different"), "case": c["case_id"]}, format="multipart").status_code, 201)
        for bad in ({"file": f("virus.exe", b"MZ")}, {"file": f("empty.pdf", b"")}, {"file": f("n.pdf", b"x"), "doc_type": "Poem"}, {"file": f("n2.pdf", b"y"), "confidentiality": "Public"},
                    {"file": f("n3.pdf", b"z"), "case": None}, {"file": f("n4.pdf", b"w"), "case": "CASE-99"}):
            body = {"case": c["case_id"], **bad}
            self.assertEqual(self.a.post(url, {k: v for k, v in body.items() if v is not None}, format="multipart").status_code, 400, list(bad))
        self.assertEqual(self.a.post(url, {"title": "no file", "case": c["case_id"]}, format="multipart").status_code, 400)
        big = SimpleUploadedFile("big.pdf", b"0" * (10 * 1024 * 1024 + 1), content_type="application/pdf")
        self.assertEqual(self.a.post(url, {"file": big, "case": c["case_id"]}, format="multipart").status_code, 400)
        dl = self.a.get(f"{url}{d['id']}/download/")
        self.assertEqual((dl.status_code, b"".join(dl.streaming_content)), (200, b"%PDF-1.4 statement"))
        self.assertIn("attachment", dl["Content-Disposition"])
        self.j(self.a.get(f"{url}{d['id']}/"), 200)
        self.j(self.a.patch(f"{url}{d['id']}/", {"title": "Statement (signed)", "confidentiality": "Restricted"}, format="json"), 200)
        rep = self.j(self.a.patch(f"{url}{d['id']}/", {"file": f("statement_v2.pdf", b"%PDF new version")}, format="multipart"), 200)["data"]
        self.assertEqual(rep["file_name"], "statement_v2.pdf")
        acts = [x["action"] for x in self.j(self.a.get(f"{url}{d['id']}/access-log/"), 200)["data"]]
        self.assertEqual(sorted(set(acts)), ["DOWNLOAD", "UPDATE", "UPLOAD", "VIEW"])
        self.assertEqual(len(self.j(self.a.get(f"{url}?case={c['case_id']}&doc_type=Statement"))["data"]), 1)
        self.assertEqual(self.a.delete(f"/api/relations/cases/{c['id']}/").status_code, 409)                              # documents linked
        # access control: HR with edit rights is NOT enough
        hr = self.emp(self.elena)
        self.assertEqual(hr.get(url).status_code, 403)
        self.assertEqual(hr.get(f"{url}{d['id']}/download/").status_code, 403)
        self.assertEqual(self.emp(self.vikram).get(url).status_code, 403)
        self.assertEqual(self.j(hr.put("/api/relations/settings/", {"legal_counsel_code": self.counsel.employee_code}, format="json").status_code if False else hr.get("/api/relations/settings/"), 200)["code"], "RELATIONS_SETTINGS")
        self.assertEqual(hr.put("/api/relations/settings/", {"hr_head_code": self.elena.employee_code}, format="json").status_code, 403)   # only the Company Admin
        self.j(self.a.put("/api/relations/settings/", {"legal_counsel_code": self.counsel.employee_code, "vault_members_codes": [self.amit.employee_code]}, format="json"), 200)
        self.assertEqual(self.emp(self.counsel).get(url).status_code, 200)                                              # Legal Counsel
        self.assertEqual(self.emp(self.amit).get(url).status_code, 200)                                                 # named member
        self.assertEqual(hr.get(url).status_code, 403)
        self.j(self.a.put("/api/relations/settings/", {"hr_head_code": self.elena.employee_code}, format="json"), 200)
        self.assertEqual(self.emp(self.elena).get(url).status_code, 200)                                                # HR Head
        self.assertEqual(self.j(self.emp(self.counsel).get(f"{url}access-log/"), 200)["meta"]["total"] >= 5, True)
        self.assertEqual(cli(self.other).get(f"{url}{d['id']}/download/").status_code, 404)                              # B2B
        self.j(self.a.delete(f"{url}{d['id']}/"), 200)
        self.assertEqual(self.a.get(f"{url}{d['id']}/download/").status_code, 404)
        self.assertTrue(DocumentAccessLog.objects.filter(document_id=d["id"], action="DELETE").exists())
        self.assertTrue(CaseDocument.objects.filter(pk=d["id"], is_active=False).exists())                              # kept for legal hold
        self.assertEqual(self.P(f"{url}{d['id']}/update/", {}).status_code, 404)

    # ---------------- employee side ----------------
    def test_employee_raises_and_tracks_case(self):
        me = self.emp(self.ananya)
        E = "/employee/relations"
        body = {"category": "Grievance", "subject": "Manager communication feedback", "description": "Unclear priorities", "against_employee_code": self.amit.employee_code}
        c = self.j(me.post(f"{E}/cases/", body, format="json"), 201)["data"]
        self.assertEqual((c["case_id"], c["status"], c["can_edit"], c["about_employee"]), ("CASE-01", "Open", True, "Amit Joshi"))
        self.assertNotIn("severity", c)
        self.assertNotIn("investigator", json.dumps(c))
        self.assertEqual(me.post(f"{E}/cases/", body, format="json").status_code, 400)                                  # duplicate
        for bad in ({"category": "Disciplinary"}, {"subject": " "}, {"against_employee_code": self.ananya.employee_code}, {"incident_date": "2999-01-01"}):
            self.assertEqual(me.post(f"{E}/cases/", {**body, "subject": "Other", **bad}, format="json").status_code, 400, bad)
        self.j(me.patch(f"{E}/cases/{c['id']}/", {"description": "More detail"}, format="json"), 200)
        self.j(me.post(f"{E}/cases/{c['id']}/update/", {"subject": "Manager communication feedback (updated)"}), 200)
        self.assertEqual(len(self.j(me.get(f"{E}/cases/"))["data"]), 1)
        # HR works the case; internal notes stay hidden from the employee
        self.P(f"/api/relations/cases/{c['id']}/assign/", {"investigator_code": self.elena.employee_code})
        self.P(f"/api/relations/cases/{c['id']}/notes/", {"text": "Internal: manager has history", "is_internal": True})
        self.P(f"/api/relations/cases/{c['id']}/notes/", {"text": "We have started the review.", "is_internal": False})
        self.assertEqual(me.patch(f"{E}/cases/{c['id']}/", {"description": "x"}, format="json").status_code, 409)         # assigned -> locked
        d = self.j(me.get(f"{E}/cases/{c['id']}/"), 200)["data"]
        texts = [u["text"] for u in d["updates"]]
        self.assertIn("We have started the review.", texts)
        self.assertFalse(any("Internal" in x for x in texts))
        self.j(me.post(f"{E}/cases/{c['id']}/notes/", {"text": "Adding a screenshot reference"}, format="json"), 201)
        self.assertEqual(me.post(f"{E}/cases/{c['id']}/notes/", {"text": " "}, format="json").status_code, 400)
        self.assertEqual(self.emp(self.vikram).get(f"{E}/cases/{c['id']}/").status_code, 404)                            # someone else's case
        self.assertEqual(self.emp(self.vikram).get(f"{E}/cases/").json()["data"], [])
        self.P(f"/api/relations/cases/{c['id']}/resolve/", {"resolution_type": "Settled", "resolution_summary": "Mediation held"})
        d = self.j(me.get(f"{E}/cases/{c['id']}/"), 200)["data"]
        self.assertEqual((d["status"], d["resolution_summary"]), ("Resolved", "Mediation held"))
        self.assertEqual(me.delete(f"{E}/cases/{c['id']}/").status_code, 409)                                             # resolved cannot be withdrawn
        c2 = self.j(me.post(f"{E}/cases/", {"category": "Other", "subject": "Parking"}, format="json"), 201)["data"]
        self.assertIsNone(c2["about_employee"])
        self.j(me.delete(f"{E}/cases/{c2['id']}/"), 200)
        self.assertEqual(self.j(me.get(f"{E}/cases/?status=Withdrawn"))["data"][0]["case_id"], "CASE-02")
        c3 = self.j(me.post(f"{E}/cases/", {"category": "Other", "subject": "Canteen"}, format="json"), 201)["data"]
        self.j(me.post(f"{E}/cases/{c3['id']}/delete/"), 200)
        self.assertEqual(self.j(me.get(f"{E}/dashboard/"), 200)["data"]["my_cases_resolved"], 1)

    def test_anonymous_case_hides_identity(self):
        me, E = self.emp(self.ananya), "/employee/relations"
        r = self.j(me.post(f"{E}/cases/", {"category": "Harassment", "subject": "Hostile remarks in team chat", "anonymous": True}, format="json"), 201)["data"]
        self.assertTrue(r["tracking_token"].startswith("ANON-"))
        row = ERCase.objects.get(pk=r["id"])
        self.assertIsNone(row.raised_by_id)                                                                              # no link to the person
        self.assertIsNone(row.created_by)
        self.assertEqual((row.source, row.severity, row.employee_id), ("Anonymous", "High", None))
        self.assertNotIn(r["tracking_token"], row.tracking_hash)                                                         # only a hash is stored
        self.assertEqual(self.j(me.get(f"{E}/cases/"))["data"], [])                                                      # not listed under "my cases"
        self.P(f"/api/relations/cases/{r['id']}/notes/", {"text": "Looking into it", "is_internal": False})
        t = self.j(self.emp(self.vikram).post(f"{E}/track/", {"token": r["tracking_token"]}, format="json"), 200)["data"]   # any employee holding the token can follow it
        self.assertEqual((t["case_id"], t["is_anonymous"]), ("CASE-01", True))
        self.assertIn("Looking into it", [u["text"] for u in t["updates"]])
        self.assertEqual(me.post(f"{E}/track/", {"token": "ANON-WRONG"}, format="json").status_code, 404)
        self.assertEqual(me.post(f"{E}/track/", {}, format="json").status_code, 400)
        a = self.j(self.a.get(f"/api/relations/cases/{r['id']}/"), 200)["data"]
        self.assertEqual((a["is_anonymous"], a["raised_by"], a["employee"]), (True, None, None))

    def test_employee_warnings_and_disciplinary(self):
        t = timezone.localdate()
        w = self.j(self.P("/api/relations/warnings/", {"employee_code": self.vikram.employee_code, "level": "Written Warning", "reason": "Absenteeism"}), 201)["data"]
        self.P("/api/relations/warnings/", {"employee_code": self.vikram.employee_code, "level": "Verbal Warning", "reason": "Draft one", "issue": False})
        me, E = self.emp(self.vikram), "/employee/relations"
        lst = self.j(me.get(f"{E}/warnings/"), 200)["data"]
        self.assertEqual([x["warning_id"] for x in lst], [f"WRN-{t.year}-01"])                                            # draft is invisible
        det = self.j(me.get(f"{E}/warnings/{w['id']}/"), 200)["data"]
        self.assertIn("Absenteeism", det["letter"]["body"])
        self.assertEqual(self.emp(self.ananya).get(f"{E}/warnings/{w['id']}/").status_code, 404)
        self.assertEqual(self.j(me.post(f"{E}/warnings/{w['id']}/acknowledge/", {"remarks": "Received"}, format="json"), 200)["data"]["status"], "Acknowledged")
        self.assertEqual(me.post(f"{E}/warnings/{w['id']}/acknowledge/", {}, format="json").status_code, 409)
        d = self.j(self.P("/api/relations/disciplinary/", {"employee_code": self.vikram.employee_code, "action_type": "Inquiry", "charge": "Absence", "notice_served_on": str(t - timedelta(days=5)),
                                                           "hearing_date": str(t), "committee_codes": [self.elena.employee_code]}), 201)["data"]
        n = self.j(me.get(f"{E}/disciplinary/"), 200)["data"][0]
        self.assertEqual((n["status"], n["committee"]), ("Hearing Scheduled", ["Elena Rostova"]))
        self.assertNotIn("minutes", n)
        self.assertEqual(me.post(f"{E}/disciplinary/{d['id']}/respond/", {}, format="json").status_code, 400)
        self.assertEqual(self.j(me.post(f"{E}/disciplinary/{d['id']}/respond/", {"response": "I was ill"}, format="json"), 200)["data"]["employee_response"], "I was ill")
        self.assertEqual(me.post(f"{E}/disciplinary/{d['id']}/appeal/", {"reason": "x"}, format="json").status_code, 409)       # no decision yet
        self.P(f"/api/relations/disciplinary/{d['id']}/record-hearing/", {"minutes": "Heard"})
        self.P(f"/api/relations/disciplinary/{d['id']}/decide/", {"outcome": "Warning Issued"})
        self.assertEqual(me.post(f"{E}/disciplinary/{d['id']}/respond/", {"response": "late"}, format="json").status_code, 409)
        self.assertEqual(me.post(f"{E}/disciplinary/{d['id']}/appeal/", {}, format="json").status_code, 400)
        self.assertEqual(self.j(me.post(f"{E}/disciplinary/{d['id']}/appeal/", {"reason": "Disproportionate"}, format="json"), 200)["data"]["status"], "Appealed")
        self.assertEqual(self.emp(self.ananya).get(f"{E}/disciplinary/{d['id']}/").status_code, 404)
        self.assertEqual(self.j(me.get(f"{E}/dashboard/"))["data"]["warnings_to_acknowledge"], 0)

    def test_investigator_workflow(self):
        c = self.case(self.vikram)
        self.P(f"/api/relations/cases/{c['id']}/assign/", {"investigator_code": self.amit.employee_code})
        inv, E = self.emp(self.amit), "/employee/relations/investigations"
        self.assertEqual(len(self.j(inv.get(f"{E}/"), 200)["data"]), 1)
        d = self.j(inv.get(f"{E}/{c['id']}/"), 200)["data"]
        self.assertEqual((d["case_id"], d["employee"]["name"]), ("CASE-01", "Vikram Rao"))
        self.assertEqual(self.emp(self.elena).get(f"{E}/{c['id']}/").status_code, 404)                                    # not the assigned investigator
        self.assertEqual(self.emp(self.vikram).get(f"{E}/").json()["data"], [])
        self.j(inv.post(f"{E}/{c['id']}/notes/", {"text": "Interviewed supervisor"}, format="json"), 201)
        self.j(inv.post(f"{E}/{c['id']}/notes/", {"text": "Please share attendance log", "is_internal": False}, format="json"), 201)
        self.assertEqual(inv.post(f"{E}/{c['id']}/status/", {"status": "Closed"}, format="json").status_code, 400)
        self.j(inv.post(f"{E}/{c['id']}/status/", {"status": "Pending Review"}, format="json"), 200)
        self.assertEqual(inv.post(f"{E}/{c['id']}/resolve/", {"resolution_type": "Settled"}, format="json").status_code, 400)
        r = self.j(inv.post(f"{E}/{c['id']}/resolve/", {"resolution_type": "Substantiated", "resolution_summary": "Absence confirmed"}, format="json"), 200)["data"]
        self.assertEqual(r["status"], "Resolved")
        self.assertEqual(inv.post(f"{E}/{c['id']}/resolve/", {"resolution_type": "Settled", "resolution_summary": "x"}, format="json").status_code, 409)
        self.assertEqual(self.j(self.a.get(f"/api/relations/cases/{c['id']}/"))["data"]["resolution_type"], "Substantiated")

    # ---------------- permissions, summary, central audit ----------------
    def test_permissions_summary_and_audit(self):
        self.case()
        for who_, code in ((self.vikram, 403),):
            for url in ("/api/relations/cases/", "/api/relations/warnings/", "/api/relations/legal-cases/", "/api/relations/summary/", "/api/relations/settings/"):
                self.assertEqual(self.emp(who_).get(url).status_code, code, url)                                          # plain role (view employees only)
        hr = self.emp(self.elena)
        self.assertEqual(hr.get("/api/relations/cases/").status_code, 200)
        self.assertEqual(hr.post("/api/relations/cases/", {"employee_code": self.ananya.employee_code, "category": "Grievance", "subject": "HR made"}, format="json").status_code, 201)
        EmployeeRole.objects.filter(pk=self.hr_role.pk).update(can_delete_employees=False, can_manage_employees=False)
        self.assertEqual(self.emp(self.elena).delete("/api/relations/cases/1/").status_code, 403)
        self.assertEqual(APIClient().get("/api/relations/cases/").status_code, 401)
        self.assertEqual(APIClient().get("/employee/relations/dashboard/").status_code, 401)
        self.assertEqual(self.a.get("/employee/relations/dashboard/").status_code, 403)                                  # company token on employee API
        s = self.j(self.a.get("/api/relations/summary/"), 200)["data"]
        self.assertEqual((s["cases_total"], s["cases_open"], s["open_by_severity"]["High"]), (2, 2, 1))
        mt = self.j(self.a.get("/api/relations/meta/"), 200)["data"]
        self.assertEqual(mt["tabs"][0], "hr-cases")
        self.assertIn("Final Written Warning", mt["warning_levels"])
        try:
            from AdminCenter.models import AdminAuditEvent
            self.assertGreaterEqual(AdminAuditEvent.objects.filter(company=self.co, module="HR Cases", action="CREATED").count(), 1)   # central trail
        except ImportError:
            pass
        self.assertEqual(cli(self.other).get("/api/relations/summary/").json()["data"]["cases_total"], 0)
