# Organization Hierarchy / Org Chart tests:  python manage.py test People.tests_org_chart
from datetime import date

from rest_framework.test import APITestCase

from Company.models import company_details
from Employee.models import Department, EmployeeAccount, EmployeeDT, EmployeeRole
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People.models import EmployeeExtra, HistoryEvent, OrgChartSettings

O = "/api/people/org"


class OrgBase(APITestCase):
    def mk_company(self, n):
        return company_details.objects.create(email=f"oc{n}@x.com", password="pw", contact_no=f"95000000{n:02d}",
                                              status=True, is_verified=True, Registered_Company_Name=f"Org Co {n}",
                                              Company_address="Pune")

    def mk(self, co, code, name, desig, dept=None, mgr=None, role=None, active=True, email=None, doj=date(2024, 1, 1)):
        e = EmployeeDT.objects.create(company=co, employee_code=code, name=name, email=email or f"{code.lower()}@x.com",
                                      Designation=desig, department=dept, Date_of_Joining=doj, is_active=active)
        EmployeeAccount.objects.create(employee=e, role=role)
        EmployeeExtra.objects.create(company=co, employee=e, reporting_manager=mgr, lifecycle_status="Confirmed")
        return e

    def setUp(self):
        self.co, self.other = self.mk_company(1), self.mk_company(2)
        eng = Department.objects.create(company=self.co, name="Engineering", code="ENG")
        hrd = Department.objects.create(company=self.co, name="Human Resources", code="HR")
        fin = Department.objects.create(company=self.co, name="Finance", code="FIN")
        self.eng, self.hrd, self.fin = eng, hrd, fin
        hr_role = EmployeeRole.objects.create(company=self.co, role_name="HR", role_code="hr", can_view_employees=True,
                                              can_edit_employees=True, can_create_employees=False)
        ro_role = EmployeeRole.objects.create(company=self.co, role_name="RO", role_code="ro", can_view_employees=True)
        mg_role = EmployeeRole.objects.create(company=self.co, role_name="MG", role_code="mg", can_view_employees=True,
                                              can_edit_employees=True, can_manage_employees=True)
        m = self.mk
        self.ceo = m(self.co, "EMP001", "Jagadish Patil", "CEO / Founder", None)
        self.cto = m(self.co, "EMP002", "Rohan Mehta", "CTO", eng, self.ceo)
        self.chro = m(self.co, "EMP003", "Priya Nair", "CHRO", hrd, self.ceo, role=hr_role)
        self.cfo = m(self.co, "EMP004", "Amit Kulkarni", "CFO", fin, self.ceo)
        self.em = m(self.co, "EMP005", "Siddharth Iyer", "Engineering Manager", eng, self.cto)
        self.fl = m(self.co, "EMP006", "Amit Verma", "Frontend Team Lead", eng, self.em)
        self.bl = m(self.co, "EMP007", "Rohit Singh", "Backend Team Lead", eng, self.em)
        self.devs = [m(self.co, f"DEV0{i}", f"Dev {i}", "Developer", eng, self.fl) for i in range(1, 5)]
        self.bdevs = [m(self.co, f"BDV0{i}", f"Backend Dev {i}", "Backend Developer", eng, self.bl) for i in range(1, 3)]
        self.hrx = m(self.co, "EMP020", "Hina Exec", "HR Executive", hrd, self.chro, role=ro_role)
        self.mgr_u = m(self.co, "EMP021", "Mona Manage", "HR Admin", hrd, self.chro, role=mg_role)
        self.total = 1 + 3 + 1 + 2 + 4 + 2 + 1 + 1           # 15
        self.other_emp = m(self.other, "OT001", "Other CEO", "CEO", None)
        self.other_dev = m(self.other, "OT002", "Other Dev", "Developer", None, self.other_emp)
        self.admin = client_for(company_token(self.co))
        self.admin2 = client_for(company_token(self.other))
        self.hr = client_for(employee_token(self.chro))
        self.ro = client_for(employee_token(self.hrx))
        self.mg = client_for(employee_token(self.mgr_u))

    def chart(self, qs="", client=None):
        return (client or self.admin).get(f"{O}/chart/{qs}").json()

    def post_mgr(self, code, body, client=None):
        return (client or self.admin).post(f"{O}/employees/{code}/reporting-manager/", body, format="json")


