# 30-60-90 review - DYNAMIC configuration tests:  python manage.py test People.tests_review_config
from datetime import date, timedelta
from decimal import Decimal

from django.utils import timezone

from Employee.models import EmployeeRole
from People.models import ReviewCriterion, ReviewMilestone, ReviewOption, ReviewTemplate
from People.tests_review import Base, R, ME

C = "/api/people/review-306090-config"


class ConfigBase(Base):
    def setUp(self):
        super().setUp()
        mgr = EmployeeRole.objects.create(company=self.co, role_name="Mgr", role_code="mgr", can_view_employees=True,
                                          can_edit_employees=True, can_manage_employees=True)
        self.mgr = self.mk_emp(self.co, "MG000001", "Manager", role=mgr)
        from Employee.tests_leave_hub import client_for, employee_token
        self.mgr_c = client_for(employee_token(self.mgr))

    def post(self, path, body=None, client=None):
        return (client or self.admin).post(f"{C}/{path}", body or {}, format="json")

    def cfg(self, client=None):
        return (client or self.admin).get(f"{C}/").json()["data"]

    def review(self, client=None):
        return (client or self.admin).get(f"{R}/F2E6FDE3/").json()["data"]


class Seeding(ConfigBase):
    def test_first_access_seeds_standard_set_once(self):
        d = self.cfg()
        self.assertEqual(d["days"], [30, 60, 90])
        self.assertEqual([s["label"] for s in d["statuses"]],
                         ["Pending", "In Progress", "Completed", "Competent & Strong", "Confirmed", "Needs Improvement"])
        self.cfg(), self.cfg()
        self.assertEqual(ReviewTemplate.objects.filter(company=self.co).count(), 3)
        self.assertEqual(ReviewOption.objects.filter(company=self.co, kind="STATUS").count(), 6)
        self.assertEqual(d["settings"], {"due_soon_days": 7, "window_days": 120, "score_min": 1.0,
                                         "score_max": 5.0, "score_step": 0.5})

    def test_meta_endpoint_is_the_same_live_config(self):
        self.post("milestones/30/update/", {"title": "Edited"})
        self.assertEqual(self.admin.get(f"{R}/meta/").json()["data"]["milestones"]["30"]["title"], "Edited")


