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

from django.test import TestCase, override_settings
from django.utils import timezone
from rest_framework.test import APIClient
from rest_framework_simplejwt.tokens import RefreshToken

from Company.models import AuthLog, company_details
from Employee.models import Department, EmployeeAccount, EmployeeDT, EmployeeRole
from People.models import Branch

from AdminCenter.models import AdminAuditEvent, IntegrationConnector

TMP = tempfile.mkdtemp()


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 AdminCenterTests(TestCase):
    @classmethod
    def tearDownClass(cls):
        shutil.rmtree(TMP, ignore_errors=True)
        super().tearDownClass()

    def setUp(self):
        self.co, self.other = mk_company("ac1@x.com"), mk_company("ac2@x.com")
        self.a = cli(self.co)
        self.hr_role = EmployeeRole.objects.create(company=self.co, role_name="HR Admin", role_code="hr_admin", can_view_employees=True, can_view_payroll=True)
        self.emp_role = EmployeeRole.objects.create(company=self.co, role_name="Employee", role_code="employee")
        self.rahul = self.mk_user("Rahul Sharma", "rahul@z.com", self.emp_role)
        self.elena = self.mk_user("Elena Rostova", "elena@z.com", self.hr_role)
        self.P = lambda u, d=None: self.a.post(u, d if d is not None else {}, format="json")

    def mk_user(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            # what EmployeeJWTAuthentication does in production
        return cli(u)

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

    # ---------------- Companies / org / master ----------------
    def test_legal_entities(self):
        z = self.j(self.P("/api/admin-center/legal-entities/", {"name": "Zenith Technologies Pvt Ltd", "code": "zen-in", "tax_id": "U72200PN2019PTC184421", "country": "India", "currency": "inr", "timezone": "Asia/Kolkata"}), 201)["data"]
        self.assertEqual((z["code"], z["currency"], z["is_primary"]), ("ZEN-IN", "INR", True))
        self.assertEqual(self.P("/api/admin-center/legal-entities/", {"name": "Other", "code": "ZEN-IN"}).status_code, 400)           # dup code
        self.assertEqual(self.P("/api/admin-center/legal-entities/", {"name": "zenith technologies pvt ltd", "code": "X"}).status_code, 400)  # dup name
        self.assertEqual(self.P("/api/admin-center/legal-entities/", {"name": "B", "code": "B", "currency": "RUPEE"}).status_code, 400)
        self.assertEqual(self.P("/api/admin-center/legal-entities/", {"name": "B", "code": "B", "timezone": "Mars/Base"}).status_code, 400)
        us = self.j(self.P("/api/admin-center/legal-entities/", {"name": "Zenith Global Inc", "code": "ZEN-US", "currency": "USD", "is_primary": True}), 201)["data"]
        self.assertFalse(self.j(self.a.get(f"/api/admin-center/legal-entities/{z['id']}/"))["data"]["is_primary"])      # primary moved
        self.assertEqual(self.a.delete(f"/api/admin-center/legal-entities/{us['id']}/").status_code, 409)                 # primary + others
        self.j(self.a.patch(f"/api/admin-center/legal-entities/{z['id']}/", {"status": "Inactive"}, format="json"), 200)
        self.j(self.a.put(f"/api/admin-center/legal-entities/{z['id']}/", {"country": "IN"}, format="json"), 200)
        self.j(self.P(f"/api/admin-center/legal-entities/{z['id']}/update/", {"address": "Pune"}), 200)
        self.j(self.a.delete(f"/api/admin-center/legal-entities/{z['id']}/"), 200)
        self.j(self.P("/api/admin-center/legal-entities/", {"name": "Zenith Technologies Pvt Ltd", "code": "ZEN-IN"}), 201)  # code reusable after delete
        self.assertEqual(self.j(cli(self.other).get("/api/admin-center/legal-entities/"))["data"], [])                      # B2B

    def test_org_units_link_existing_dept_and_branch(self):
        d = Department.objects.create(company=self.co, name="Human Resources", code="HR")
        Branch.objects.create(company=self.co, name="Pune Office", code="PNQ")
        rows = self.j(self.a.get("/api/admin-center/org-units/"), 200)["data"]
        self.assertEqual({(r["unit_type"], r["name"]) for r in rows}, {("Department", "Human Resources"), ("Location", "Pune Office")})
        self.a.get("/api/admin-center/org-units/")
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/org-units/"))["data"]), 2)                               # no duplicates on re-sync
        u = self.j(self.P("/api/admin-center/org-units/", {"unit_type": "Department", "name": "Technology & Engineering", "code": "tech", "parent_name": "Operations",
                                                           "head_employee_code": self.rahul.employee_code}), 201)["data"]
        self.assertEqual((u["parent_structure"], u["head_manager"], u["code"]), ("Operations", "Rahul Sharma", "TECH"))
        self.assertTrue(Department.objects.filter(company=self.co, name="Technology & Engineering").exists())             # real Department created, not a copy
        self.assertEqual(self.P("/api/admin-center/org-units/", {"unit_type": "Department", "name": "technology & engineering"}).status_code, 400)
        self.assertEqual(self.P("/api/admin-center/org-units/", {"unit_type": "Galaxy", "name": "X"}).status_code, 400)
        child = self.j(self.P("/api/admin-center/org-units/", {"unit_type": "Division", "name": "Platform", "parent": u["id"]}), 201)["data"]
        self.assertEqual(self.a.patch(f"/api/admin-center/org-units/{u['id']}/", {"parent": child["id"]}, format="json").status_code, 400)   # cycle
        self.assertEqual(self.a.delete(f"/api/admin-center/org-units/{u['id']}/").status_code, 409)                         # has child
        self.j(self.a.patch(f"/api/admin-center/org-units/{u['id']}/", {"name": "Tech Eng"}, format="json"), 200)
        self.assertTrue(Department.objects.filter(company=self.co, name="Tech Eng").exists())                              # renamed in Department too
        self.j(self.a.delete(f"/api/admin-center/org-units/{child['id']}/"), 200)
        dep = Department.objects.get(company=self.co, name="Tech Eng")
        EmployeeDT.objects.filter(pk=self.rahul.pk).update(department=dep)
        self.assertEqual(self.a.delete(f"/api/admin-center/org-units/{u['id']}/").status_code, 409)                         # employees assigned
        EmployeeDT.objects.filter(pk=self.rahul.pk).update(department=None)
        self.j(self.a.delete(f"/api/admin-center/org-units/{u['id']}/"), 200)
        self.assertFalse(Department.objects.get(pk=dep.pk).is_active)
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/org-units/?unit_type=Location"))["data"]), 1)
        self.assertGreater(d.id, 0)

    def test_master_data(self):
        m = self.j(self.P("/api/admin-center/master-data/", {"category": "Leave Type", "value": "Casual Leave", "code": "cl"}), 201)["data"]
        self.assertEqual((m["code"], m["sort_order"]), ("CL", 1))
        self.assertEqual(self.j(self.P("/api/admin-center/master-data/", {"category": "Leave Type", "value": "Sick Leave", "code": "SL"}), 201)["data"]["sort_order"], 2)
        self.assertEqual(self.P("/api/admin-center/master-data/", {"category": "leave type", "value": "Other", "code": "CL"}).status_code, 400)
        self.assertEqual(self.P("/api/admin-center/master-data/", {"category": "Leave Type", "value": "casual leave", "code": "XX"}).status_code, 400)
        self.j(self.P("/api/admin-center/master-data/", {"category": "Asset Type", "value": "Laptop", "code": "CL"}), 201)       # same code, other category OK
        self.assertEqual({c["category"]: c["values"] for c in self.j(self.a.get("/api/admin-center/master-data/categories/"))["data"]}, {"Asset Type": 1, "Leave Type": 2})
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/master-data/?category=Leave Type&search=sick"))["data"]), 1)
        self.j(self.a.patch(f"/api/admin-center/master-data/{m['id']}/", {"status": "Inactive", "sort_order": 5}, format="json"), 200)
        self.j(self.a.delete(f"/api/admin-center/master-data/{m['id']}/"), 200)
        self.j(self.P("/api/admin-center/master-data/", {"category": "Leave Type", "value": "Casual Leave", "code": "CL"}), 201)  # reusable

    # ---------------- workflows / jobs / integrations ----------------
    def test_workflows(self):
        body = {"name": "Leave Approval Chain", "module": "leave", "trigger_event": "On Submit", "sla_hours": 24,
                "steps": [{"approver_type": "Reporting Manager"}, {"role_code": "hr_admin"}]}
        w = self.j(self.P("/api/admin-center/workflows/", body), 201)["data"]
        self.assertEqual((w["module"], w["levels_label"], w["sla_label"], w["approver_chain"]), ("Leave", "2 Tier", "24 Hrs", "Reporting Manager → HR Admin"))
        self.assertEqual(self.P("/api/admin-center/workflows/", body).status_code, 400)                                    # dup
        for bad in ({"steps": []}, {"steps": [{"approver_type": "Wizard"}]}, {"steps": [{"role_code": "nope"}]}, {"module": "Moon"}):
            self.assertEqual(self.P("/api/admin-center/workflows/", {**body, "name": "W2", **bad}).status_code, 400)
        w = self.j(self.a.patch(f"/api/admin-center/workflows/{w['id']}/", {"steps": [{"approver_type": "HOD"}], "status": "Draft"}, format="json"), 200)["data"]
        self.assertEqual((w["levels"], w["approver_chain"], w["status"]), (1, "HOD", "Draft"))
        self.assertEqual(self.j(self.a.get("/api/admin-center/workflows/?module=Leave"))["data"][0]["name"], "Leave Approval Chain")
        self.assertEqual(self.j(self.a.get("/api/admin-center/workflows/legacy/"), 200)["data"], [])
        self.j(self.a.delete(f"/api/admin-center/workflows/{w['id']}/"), 200)
        self.j(self.P("/api/admin-center/workflows/", body), 201)

    def test_jobs(self):
        j = self.j(self.P("/api/admin-center/jobs/", {"name": "Nightly Database Backup", "job_type": "Backup", "schedule_type": "Daily", "time_of_day": "02:00"}), 201)["data"]
        self.assertEqual((j["schedule"], j["handler"], j["status"]), ("Every day 02:00 AM", "backup", "Active"))
        self.assertIsNotNone(j["next_scheduled_run"])
        self.assertEqual(self.j(self.P("/api/admin-center/jobs/", {"name": "W", "job_type": "Sync", "schedule_type": "Weekly", "day_of_week": 0, "time_of_day": "09:30"}), 201)["data"]["schedule"], "Weekly on Monday 09:30 AM")
        self.assertEqual(self.j(self.P("/api/admin-center/jobs/", {"name": "M", "job_type": "Payroll", "schedule_type": "Monthly", "day_of_month": 25}), 201)["data"]["schedule"], "25th of Month 02:00 AM")
        for bad in ({"name": "Nightly database backup", "job_type": "Backup"}, {"name": "X", "job_type": "Nope"}, {"name": "X", "job_type": "Sync", "schedule_type": "Hourly"},
                    {"name": "X", "job_type": "Sync", "time_of_day": "25:99"}, {"name": "X", "job_type": "Sync", "schedule_type": "Monthly", "day_of_month": 31}, {"name": "X", "job_type": "Sync", "handler": "rm-rf"}):
            self.assertEqual(self.P("/api/admin-center/jobs/", bad).status_code, 400, bad)
        r = self.j(self.P(f"/api/admin-center/jobs/{j['id']}/run/"), 200)["data"]
        self.assertEqual(r["last_run_status"], "Completed")
        self.assertIn("Snapshot", r["last_run_message"])
        self.assertEqual(self.j(self.P(f"/api/admin-center/jobs/{j['id']}/pause/"), 200)["data"]["next_scheduled_run"], None)
        self.assertEqual(self.j(self.P(f"/api/admin-center/jobs/{j['id']}/resume/"), 200)["data"]["status"], "Active")
        from AdminCenter.models import ScheduledJob
        ScheduledJob.objects.filter(pk=j["id"]).update(next_run_at=timezone.now() - timedelta(minutes=1))
        self.assertEqual(len(self.j(self.P("/api/admin-center/jobs/run-due/"), 200)["data"]), 1)
        self.assertEqual(len(self.j(self.P("/api/admin-center/jobs/run-due/"), 200)["data"]), 0)
        self.j(self.a.patch(f"/api/admin-center/jobs/{j['id']}/", {"schedule_type": "Weekdays", "time_of_day": "18:30"}, format="json"), 200)
        self.j(self.a.delete(f"/api/admin-center/jobs/{j['id']}/"), 200)

    def test_integrations_secret_never_returned(self):
        i = self.j(self.P("/api/admin-center/integrations/", {"name": "Corporate SMTP Gateway", "connector_type": "email", "endpoint": "smtp.office365.com:587", "version": "v2.1", "secret": "super-secret-key-1234"}), 201)["data"]
        self.assertEqual((i["has_secret"], i["secret_hint"], i["connector_type"], i["status"]), (True, "****1234", "Email", "Not Tested"))
        self.assertNotIn("super-secret", json.dumps(self.j(self.a.get(f"/api/admin-center/integrations/{i['id']}/"))))
        self.assertNotIn("super-secret", json.dumps(self.j(self.a.get("/api/admin-center/integrations/"))))
        row = IntegrationConnector.objects.get(pk=i["id"])
        self.assertNotIn("super-secret", row.secret_enc)                                                                  # encrypted at rest
        from AdminCenter.common import decrypt_secret
        self.assertEqual(decrypt_secret(row.secret_enc), "super-secret-key-1234")
        self.assertNotIn("super-secret", self.a.get("/api/admin-center/backup/export/").content.decode())              # not exported either
        self.assertEqual(self.P("/api/admin-center/integrations/", {"name": "corporate smtp gateway", "connector_type": "Email"}).status_code, 400)
        self.assertEqual(self.a.patch(f"/api/admin-center/integrations/{i['id']}/", {"status": "Connected"}, format="json").status_code, 400)    # status not forgeable
        self.assertFalse(self.j(self.a.patch(f"/api/admin-center/integrations/{i['id']}/", {"clear_secret": True}, format="json"), 200)["data"]["has_secret"])
        lo = self.j(self.P("/api/admin-center/integrations/", {"name": "Local", "connector_type": "REST API", "endpoint": "http://127.0.0.1:8000/x"}), 201)["data"]
        p = self.j(self.P(f"/api/admin-center/integrations/{lo['id']}/ping/"), 502)["data"]                                # SSRF guard
        self.assertEqual(p["status"], "Error")
        self.assertIn("Blocked", p["last_ping_message"])
        self.j(self.a.delete(f"/api/admin-center/integrations/{i['id']}/"), 200)

    # ---------------- users / rbac / sessions ----------------
    def test_users_crud_lock_and_guards(self):
        u = self.j(self.P("/api/admin-center/users/", {"name": "Sachin Patil", "email": "Sachin@Z.com", "password": "pass1234", "role": "hr_admin", "designation": "Finance"}), 201)["data"]
        self.assertEqual((u["email"], u["assigned_role"]["role_code"], u["status"]), ("sachin@z.com", "hr_admin", "Active"))
        self.assertNotIn("pass1234", json.dumps(u))
        self.assertEqual(self.P("/api/admin-center/users/", {"name": "Dup", "email": "SACHIN@z.com", "password": "pass1234"}).status_code, 400)
        self.assertEqual(self.P("/api/admin-center/users/", {"name": "X", "email": "x@z.com", "password": "123"}).status_code, 400)
        self.assertEqual(self.P("/api/admin-center/users/", {"name": "X", "email": "x@z.com", "password": "pass1234", "role": "ghost"}).status_code, 400)
        lst = self.j(self.a.get("/api/admin-center/users/?search=sachin"), 200)
        self.assertEqual((len(lst["data"]), lst["company_admin"]["assigned_role"]["role_name"]), (1, "Super Admin"))
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/users/?role=hr_admin"))["data"]), 2)
        self.j(self.a.patch(f"/api/admin-center/users/{u['id']}/", {"role": "employee", "designation": "Accountant"}, format="json"), 200)
        self.j(self.P(f"/api/admin-center/users/{u['id']}/update/", {"name": "Sachin P"}), 200)
        self.assertEqual(self.j(self.P(f"/api/admin-center/users/{u['id']}/lock/"), 200)["data"]["status"], "Locked")
        self.assertEqual(self.P(f"/api/admin-center/users/{u['id']}/lock/").status_code, 409)
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/users/?status=Locked"))["data"]), 1)
        EmployeeAccount.objects.filter(employee_id=u["id"]).update(failed_login_attempts=4)
        self.assertEqual(self.j(self.P(f"/api/admin-center/users/{u['id']}/unlock/"), 200)["data"]["failed_login_attempts"], 0)
        self.j(self.P(f"/api/admin-center/users/{u['id']}/reset-password/", {"new_password": "newpass99"}), 200)
        self.assertEqual(EmployeeDT.objects.get(pk=u["id"]).password, "newpass99")
        self.assertEqual(self.P(f"/api/admin-center/users/{u['id']}/reset-password/", {"new_password": "x"}).status_code, 400)
        self.j(self.P(f"/api/admin-center/users/{u['id']}/revoke-sessions/"), 200)
        self.j(self.a.delete(f"/api/admin-center/users/{u['id']}/"), 200)
        self.assertEqual(self.a.get(f"/api/admin-center/users/{u['id']}/").json()["data"]["status"], "Inactive")
        self.assertFalse(EmployeeAccount.objects.get(employee_id=u["id"]).is_login_enabled)
        # an HR user cannot lock / delete / re-role himself
        hr = EmployeeRole.objects.create(company=self.co, role_name="Admin", role_code="adm", can_manage_company=True)
        boss = self.mk_user("Boss", "boss@z.com", hr)
        b = self.emp(boss)
        self.assertEqual(b.post(f"/api/admin-center/users/{boss.id}/lock/", {}, format="json").status_code, 409)
        self.assertEqual(b.delete(f"/api/admin-center/users/{boss.id}/").status_code, 409)
        self.assertEqual(b.patch(f"/api/admin-center/users/{boss.id}/", {"role": "employee"}, format="json").status_code, 400)
        self.assertEqual(cli(self.other).get(f"/api/admin-center/users/{self.rahul.id}/").status_code, 404)

    def test_rbac_matrix(self):
        m = self.j(self.a.get("/api/admin-center/rbac/matrix/?modules=payroll,attendance"), 200)["data"]
        self.assertEqual({x["module"] for x in m["modules"]}, {"payroll", "attendance"})
        pay = [x for x in m["modules"] if x["module"] == "payroll"][0]
        self.assertTrue(pay["roles"][str(self.hr_role.id)]["access"])
        self.assertFalse(pay["roles"][str(self.emp_role.id)]["access"])
        self.j(self.a.put("/api/admin-center/rbac/matrix/", {"changes": [{"role_code": "employee", "module": "payroll", "allowed": True},
                                                                         {"role_id": self.hr_role.id, "module": "payroll", "action": "create", "allowed": True}]}, format="json"), 200)
        self.emp_role.refresh_from_db(), self.hr_role.refresh_from_db()
        self.assertTrue(self.emp_role.can_view_payroll and self.hr_role.can_create_payroll)
        self.j(self.a.put("/api/admin-center/rbac/matrix/", {"changes": [{"role_code": "hr_admin", "module": "payroll", "allowed": False}]}, format="json"), 200)
        self.hr_role.refresh_from_db()
        self.assertFalse(self.hr_role.can_view_payroll or self.hr_role.can_create_payroll)                                 # access=false clears the module
        for bad in ([{"role_code": "employee", "module": "ghost", "allowed": True}], [{"role_code": "nobody", "module": "payroll", "allowed": True}],
                    [{"role_code": "employee", "module": "payroll", "allowed": "yes"}], []):
            self.assertEqual(self.a.put("/api/admin-center/rbac/matrix/", {"changes": bad}, format="json").status_code, 400)
        self.assertEqual(AdminAuditEvent.objects.filter(company=self.co, action="PERMISSION_CHANGED").count(), 3)
        # role editor cannot remove his own roles access
        r = EmployeeRole.objects.create(company=self.co, role_name="RoleAdmin", role_code="ra", can_manage_roles=True)
        ra = self.mk_user("Role Admin", "ra@z.com", r)
        self.assertEqual(self.emp(ra).put("/api/admin-center/rbac/matrix/", {"changes": [{"role_code": "ra", "module": "roles", "allowed": False}]}, format="json").status_code, 409)

    def test_sessions_revocation_really_blocks_token(self):
        def token(e):
            rt = RefreshToken()
            rt["type"], rt["user_id"], rt["employee_id"], rt["company_id"] = "employee", e.employee_code, e.employee_code, self.co.company_id
            return str(rt.access_token)
        AuthLog.objects.create(actor_type="EMPLOYEE", identifier=self.rahul.email, actor_id=self.rahul.employee_code, company=self.co, action="LOGIN", status="SUCCESS",
                               ip_address="192.168.1.45", user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X) Safari/605 Chrome/128")
        AuthLog.objects.create(actor_type="COMPANY_ADMIN", identifier="admin", actor_id=str(self.co.company_id), company=self.co, action="LOGIN", status="SUCCESS", ip_address="10.0.0.1", user_agent="Edg/128 Windows")
        tok = token(self.rahul)
        c = APIClient()
        c.credentials(HTTP_AUTHORIZATION="Bearer " + tok)
        r0 = c.get("/employee/admin-center/my-access/")
        self.assertEqual(r0.status_code, 200, r0.content)
        rows = self.j(self.a.get("/api/admin-center/sessions/"), 200)["data"]
        self.assertEqual(len(rows), 2)
        s = [r for r in rows if r["actor_type"] == "EMPLOYEE"][0]
        self.assertEqual((s["device"], s["browser"], s["revocable"]), ("macOS", "Chrome", True))
        adm = [r for r in rows if r["actor_type"] == "COMPANY_ADMIN"][0]
        self.assertEqual(self.a.post(f"/api/admin-center/sessions/{adm['id']}/revoke/", {}, format="json").status_code, 409)
        import time as _t
        _t.sleep(1.1)
        self.j(self.a.delete(f"/api/admin-center/sessions/{s['id']}/"), 200)
        r = c.get("/employee/admin-center/my-access/")
        self.assertEqual(r.status_code, 401)                                                                              # token is dead
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/sessions/"))["data"]), 1)                              # session gone from list
        _t.sleep(1.1)
        c2 = APIClient()
        c2.credentials(HTTP_AUTHORIZATION="Bearer " + token(self.rahul))                                                  # new login works
        self.assertEqual(c2.get("/employee/admin-center/my-access/").status_code, 200)
        self.assertEqual(self.a.get(f"/api/admin-center/sessions/{s['id']}/").status_code, 404)
        h = self.j(self.a.get("/api/admin-center/sessions/history/?status=SUCCESS"), 200)
        self.assertEqual(len(h["data"]), 2)

    def test_revoke_others_and_own_sessions(self):
        AuthLog.objects.create(actor_type="EMPLOYEE", actor_id=self.rahul.employee_code, company=self.co, action="LOGIN", status="SUCCESS", ip_address="1.1.1.1")
        AuthLog.objects.create(actor_type="EMPLOYEE", actor_id=self.elena.employee_code, company=self.co, action="LOGIN", status="SUCCESS", ip_address="2.2.2.2")
        self.assertEqual(len(self.j(self.emp(self.rahul).get("/employee/admin-center/my-sessions/"))["data"]), 1)
        import time as _t
        _t.sleep(1.1)
        r = self.j(self.P("/api/admin-center/sessions/revoke-others/"), 200)["data"]
        self.assertEqual(sorted(r["revoked_users"]), sorted([self.rahul.employee_code, self.elena.employee_code]))
        self.assertEqual(self.j(self.a.get("/api/admin-center/sessions/"))["data"], [])
        self.j(self.emp(self.rahul).post("/employee/admin-center/my-sessions/revoke-others/", {}, format="json"), 200)

    # ---------------- security / health / backup / audit ----------------
    def test_security_center(self):
        s = self.j(self.a.get("/api/admin-center/security/"), 200)["data"]
        self.assertEqual((s["security_posture"], s["policy"]["lockout_attempts"], s["policy"]["ip_allowlist_enabled"]), (85, 5, False))
        s = self.j(self.a.put("/api/admin-center/security/", {"password_rotation_days": 60, "idle_timeout_enabled": False}, format="json"), 200)["data"]
        self.assertEqual((s["policy"]["password_rotation_days"], s["security_posture"]), (60, 65))
        for bad in ({"lockout_attempts": 0}, {"idle_timeout_minutes": 2}, {"mfa_required_admins": "yes"}, {"ip_allowlist": ["not-an-ip"]}, {"ip_allowlist_enabled": True, "ip_allowlist": ["203.0.113.9"]}):
            self.assertEqual(self.a.put("/api/admin-center/security/", bad, format="json").status_code, 400, bad)       # last one = would lock admin out
        self.j(self.a.put("/api/admin-center/security/", {"ip_allowlist_enabled": True, "ip_allowlist": ["127.0.0.1"]}, format="json"), 200)   # test client IP
        self.assertEqual(cli(self.co).get("/api/admin-center/security/", REMOTE_ADDR="8.8.8.8").status_code, 403)
        self.j(self.a.put("/api/admin-center/security/", {"ip_allowlist_enabled": False}, format="json"), 200)
        for i in range(3):
            AuthLog.objects.create(actor_type="EMPLOYEE", identifier="x@z.com", company=self.co, action="LOGIN", status="FAILED", ip_address="185.220.101.44")
        EmployeeAccount.objects.filter(employee=self.rahul).update(failed_login_attempts=5)
        t = self.j(self.a.get("/api/admin-center/security/"), 200)["data"]
        self.assertEqual(t["failed_logins_24h"], 3)
        self.assertTrue(any("Brute Force" in x["title"] for x in t["threat_detection_logs"]))
        scan = self.j(self.P("/api/admin-center/security/scan/"), 200)["data"]
        self.assertTrue(any("Idle session" in f["title"] for f in scan["findings"]))
        self.assertEqual(self.j(self.P("/api/admin-center/security/enforce-lockouts/"), 200)["data"]["locked"], 1)
        self.assertFalse(EmployeeAccount.objects.get(employee=self.rahul).is_login_enabled)
        self.assertEqual(self.j(self.a.get("/api/admin-center/security/"))["data"]["locked_accounts"], 1)

    def test_system_health(self):
        h = self.j(self.a.get("/api/admin-center/system-health/"), 200)["data"]
        names = {p["name"]: p["status"] for p in h["probes"]}
        self.assertEqual((names["Database"], names["REST API"], names["File Storage"]), ("Operational", "Operational", "Operational"))
        self.assertIn("storage_used_percent", h["resources"])
        self.assertGreaterEqual(h["application_uptime_seconds"], 0)

    def test_backup_policies_and_snapshots(self):
        p = self.j(self.P("/api/admin-center/backup/policies/", {"target": "Full Database Snapshot", "frequency": "Daily at 02:00 AM", "retention_days": 30, "storage_location": "AWS S3"}), 201)["data"]
        self.assertEqual((p["retention_period"], p["snapshot_size"]), ("30 Days", None))
        self.assertEqual(self.P("/api/admin-center/backup/policies/", {"target": "full database snapshot", "frequency": "x"}).status_code, 400)
        self.assertEqual(self.P("/api/admin-center/backup/policies/", {"target": "T", "frequency": "x", "retention_days": 0}).status_code, 400)
        s = self.j(self.P(f"/api/admin-center/backup/policies/{p['id']}/trigger/"), 201)["data"]
        self.assertEqual((s["status"], len(s["checksum_sha256"])), ("Completed", 64))
        self.assertIsNotNone(self.j(self.a.get(f"/api/admin-center/backup/policies/{p['id']}/"))["data"]["snapshot_size"])
        s2 = self.j(self.P("/api/admin-center/backup/trigger/"), 201)["data"]
        dl = self.a.get(f"/api/admin-center/backup/snapshots/{s2['id']}/download/")
        self.assertEqual(dl.status_code, 200)
        data = json.loads(b"".join(dl.streaming_content))
        self.assertIn("users", data)
        self.assertNotIn("secret1", json.dumps(data))                                                                      # no passwords in backups
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/backup/snapshots/"))["data"]), 2)
        path = os.path.join(TMP, "admin_center_backups")
        self.assertTrue(os.path.isdir(path))
        self.j(self.a.delete(f"/api/admin-center/backup/snapshots/{s2['id']}/"), 200)
        self.assertEqual(self.a.get(f"/api/admin-center/backup/snapshots/{s2['id']}/download/").status_code, 404)
        self.assertEqual(self.a.get(f"/api/admin-center/backup/snapshots/{s['id']}/download/").status_code, 200)
        self.assertEqual(cli(self.other).get(f"/api/admin-center/backup/snapshots/{s['id']}/download/").status_code, 404)  # B2B
        self.assertEqual(self.a.get("/api/admin-center/backup/export/").status_code, 200)
        self.j(self.a.patch(f"/api/admin-center/backup/policies/{p['id']}/", {"status": "Paused", "retention_days": 90}, format="json"), 200)
        self.j(self.a.delete(f"/api/admin-center/backup/policies/{p['id']}/"), 200)

    def test_audit_trail_is_immutable_and_complete(self):
        self.P("/api/admin-center/master-data/", {"category": "C", "value": "V", "code": "V1"})
        m = self.j(self.P("/api/admin-center/master-data/", {"category": "C", "value": "W", "code": "W1"}), 201)["data"]
        self.a.patch(f"/api/admin-center/master-data/{m['id']}/", {"value": "W2"}, format="json")
        self.a.delete(f"/api/admin-center/master-data/{m['id']}/")
        ev = self.j(self.a.get("/api/admin-center/audit/?module=Master Data"), 200)["data"]
        self.assertEqual([e["action"] for e in ev], ["DELETED", "UPDATED", "CREATED", "CREATED"])
        upd = [e for e in ev if e["action"] == "UPDATED"][0]
        self.assertIn("W2", upd["new_value"])
        self.assertIn('"W"', upd["old_value"])
        one = self.j(self.a.get(f"/api/admin-center/audit/{ev[0]['id']}/"), 200)["data"]
        self.assertEqual(one["user_actor"], self.co.Registered_Company_Name)
        self.assertEqual(self.a.put(f"/api/admin-center/audit/{ev[0]['id']}/", {}, format="json").status_code, 405)
        self.assertEqual(self.a.patch(f"/api/admin-center/audit/{ev[0]['id']}/", {}, format="json").status_code, 405)
        self.assertEqual(self.a.delete(f"/api/admin-center/audit/{ev[0]['id']}/").status_code, 405)
        self.assertEqual(self.P(f"/api/admin-center/audit/{ev[0]['id']}/delete/").status_code, 405)
        self.assertEqual(self.P(f"/api/admin-center/audit/{ev[0]['id']}/update/").status_code, 405)
        c = self.j(self.P("/api/admin-center/audit/", {"action": "verified", "module": "Document Collection", "record_ref": "CAN-301", "old_value": "Under Verification", "new_value": "Verified"}), 201)["data"]
        self.assertEqual(c["action"], "VERIFIED")
        self.assertEqual(self.P("/api/admin-center/audit/", {"module": "x"}).status_code, 400)
        self.assertEqual(len(self.j(self.a.get("/api/admin-center/audit/?search=CAN-301"))["data"]), 1)
        self.assertEqual(self.a.get("/api/admin-center/audit/?date_from=bad").status_code, 400)
        csv = self.a.get("/api/admin-center/audit/export/?module=Document Collection")
        self.assertIn(b"CAN-301", csv.content)
        self.assertEqual(self.j(cli(self.other).get("/api/admin-center/audit/"))["data"], [])

    def test_summary(self):
        self.P("/api/admin-center/legal-entities/", {"name": "A", "code": "A"})
        s = self.j(self.a.get("/api/admin-center/summary/"), 200)["data"]
        self.assertEqual((s["total_users"], s["operating_companies"], len(s["system_activity_last_7_days"])), (3, 1, 7))
        self.assertGreaterEqual(s["audit_events"], 1)
        self.assertEqual(s["live_system_checks"]["overall"], "All Operational")

    # ---------------- permissions + employee side ----------------
    def test_permissions_and_isolation(self):
        r = self.emp(self.rahul)
        for url in ("/api/admin-center/users/", "/api/admin-center/security/", "/api/admin-center/audit/", "/api/admin-center/jobs/", "/api/admin-center/backup/snapshots/"):
            self.assertEqual(r.get(url).status_code, 403, url)                                                              # plain employee
        hr = self.emp(self.elena)                                                                                           # can_view_employees only
        self.assertEqual(hr.get("/api/admin-center/users/").status_code, 403)                                               # user list is sensitive
        self.assertEqual(hr.get("/api/admin-center/org-units/").status_code, 200)
        self.assertEqual(hr.get("/api/admin-center/workflows/").status_code, 200)
        self.assertEqual(hr.get("/api/admin-center/security/").status_code, 403)                                            # sensitive
        self.assertEqual(hr.get("/api/admin-center/integrations/").status_code, 403)
        self.assertEqual(hr.post("/api/admin-center/users/", {"name": "n", "email": "n@z.com", "password": "pass1234"}, format="json").status_code, 403)
        self.assertEqual(hr.post("/api/admin-center/master-data/", {"category": "a", "value": "b", "code": "c"}, format="json").status_code, 403)
        EmployeeRole.objects.filter(pk=self.hr_role.pk).update(can_manage_company=True)
        self.assertEqual(self.emp(self.elena).get("/api/admin-center/security/").status_code, 200)
        self.assertEqual(self.emp(self.elena).post("/api/admin-center/master-data/", {"category": "a", "value": "b", "code": "c"}, format="json").status_code, 201)
        self.assertEqual(APIClient().get("/api/admin-center/users/").status_code, 401)
        self.assertEqual(APIClient().get("/employee/admin-center/my-access/").status_code, 401)
        self.assertEqual(self.a.get("/employee/admin-center/my-access/").status_code, 403)                                 # company token on employee API

    def test_employee_side(self):
        self.P("/api/admin-center/master-data/", {"category": "Leave Type", "value": "Casual Leave", "code": "CL"})
        self.P("/api/admin-center/master-data/", {"category": "Leave Type", "value": "Old", "code": "OLD", "status": "Inactive"})
        self.P("/api/admin-center/org-units/", {"unit_type": "Division", "name": "Platform", "head_employee_code": self.elena.employee_code})
        self.P("/api/admin-center/workflows/", {"name": "Leave Chain", "module": "Leave", "trigger_event": "On Submit", "steps": ["Reporting Manager", "HR Admin"]})
        self.P("/api/admin-center/workflows/", {"name": "Draft Chain", "module": "Exit", "trigger_event": "x", "status": "Draft", "steps": ["HOD"]})
        self.P("/api/admin-center/legal-entities/", {"name": "Zenith", "code": "Z", "currency": "INR", "tax_id": "SECRET-TAX"})
        self.P("/api/admin-center/security/", {"ip_allowlist_enabled": False})
        me = self.emp(self.rahul)
        acc = self.j(me.get("/employee/admin-center/my-access/"), 200)["data"]
        self.assertEqual(acc["role"]["role_code"], "employee")
        self.assertFalse({"company", "roles"} & {m["module"] for m in acc["modules"]})
        self.assertEqual([m["value"] for m in self.j(me.get("/employee/admin-center/master-data/?category=leave type"))["data"]], ["Casual Leave"])
        self.assertEqual([u["name"] for u in self.j(me.get("/employee/admin-center/org-units/?unit_type=Division"))["data"]], ["Platform"])
        wf = self.j(me.get("/employee/admin-center/workflows/"))["data"]
        self.assertEqual([(w["name"], w["approver_chain"]) for w in wf], [("Leave Chain", "Reporting Manager → HR Admin")])
        comp = self.j(me.get("/employee/admin-center/companies/"))["data"]
        self.assertNotIn("SECRET-TAX", json.dumps(comp))
        pol = self.j(me.get("/employee/admin-center/security-policy/"))["data"]
        self.assertNotIn("ip_allowlist", pol)
        self.assertEqual(pol["lockout_after_failed_attempts"], 5)
        self.assertEqual(me.post("/employee/admin-center/master-data/", {}, format="json").status_code, 405)               # read-only
        self.assertEqual(me.delete("/employee/admin-center/workflows/").status_code, 405)
        act = self.j(me.get("/employee/admin-center/my-activity/"), 200)["data"]
        self.assertEqual(set(act), {"logins", "actions"})
        self.assertEqual(self.j(cli(self.other).get("/api/admin-center/master-data/"))["data"], [])

    def test_employee_revoke_others_keeps_current_token(self):
        import time as _t

        def tok(e):
            rt = RefreshToken()
            rt["type"], rt["user_id"], rt["employee_id"], rt["company_id"] = "employee", e.employee_code, e.employee_code, self.co.company_id
            return str(rt.access_token)
        old = tok(self.rahul)
        _t.sleep(1.1)
        cur = tok(self.rahul)
        co, cn = APIClient(), APIClient()
        co.credentials(HTTP_AUTHORIZATION="Bearer " + old)
        cn.credentials(HTTP_AUTHORIZATION="Bearer " + cur)
        self.assertEqual(cn.post("/employee/admin-center/my-sessions/revoke-others/", {}, format="json").status_code, 200)
        self.assertEqual(co.get("/employee/admin-center/my-access/").status_code, 401)         # other device signed out
        self.assertEqual(cn.get("/employee/admin-center/my-access/").status_code, 200)         # this device still in