def walk(node, out=None):
    out = [] if out is None else out
    if node is None:
        return out
    out.append(node)
    for c in node.get("children", []):
        walk(c, out)
    return out


class Overview(OrgBase):
    def test_stats_and_departments(self):
        d = self.admin.get(f"{O}/hierarchy/").json()["data"]
        s = d["stats"]
        self.assertEqual((s["total_employees"], s["departments"]), (self.total, 3))
        self.assertEqual((s["team_leads"], s["leaders"], s["managers"]), (2, 6, 4))
        deps = {r["name"]: r for r in d["departments"]}
        self.assertEqual(deps["Engineering"]["employees"], 10)
        self.assertEqual(deps["Finance"]["employees"], 1)
        self.assertTrue(all(r["color"] for r in d["departments"]))
        self.assertEqual(d["chart_card"]["chart_api"], "/api/people/org/chart/")

    def test_search_departments_and_employees(self):
        d = self.admin.get(f"{O}/hierarchy/?q=amit").json()["data"]
        self.assertEqual(sorted(e["employee_code"] for e in d["search"]["employees"]), ["EMP004", "EMP006"])
        self.assertEqual(self.admin.get(f"{O}/hierarchy/?q=fin").json()["data"]["departments"][0]["name"], "Finance")

    def test_key_actions_follow_permissions(self):
        a = {x["key"]: x["allowed"] for x in self.hr.get(f"{O}/hierarchy/").json()["data"]["key_actions"]}
        self.assertEqual((a["add_employee"], a["edit_reporting_manager"], a["settings"]), (False, True, False))
        a = {x["key"]: x["allowed"] for x in self.admin.get(f"{O}/hierarchy/").json()["data"]["key_actions"]}
        self.assertTrue(all(a.values()))