class MilestoneEditing(ConfigBase):
    def test_edit_texts_labels_headers_and_criteria_show_up_in_review(self):
        r = self.post("milestones/30/update/", {
            "title": "Settling In", "tab_label": "Settling", "subtitle": "First month", "section_title": "Month 1",
            "default_reviewer_title": "Buddy", "labels": {"strengths": "Wins", "remarks": "Notes"},
            "table_headers": {"criterion": "Area"}, "criteria": ["Punctuality", {"name": "Learning"}]})
        self.assertEqual(r.status_code, 200, r.content)
        m = self.review()["milestones"][0]
        self.assertEqual((m["title"], m["heading"], m["tab_label"], m["section_title"]),
                         ("Settling In", "30 Days - Settling In", "Settling", "Month 1"))
        self.assertEqual(m["labels"]["strengths"], "Wins")
        self.assertEqual(m["labels"]["reviewer"], "Assessed By")                  # untouched keys survive
        self.assertEqual(m["table_headers"]["criterion"], "Area")
        self.assertEqual([c["name"] for c in m["criteria"]], ["Punctuality", "Learning"])
        self.assertEqual(m["reviewer_title"], "Buddy")

    def test_saved_assessment_keeps_its_own_criteria_after_template_changes(self):
        self.assess(30, None, criteria=[{"name": "Old criterion", "score": 4}])
        self.post("milestones/30/update/", {"criteria": ["Brand new criterion"]})
        m = self.review()["milestones"][0]
        self.assertEqual([c["name"] for c in m["criteria"]], ["Old criterion"])
        self.assertEqual(self.cfg()["milestones"]["30"]["criteria"], ["Brand new criterion"])

    def test_add_milestone_changes_everything_downstream(self):
        r = self.post("milestones/", {"milestone_day": 15, "title": "Induction", "criteria": ["Orientation"]})
        self.assertEqual(r.status_code, 201, r.content)
        d = self.review()
        self.assertEqual([m["milestone_day"] for m in d["milestones"]], [15, 30, 60, 90])
        self.assertEqual(d["milestones"][0]["target_date"], "2026-10-10")           # DOJ 2026-09-25 + 15
        self.assertEqual(d["tabs"][0]["label"], "All 4 Milestones (15-30-60-90)")
        self.assertEqual(d["summary"]["milestones_total"], 4)
        self.assertEqual(self.assess(15, 4.0, "Completed").status_code, 201)
        self.assertEqual(self.review()["summary"]["milestones_completed"], 1)
        self.assertEqual(self.me.get(ME).json()["data"]["milestones"][0]["milestone_day"], 15)
        self.assertEqual(self.admin.get(f"{R}/?milestone=15").status_code, 200)

    def test_milestone_validation(self):
        bad = lambda body, path="milestones/": self.post(path, body)
        for body in ({"milestone_day": 0, "title": "x"}, {"milestone_day": 731, "title": "x"},
                     {"milestone_day": "abc", "title": "x"}, {"milestone_day": 45},
                     {"milestone_day": 45, "title": "x", "labels": {"bogus": "a"}},
                     {"milestone_day": 45, "title": "x", "table_headers": {"bogus": "a"}},
                     {"milestone_day": 45, "title": "x", "criteria": ["a", "A"]},
                     {"milestone_day": 45, "title": "x", "criteria": [""]},
                     {"milestone_day": 45, "title": "x", "criteria": "nope"},
                     {"milestone_day": 45, "title": "x" * 151}):
            self.assertEqual(bad(body).status_code, 400, body)
        self.assertEqual(bad({"milestone_day": 30, "title": "dup"}).status_code, 400)       # already exists
        self.assertEqual(bad({"title": ""}, "milestones/30/update/").status_code, 400)
        self.assertEqual(bad({"title": "x"}, "milestones/77/update/").status_code, 404)

    def test_at_most_six_milestones(self):
        for d in (10, 20, 45):
            self.assertEqual(self.post("milestones/", {"milestone_day": d, "title": f"M{d}"}).status_code, 201)
        r = self.post("milestones/", {"milestone_day": 100, "title": "seventh"})
        self.assertEqual(r.status_code, 400)
        self.assertIn("At most 6", r.json()["message"])

    def test_delete_unused_removes_used_only_hides(self):
        self.assess(60, 4.0)
        r = self.post("milestones/60/delete/")
        self.assertIn("hidden", r.json()["message"])
        self.assertEqual(self.cfg()["days"], [30, 90])
        self.assertTrue(ReviewMilestone.objects.filter(milestone_day=60).exists())          # data kept
        self.assertIn("deleted", self.post("milestones/90/delete/").json()["message"])
        self.assertFalse(ReviewTemplate.objects.filter(company=self.co, milestone_day=90).exists())
        self.assertEqual(self.post("milestones/30/delete/").status_code, 400)               # last one stays
        # re-adding a hidden day re-activates it (old assessment is visible again)
        self.assertEqual(self.post("milestones/", {"milestone_day": 60, "title": "Back"}).status_code, 201)
        self.assertEqual(self.review()["milestones"][1]["rating"], 4.0)

    def test_reset_defaults_restores_missing_but_keeps_edits(self):
        self.post("milestones/30/update/", {"title": "My title"})
        self.post("milestones/90/delete/")
        self.post("options/%d/delete/" % ReviewOption.objects.get(company=self.co, code="CONFIRMED").pk)
        r = self.post("reset-defaults/")
        self.assertEqual(r.status_code, 200)
        d = self.cfg()
        self.assertEqual(d["days"], [30, 60, 90])
        self.assertEqual(d["milestones"]["30"]["title"], "My title")
        self.assertIn("Confirmed", [s["label"] for s in d["statuses"]])