class Chart(OrgBase):
    def test_tree_shape_matches_the_design(self):
        r = self.chart("?expand=all")
        root = r["data"]["root"]
        self.assertEqual((root["employee_code"], root["is_root"], root["badge"]), ("EMP001", True, "Root Node"))
        self.assertEqual(root["team_size"], self.total - 1)                       # everyone below the root (other company excluded)
        kinds = [c["type"] for c in root["children"]]
        self.assertEqual(kinds[0], "leadership")
        lead = root["children"][0]
        self.assertEqual((lead["label"], lead["count"]), ("Leadership Team", 2))
        self.assertEqual(sorted(c["employee_code"] for c in lead["children"]), ["EMP002", "EMP003"])
        self.assertIn("EMP004", [c.get("employee_code") for c in root["children"]])     # CFO has no team: sits beside it
        cto = next(c for c in lead["children"] if c["employee_code"] == "EMP002")
        self.assertEqual((cto["direct_reports"], cto["team_size"], cto["role_type"]), (1, 9, "manager"))
        fl = next(n for n in walk(root) if n.get("employee_code") == "EMP006")
        self.assertEqual(fl["role_type"], "lead")
        grp = fl["children"][0]
        self.assertEqual((grp["type"], grp["count"], grp["display_label"]), ("group", 4, "Developers (4)"))
        self.assertEqual(len(grp["preview"]), 4)
        bl = next(n for n in walk(root) if n.get("employee_code") == "EMP007")
        self.assertEqual([c["type"] for c in bl["children"]], ["employee", "employee"])    # only 2 -> not grouped
        self.assertEqual(r["meta"]["primary_root"], "EMP001")

    def test_every_employee_appears_exactly_once(self):
        root = self.chart("?expand=all&group=false")["data"]["root"]
        codes = [n["employee_code"] for n in walk(root) if n["type"] == "employee"]
        self.assertEqual(len(codes), self.total)
        self.assertEqual(len(codes), len(set(codes)))
        self.assertNotIn("OT001", codes)                                                    # B2B
        grouped = self.chart("?expand=all")["data"]["root"]
        n_emp = sum(1 for n in walk(grouped) if n["type"] == "employee")
        n_grp = sum(n["count"] for n in walk(grouped) if n["type"] == "group")
        self.assertEqual(n_emp + n_grp, self.total)

    def test_expand_and_depth(self):
        none = self.chart("?expand=none")["data"]["root"]
        self.assertFalse(any(n["expanded"] for n in walk(none) if n["type"] == "employee"))
        allx = self.chart("?expand=all")["data"]["root"]
        self.assertTrue(all(n["expanded"] for n in walk(allx) if n["type"] == "employee" and n["has_children"]))
        d1 = self.chart("?depth=1")["data"]["root"]
        leaders = d1["children"][0]["children"]
        self.assertTrue(all(c["children_loaded"] is False and c["has_children"] for c in leaders if c["employee_code"] == "EMP002"))
        sub = self.chart("?root=EMP005&expand=all")
        self.assertEqual(sub["data"]["root"]["employee_code"], "EMP005")
        self.assertTrue(sub["data"]["root"]["is_subtree_root"] and not sub["data"]["root"]["is_root"])
        self.assertEqual([b["employee_code"] for b in sub["data"]["breadcrumb"]], ["EMP001", "EMP002"])
        self.assertEqual(sub["data"]["other_roots"], [])

    def test_department_filter_keeps_the_path_to_the_top(self):
        r = self.chart(f"?department={self.eng.id}&expand=all")
        codes = {n["employee_code"]: n for n in walk(r["data"]["root"]) if n["type"] == "employee"}
        self.assertIn("EMP001", codes)                                                       # ancestor kept, not in filter
        self.assertFalse(codes["EMP001"]["in_filter"])
        self.assertTrue(codes["EMP002"]["in_filter"])
        self.assertNotIn("EMP003", codes)                                                    # HR branch pruned
        self.assertNotIn("EMP004", codes)
        self.assertEqual(r["meta"]["matches"], 10)
        by_name = self.chart("?department=finance")["data"]["root"]
        self.assertEqual(sorted(n["employee_code"] for n in walk(by_name) if n["type"] == "employee"), ["EMP001", "EMP004"])

    def test_search_shows_people_individually_with_ancestors(self):
        r = self.chart("?q=amit")
        nodes = [n for n in walk(r["data"]["root"]) if n["type"] == "employee"]
        self.assertEqual(sorted(n["employee_code"] for n in nodes if n["matched"]), ["EMP004", "EMP006"])
        self.assertEqual(r["meta"]["matches"], 2)
        self.assertEqual(self.chart("?q=zzzz-nobody")["data"]["root"], None)
        self.assertIn("No employee matches", self.chart("?q=zzzz-nobody")["message"])
        dev = self.chart("?q=Dev 3")["data"]["root"]
        self.assertTrue(any(n.get("employee_code") == "DEV03" and n["matched"] for n in walk(dev)))   # grouped devs are un-grouped on search

    def test_bad_params(self):
        for qs, code in (("?depth=x", 400), ("?expand=abc", 400), ("?department=999999", 404), ("?root=NOPE", 404),
                         ("?root=OT001", 404)):
            self.assertEqual(self.admin.get(f"{O}/chart/{qs}").status_code, code, qs)

    def test_other_roots_and_health_for_multiple_tops(self):
        self.mk(self.co, "EMP900", "Second Top", "Director")
        r = self.chart()
        self.assertEqual(len(r["data"]["other_roots"]), 1)
        self.assertTrue(r["data"]["other_roots"][0]["orphan_root"])
        self.assertEqual(r["meta"]["primary_root"], "EMP001")
        h = self.admin.get(f"{O}/chart/health/").json()["data"]
        self.assertIn("MULTIPLE_ROOTS", [i["type"] for i in h["issues"]])

    def test_corrupt_loop_never_duplicates_or_crashes(self):
        EmployeeExtra.objects.filter(employee=self.cto).update(reporting_manager=self.fl)     # CTO -> ... -> Frontend Lead -> CTO
        r = self.chart("?expand=all&group=false")
        codes = [n["employee_code"] for n in walk(r["data"]["root"]) if n["type"] == "employee"]
        for t in r["data"]["other_roots"]:
            codes += [n["employee_code"] for n in walk(t) if n["type"] == "employee"]
        self.assertEqual(len(codes), len(set(codes)))
        self.assertEqual(len(codes), self.total)
        h = self.admin.get(f"{O}/chart/health/").json()["data"]
        self.assertFalse(h["healthy"])
        self.assertIn("CIRCULAR_REPORTING", [i["type"] for i in h["issues"]])

    def test_inactive_manager_is_reported_not_hidden(self):
        EmployeeDT.objects.filter(pk=self.em.pk).update(is_active=False)
        h = self.admin.get(f"{O}/chart/health/").json()["data"]
        bad = next(i for i in h["issues"] if i["type"] == "INACTIVE_MANAGER")
        self.assertEqual(sorted(e["employee_code"] for e in bad["employees"]), ["EMP006", "EMP007"])
        r = self.chart("?expand=all&group=false")
        total = sum(1 for n in walk(r["data"]["root"]) if n["type"] == "employee") + sum(
            sum(1 for n in walk(t) if n["type"] == "employee") for t in r["data"]["other_roots"])
        self.assertEqual(total, self.total - 1)

    def test_health_flags_duplicate_employee_codes(self):
        self.mk(self.co, "emp005", "Clone", "Dev", self.eng, self.fl, email="clone@x.com")       # same code, different case
        h = self.admin.get(f"{O}/chart/health/").json()["data"]
        types = {i["type"]: i for i in h["issues"]}
        self.assertEqual(types["DUPLICATE_EMPLOYEE_CODE"]["values"], ["emp005"])
        self.assertFalse(h["healthy"])


class CardTeamDepartment(OrgBase):
    def test_employee_card(self):
        c = self.admin.get(f"{O}/employees/EMP006/card/").json()["data"]
        self.assertEqual((c["name"], c["designation"], c["department"], c["status"]),
                         ("Amit Verma", "Frontend Team Lead", "Engineering", "Active"))
        self.assertEqual(c["reporting_manager"]["name"], "Siddharth Iyer")
        self.assertEqual((c["direct_reports"], c["team_size"]), (4, 4))
        self.assertEqual([x["employee_code"] for x in c["management_chain"]], ["EMP001", "EMP002", "EMP005"])
        self.assertEqual(c["actions"]["view_team"]["api"], "/api/people/org/employees/EMP006/team/")
        self.assertTrue(c["actions"]["edit_reporting_manager"]["allowed"])
        self.assertEqual(self.admin.get(f"{O}/employees/NOPE/card/").status_code, 404)

    def test_team_direct_all_and_search(self):
        d = self.admin.get(f"{O}/employees/EMP005/team/").json()
        self.assertEqual(sorted(r["employee_code"] for r in d["data"]), ["EMP006", "EMP007"])
        self.assertEqual(d["manager"]["team_size"], 8)
        self.assertEqual(d["scope"], "direct")
        allx = self.admin.get(f"{O}/employees/EMP005/team/?all=true").json()
        self.assertEqual(len(allx["data"]), 8)
        self.assertEqual(len(self.admin.get(f"{O}/employees/EMP005/team/?all=true&q=backend").json()["data"]), 3)
        self.assertEqual(self.admin.get(f"{O}/employees/DEV01/team/").json()["data"], [])

    def test_department_view(self):
        d = self.admin.get(f"{O}/departments/{self.eng.id}/team-view/").json()
        self.assertEqual(d["department"]["employees"], 10)
        self.assertEqual([r["employee_code"] for r in d["data"]][:2], ["EMP002", "EMP005"])     # biggest teams first
        self.assertTrue(all(r["direct_reports"] > 0 for r in d["data"]))
        self.assertEqual(d["scope"], "leaders")
        every = self.admin.get(f"{O}/departments/{self.eng.id}/team-view/?all=true").json()
        self.assertEqual(len(every["data"]), 10)
        self.assertEqual(self.admin2.get(f"{O}/departments/{self.eng.id}/team-view/").status_code, 404)       # B2B

    def test_manager_options_exclude_self_and_own_team(self):
        d = self.admin.get(f"{O}/employees/EMP005/reporting-manager/options/").json()
        codes = {r["employee_code"] for r in d["data"]}
        self.assertNotIn("EMP005", codes)
        self.assertFalse(codes & {"EMP006", "EMP007", "DEV01", "BDV01"})
        self.assertIn("EMP002", codes)
        self.assertTrue(next(r for r in d["data"] if r["employee_code"] == "EMP002")["is_current"])
        self.assertNotIn("OT001", codes)
        self.assertEqual([r["employee_code"] for r in self.admin.get(f"{O}/employees/EMP005/reporting-manager/options/?q=priya").json()["data"]],
                         ["EMP003"])