class OptionsAreDynamic(ConfigBase):
    def new_status(self, **kw):
        body = {"kind": "STATUS", "label": "Exceeds Expectations", "counts_as_completed": True,
                "milestone_days": [60], **kw}
        return self.post("options/", body)

    def test_custom_status_scoped_to_a_milestone(self):
        r = self.new_status()
        self.assertEqual(r.status_code, 201, r.content)
        self.assertEqual(self.assess(60, 4.8, "Exceeds Expectations").status_code, 201)
        self.assertEqual(self.review()["milestones"][1]["status_label"], "Exceeds Expectations")
        self.assertTrue(self.review()["milestones"][1]["is_assessed"])
        bad = self.assess(30, 4.8, "Exceeds Expectations")
        self.assertEqual(bad.status_code, 400)
        self.assertIn("not available for the 30-day", bad.json()["message"])

    def test_non_completing_status_does_not_count(self):
        self.post("options/", {"kind": "STATUS", "label": "On Hold", "counts_as_completed": False})
        self.assess(30, 4.0, "On Hold")
        self.assertEqual(self.review()["summary"]["milestones_completed"], 0)

    def test_status_removed_by_company_is_rejected(self):
        self.cfg()                                       # first access seeds this company's rows
        oid = ReviewOption.objects.get(company=self.co, code="NEEDS_IMPROVEMENT").pk
        self.post(f"options/{oid}/delete/")
        r = self.assess(30, 3.0, "Needs Improvement")
        self.assertEqual(r.status_code, 400)

    def test_default_done_status_follows_company_config(self):
        self.cfg()                                       # first access seeds this company's rows
        for code in ("COMPLETED",):
            self.post(f"options/{ReviewOption.objects.get(company=self.co, code=code).pk}/delete/")
        self.assess(30, 4.0)                                         # no status given -> first completed-type one
        self.assertEqual(ReviewMilestone.objects.get().status, "COMPETENT_STRONG")

    def test_custom_outcome_on_any_milestone(self):
        self.post("options/", {"kind": "OUTCOME", "label": "Fast-track Promotion", "milestone_days": [60, 90]})
        self.assertEqual(self.assess(60, 4.5, outcome="Fast-track Promotion").status_code, 201)
        d = self.review()
        self.assertTrue(d["milestones"][1]["has_outcome"] and not d["milestones"][0]["has_outcome"])
        self.assertEqual(d["milestones"][1]["outcome_label"], "Fast-track Promotion")
        self.assertEqual(d["milestones"][1]["assess_button"], "Assess Day 60 & Confirm")
        bad = self.assess(30, 4.5, outcome="Fast-track Promotion")
        self.assertEqual(bad.status_code, 400)

    def test_rename_option_changes_label_everywhere_but_code_stays(self):
        self.assess(90, 4.7, "Confirmed", outcome="Extend Probation")
        oid = ReviewOption.objects.get(company=self.co, code="EXTEND_PROBATION").pk
        self.post(f"options/{oid}/update/", {"label": "Extend by 3 months"})
        m = self.review()["milestones"][2]
        self.assertEqual((m["outcome"], m["outcome_label"]), ("EXTEND_PROBATION", "Extend by 3 months"))

    def test_deleting_used_option_hides_it_but_old_rows_keep_label(self):
        self.assess(90, 4.7, "Confirmed", outcome="Extend Probation")
        oid = ReviewOption.objects.get(company=self.co, code="EXTEND_PROBATION").pk
        self.assertIn("hidden", self.post(f"options/{oid}/delete/").json()["message"])
        self.assertEqual(self.review()["milestones"][2]["outcome_label"], "Extend Probation")
        self.assertEqual(self.assess(90, 4.7, outcome="Extend Probation").status_code, 400)   # no longer selectable

    def test_system_and_last_completed_status_protection(self):
        self.cfg()                                       # first access seeds this company's rows
        pend = ReviewOption.objects.get(company=self.co, code="PENDING")
        self.assertEqual(self.post(f"options/{pend.pk}/delete/").status_code, 400)
        self.assertEqual(self.post(f"options/{pend.pk}/update/", {"counts_as_completed": True}).status_code, 400)
        self.assertEqual(self.post(f"options/{pend.pk}/update/", {"label": "Not started"}).status_code, 200)
        done = list(ReviewOption.objects.filter(company=self.co, kind="STATUS", counts_as_completed=True))
        for o in done[:-1]:
            self.assertEqual(self.post(f"options/{o.pk}/delete/").status_code, 200)
        last = done[-1]
        self.assertEqual(self.post(f"options/{last.pk}/delete/").status_code, 400)
        self.assertEqual(self.post(f"options/{last.pk}/update/", {"counts_as_completed": False}).status_code, 400)

    def test_option_validation(self):
        for body in ({"kind": "X", "label": "a"}, {"kind": "STATUS"}, {"kind": "STATUS", "label": "x" * 101},
                     {"kind": "STATUS", "label": "completed"},                          # duplicate label
                     {"kind": "STATUS", "label": "A", "milestone_days": "90"},
                     {"kind": "STATUS", "label": "A", "milestone_days": [0]}):
            self.assertEqual(self.post("options/", body).status_code, 400, body)
        self.assertEqual(self.post("options/999999/update/", {"label": "z"}).status_code, 404)
        oid = ReviewOption.objects.get(company=self.co, code="COMPLETED").pk
        self.assertEqual(self.post(f"options/{oid}/update/", {"label": "Pending"}).status_code, 400)