class EditReportingManager(OrgBase):
    def test_change_updates_chart_logs_history(self):
        r = self.post_mgr("EMP007", {"manager": "EMP002", "reason": "Backend now reports to CTO"})
        self.assertEqual(r.status_code, 200, r.content)
        d = r.json()["data"]
        self.assertEqual((d["changed"]["from"]["employee_code"], d["changed"]["to"]["employee_code"]), ("EMP005", "EMP002"))
        self.assertEqual(d["card"]["reporting_manager"]["employee_code"], "EMP002")
        self.assertEqual(EmployeeExtra.objects.get(employee=self.bl).reporting_manager_id, self.cto.id)
        ev = HistoryEvent.objects.get(employee=self.bl, event_type="MANAGER_CHANGE")
        self.assertEqual((ev.meta["from"], ev.meta["to"], ev.description), ("EMP005", "EMP002", "Backend now reports to CTO"))
        fl = self.admin.get(f"{O}/employees/EMP005/card/").json()["data"]
        self.assertEqual(fl["direct_reports"], 1)

    def test_duplicate_assignment_is_rejected_and_not_logged(self):
        r = self.post_mgr("EMP007", {"manager": "EMP005"})
        self.assertEqual(r.status_code, 409)
        self.assertEqual(r.json()["code"], "DUPLICATE")
        self.assertFalse(HistoryEvent.objects.filter(event_type="MANAGER_CHANGE").exists())
        self.assertEqual(self.post_mgr("EMP001", {"manager": None}).status_code, 409)      # root already has none
        self.post_mgr("EMP007", {"manager": "EMP002"})
        self.assertEqual(self.post_mgr("EMP007", {"manager": "EMP002"}).status_code, 409)
        self.assertEqual(HistoryEvent.objects.filter(event_type="MANAGER_CHANGE").count(), 1)

    def test_loops_and_self_are_blocked(self):
        r = self.post_mgr("EMP001", {"manager": "DEV01"})
        self.assertEqual(r.status_code, 400)
        self.assertIn("circular reporting line", r.json()["message"])
        self.assertEqual(self.post_mgr("EMP002", {"manager": "EMP006"}).status_code, 400)  # CTO under own grand-report
        self.assertIn("themselves", self.post_mgr("EMP002", {"manager": "EMP002"}).json()["message"])
        self.assertIsNone(EmployeeExtra.objects.get(employee=self.ceo).reporting_manager_id)

    def test_validation(self):
        self.assertEqual(self.post_mgr("EMP007", {}).status_code, 400)
        self.assertEqual(self.post_mgr("EMP007", {"manager": ""}).status_code, 400)
        self.assertEqual(self.post_mgr("EMP007", {"manager": "NOPE"}).status_code, 400)
        self.assertEqual(self.post_mgr("EMP007", {"manager": "EMP002", "reason": "x" * 251}).status_code, 400)
        self.assertEqual(self.post_mgr("NOPE", {"manager": "EMP002"}).status_code, 404)
        EmployeeDT.objects.filter(pk=self.cfo.pk).update(is_active=False)
        self.assertEqual(self.post_mgr("EMP007", {"manager": "EMP004"}).status_code, 400)  # inactive manager
        self.assertEqual(self.post_mgr("EMP004", {"manager": "EMP002"}).status_code, 400)  # inactive employee
        self.assertEqual(self.post_mgr("EMP007", {"reporting_manager": "EMP002"}).status_code, 200)   # alias key

    def test_remove_manager_makes_a_new_top_node(self):
        self.assertEqual(self.post_mgr("EMP004", {"manager": None}).status_code, 200)
        self.assertEqual(len(self.chart()["data"]["other_roots"]), 1)

    def test_depth_limit(self):
        self.admin.post(f"{O}/chart/settings/", {"max_depth": 4}, format="json")
        r = self.post_mgr("EMP004", {"manager": "DEV01"})                  # CFO under a developer: chain would be 6 deep
        self.assertEqual(r.status_code, 400)
        self.assertIn("levels deep", r.json()["message"])

    def test_directory_edit_also_blocks_loops(self):
        r = self.admin.patch("/api/people/directory/EMP001/", {"reporting_manager": "DEV01"}, format="json")
        self.assertEqual(r.status_code, 400, r.content)
        ok = self.admin.patch("/api/people/directory/EMP007/", {"reporting_manager": "EMP002"}, format="json")
        self.assertEqual(ok.status_code, 200, ok.content)

    def test_permissions(self):
        self.assertEqual(self.post_mgr("EMP007", {"manager": "EMP002"}, self.hr).status_code, 200)        # edit right
        self.assertEqual(self.post_mgr("EMP006", {"manager": "EMP002"}, self.ro).status_code, 403)         # view only
        self.assertEqual(self.ro.get(f"{O}/chart/").status_code, 200)
        self.assertEqual(self.ro.get(f"{O}/hierarchy/").status_code, 200)
        self.assertEqual(self.client.get(f"{O}/chart/").status_code, 401)


class ExportAndSettings(OrgBase):
    def test_csv_export(self):
        r = self.admin.get(f"{O}/chart/export/?fmt=csv")
        self.assertEqual(r.status_code, 200)
        self.assertIn("text/csv", r["Content-Type"])
        self.assertIn("org-chart-org-co-1-", r["Content-Disposition"])
        rows = r.content.decode("utf-8-sig").strip().splitlines()
        self.assertEqual(rows[0].split(",")[:3], ["Level", "Employee Code", "Name"])
        self.assertEqual(len(rows) - 1, self.total)
        self.assertTrue(rows[1].split(",")[1] == "EMP001")                       # manager before reports
        self.assertNotIn("OT001", r.content.decode())

    def test_csv_filter_and_formula_guard(self):
        EmployeeDT.objects.filter(pk=self.cfo.pk).update(Designation="=HYPERLINK(\"x\")")
        r = self.admin.get(f"{O}/chart/export/?department={self.fin.id}")
        body = r.content.decode("utf-8-sig")
        self.assertEqual(len(body.strip().splitlines()) - 1, 2)                 # CFO + the CEO above (path kept)
        self.assertIn("'=HYPERLINK", body)

    def test_xlsx_export(self):
        r = self.admin.get(f"{O}/chart/export/?fmt=xlsx")
        self.assertEqual(r.status_code, 200)
        import io
        from openpyxl import load_workbook
        ws = load_workbook(io.BytesIO(r.content)).active
        self.assertEqual(ws.max_row - 1, self.total)
        self.assertEqual(ws["B2"].value, "EMP001")
        self.assertEqual(self.admin.get(f"{O}/chart/export/?fmt=pdf").status_code, 400)
        self.assertEqual(self.admin.get(f"{O}/chart/export/?department=999").status_code, 404)

    def test_settings_default_update_and_effect(self):
        d = self.admin.get(f"{O}/chart/settings/").json()["data"]
        self.assertEqual((d["lead_keywords"], d["group_min_size"], d["leadership_label"]), (["lead"], 3, "Leadership Team"))
        r = self.admin.post(f"{O}/chart/settings/", {"lead_keywords": "lead, Manager, LEAD", "group_min_size": 5,
                                                     "leadership_label": "Top Team"}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(r.json()["data"]["lead_keywords"], ["lead", "Manager"])           # duplicate dropped
        s = self.admin.get(f"{O}/hierarchy/").json()["data"]["stats"]
        self.assertEqual((s["team_leads"], s["managers"]), (3, 3))                          # "Manager" now counts as lead
        root = self.chart("?expand=all")["data"]["root"]
        self.assertEqual(root["children"][0]["label"], "Top Team")
        fl = next(n for n in walk(root) if n.get("employee_code") == "EMP006")
        self.assertEqual([c["type"] for c in fl["children"]], ["employee"] * 4)             # 4 < min size 5 -> not grouped

    def test_group_leaders_off_and_root_override(self):
        self.admin.post(f"{O}/chart/settings/", {"group_leaders": False}, format="json")
        root = self.chart()["data"]["root"]
        self.assertNotIn("leadership", [c["type"] for c in root["children"]])
        bad = self.admin.post(f"{O}/chart/settings/", {"root_employee": "EMP002"}, format="json")
        self.assertEqual(bad.status_code, 400)                                              # CTO reports to CEO
        self.assertEqual(self.admin.post(f"{O}/chart/settings/", {"root_employee": "EMP001"}, format="json").status_code, 200)
        self.mk(self.co, "EMP901", "Big Second Top", "Director")
        self.assertEqual(self.chart()["meta"]["primary_root"], "EMP001")

    def test_department_style_and_validation(self):
        r = self.admin.post(f"{O}/chart/settings/", {"department_styles": {str(self.eng.id): {"icon": "code", "color": "#2563eb"}}}, format="json")
        self.assertEqual(r.status_code, 200)
        eng = next(x for x in self.admin.get(f"{O}/hierarchy/").json()["data"]["departments"] if x["name"] == "Engineering")
        self.assertEqual((eng["icon"], eng["color"]), ("code", "#2563eb"))
        for body in ({"lead_keywords": ["x" * 31]}, {"lead_keywords": [str(i) for i in range(11)]}, {"lead_keywords": 5},
                     {"group_min_size": 1}, {"group_min_size": "a"}, {"max_depth": 2}, {"leadership_label": ""},
                     {"root_employee": "NOPE"}, {"root_employee": "OT001"}, {"department_styles": []},
                     {"department_styles": {"99999": {"icon": "a"}}}, {"department_styles": {str(self.eng.id): "x"}}):
            self.assertEqual(self.admin.post(f"{O}/chart/settings/", body, format="json").status_code, 400, body)

    def test_only_manage_right_can_change_settings(self):
        self.assertEqual(self.hr.get(f"{O}/chart/settings/").status_code, 200)
        self.assertEqual(self.hr.post(f"{O}/chart/settings/", {"group_min_size": 4}, format="json").status_code, 403)
        self.assertEqual(self.mg.post(f"{O}/chart/settings/", {"group_min_size": 4}, format="json").status_code, 200)


class B2BIsolation(OrgBase):
    def test_companies_never_see_each_other(self):
        r2 = self.admin2.get(f"{O}/chart/").json()
        codes = [n["employee_code"] for n in walk(r2["data"]["root"]) if n["type"] == "employee"]
        self.assertEqual(sorted(codes), ["OT001", "OT002"])
        self.assertEqual(self.admin2.get(f"{O}/hierarchy/").json()["data"]["stats"]["total_employees"], 2)
        self.assertEqual(self.admin2.get(f"{O}/employees/EMP002/card/").status_code, 404)
        self.assertEqual(self.admin2.get(f"{O}/employees/EMP005/team/").status_code, 404)
        self.assertEqual(self.admin2.get(f"{O}/employees/EMP005/reporting-manager/options/").status_code, 404)
        self.assertEqual(self.admin2.get(f"{O}/chart/?root=EMP002").status_code, 404)

    def test_cannot_use_a_manager_from_another_company(self):
        r = self.post_mgr("EMP007", {"manager": "OT001"})
        self.assertEqual(r.status_code, 400)
        self.assertIn("not an active employee of your company", r.json()["message"])
        self.assertEqual(EmployeeExtra.objects.get(employee=self.bl).reporting_manager_id, self.em.id)
        r = self.post_mgr("EMP002", {"manager": "EMP001"}, self.admin2)
        self.assertEqual(r.status_code, 404)
        self.assertEqual(self.post_mgr("OT002", {"manager": "EMP001"}, self.admin2).status_code, 400)

    def test_settings_rows_are_per_company(self):
        self.assertEqual(OrgChartSettings.objects.count(), 0)
        self.admin.post(f"{O}/chart/settings/", {"group_min_size": 7}, format="json")
        self.assertEqual(self.admin2.get(f"{O}/chart/settings/").json()["data"]["group_min_size"], 3)
        self.assertEqual(OrgChartSettings.objects.count(), 2)
        self.assertEqual(self.admin.get(f"{O}/chart/settings/").json()["data"]["group_min_size"], 7)