class SettingsAreDynamic(ConfigBase):
    def test_score_scale_drives_validation_and_percent(self):
        self.assertEqual(self.post("settings/", {"score_min": 1, "score_max": 10, "score_step": 1}).status_code, 200)
        self.assertEqual(self.cfg()["score_options"][-1], 10.0)
        self.assertEqual(self.assess(30, 8.0).status_code, 201)
        s = self.review()["summary"]
        self.assertEqual((s["overall_rating"], s["overall_percent"], s["score_max"]), (8.0, 80, 10.0))
        self.assertEqual(self.assess(60, 10.5).status_code, 400)

    def test_cannot_shrink_scale_below_saved_scores(self):
        self.post("settings/", {"score_max": 10})
        self.assess(30, 9.0, criteria=[{"name": "A", "score": 9}])
        r = self.post("settings/", {"score_max": 5})
        self.assertEqual(r.status_code, 400)
        self.assertIn("fall outside", r.json()["message"])

    def test_settings_validation(self):
        for body in ({"due_soon_days": 61}, {"due_soon_days": "x"}, {"window_days": 0}, {"window_days": 401},
                     {"score_min": 5, "score_max": 5}, {"score_max": 101}, {"score_step": 0}, {"score_step": 9}):
            self.assertEqual(self.post("settings/", body).status_code, 400, body)

    def test_due_soon_days_changes_state(self):
        today = timezone.localdate()
        from Employee.models import EmployeeDT
        EmployeeDT.objects.filter(pk=self.emp.pk).update(Date_of_Joining=today - timedelta(days=30 - 12))   # day-30 in 12 days
        self.assertEqual(self.review()["milestones"][0]["due_state"], "upcoming")
        self.post("settings/", {"due_soon_days": 14})
        self.assertEqual(self.review()["milestones"][0]["due_state"], "due_soon")

    def test_window_days_is_the_dashboard_default(self):
        from Employee.models import EmployeeDT
        today = timezone.localdate()
        EmployeeDT.objects.filter(pk__in=[self.emp.pk, self.hr.pk, self.viewer.pk, self.outsider.pk]).update(
            Date_of_Joining=date(2015, 1, 1))
        e = self.mk_emp(self.co, "WIN00001", "Winnie", joined=today - timedelta(days=200))
        self.assertNotIn("WIN00001", [r["employee"]["employee_code"] for r in self.admin.get(f"{R}/").json()["data"]])
        self.post("settings/", {"window_days": 250})
        self.assertIn("WIN00001", [r["employee"]["employee_code"] for r in self.admin.get(f"{R}/").json()["data"]])


class ConfigPermissionsAndIsolation(ConfigBase):
    def test_write_needs_manage_read_needs_view(self):
        self.assertEqual(self.hr_c.get(f"{C}/").status_code, 200)                       # edit-only HR can read
        self.assertEqual(self.post("milestones/30/update/", {"title": "x"}, self.hr_c).status_code, 403)
        self.assertEqual(self.post("settings/", {"due_soon_days": 3}, self.hr_c).status_code, 403)
        self.assertEqual(self.post("options/", {"kind": "STATUS", "label": "Z"}, self.viewer_c).status_code, 403)
        self.assertEqual(self.post("milestones/30/update/", {"title": "By manager"}, self.mgr_c).status_code, 200)
        self.assertEqual(self.me.get(f"{C}/").status_code, 403)                          # plain employee
        self.assertEqual(self.client.get(f"{C}/").status_code, 401)
        self.assertEqual(ReviewTemplate.objects.get(company=self.co, milestone_day=30).title, "By manager")

    def test_each_company_has_its_own_configuration(self):
        self.post("milestones/30/update/", {"title": "Company-1 only"})
        self.post("milestones/", {"milestone_day": 15, "title": "Induction"})
        self.post("options/", {"kind": "STATUS", "label": "Secret Status"})
        other = self.admin2.get(f"{C}/").json()["data"]
        self.assertEqual(other["days"], [30, 60, 90])
        self.assertEqual(other["milestones"]["30"]["title"], "Performance of the Employee")
        self.assertNotIn("Secret Status", [s["label"] for s in other["statuses"]])
        # B cannot touch A's rows by id / day
        oid = ReviewOption.objects.get(company=self.co, label="Secret Status").pk
        self.assertEqual(self.post(f"options/{oid}/update/", {"label": "hacked"}, self.admin2).status_code, 404)
        self.assertEqual(self.post(f"options/{oid}/delete/", {}, self.admin2).status_code, 404)
        self.assertEqual(self.post("milestones/15/update/", {"title": "hacked"}, self.admin2).status_code, 404)
        self.assertEqual(self.post("milestones/15/delete/", {}, self.admin2).status_code, 404)
        self.assertEqual(ReviewOption.objects.get(pk=oid).label, "Secret Status")
        # B's own settings change doesn't leak into A
        self.post("settings/", {"score_max": 10}, self.admin2)
        self.assertEqual(self.cfg()["score_max"], 5.0)
        self.assertEqual(self.admin2.get(f"{R}/OT000001/").json()["data"]["summary"]["score_max"], 10.0)
