# 30-60-90 Day Review tests:  python manage.py test People.tests_review
from datetime import date, timedelta
from decimal import Decimal

from django.utils import timezone
from rest_framework.test import APITestCase

from Company.models import company_details
from Employee.models import EmployeeAccount, EmployeeDT, EmployeeRole
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People.models import HistoryEvent, ReviewCriterion, ReviewMilestone
from People import review_engine as en

R = "/api/people/review-306090"
ME = "/employee/review-306090/"
DOJ = date(2026, 9, 25)                    # the Joined date in the screenshots


def crit(names, scores, notes=None):
    return [{"name": n, "score": s, "note": (notes[i] if notes else f"note {i + 1}")}
            for i, (n, s) in enumerate(zip(names, scores))]


class Base(APITestCase):
    def mk_company(self, n):
        return company_details.objects.create(email=f"rv{n}@x.com", password="pw", contact_no=f"94000000{n:02d}",
                                              status=True, is_verified=True, Registered_Company_Name=f"Co{n}",
                                              Company_address="Pune")

    def mk_emp(self, co, code, name, role=None, joined=DOJ):
        e = EmployeeDT.objects.create(company=co, employee_code=code, name=name, email=f"{code}@x.com",
                                      Designation="Software Developer", Date_of_Joining=joined)
        EmployeeAccount.objects.create(employee=e, role=role)
        return e

    def setUp(self):
        self.co, self.other = self.mk_company(1), self.mk_company(2)
        hr = EmployeeRole.objects.create(company=self.co, role_name="HR", role_code="hr", can_view_employees=True,
                                         can_edit_employees=True, can_create_employees=True)
        viewer = EmployeeRole.objects.create(company=self.co, role_name="V", role_code="v", can_view_employees=True)
        self.emp = self.mk_emp(self.co, "F2E6FDE3", "hemangi patil")
        self.hr = self.mk_emp(self.co, "HR000001", "Nisha", role=hr)
        self.viewer = self.mk_emp(self.co, "VW000001", "Viewer", role=viewer)
        self.outsider = self.mk_emp(self.other, "OT000001", "Other Co Emp")
        self.admin = client_for(company_token(self.co))
        self.admin2 = client_for(company_token(self.other))
        self.hr_c = client_for(employee_token(self.hr))
        self.viewer_c = client_for(employee_token(self.viewer))
        self.me = client_for(employee_token(self.emp))

    def assess(self, day, score, status=None, client=None, **extra):
        body = {"milestone_day": day, "score": score, **extra}
        if status:
            body["status"] = status
        return (client or self.admin).post(f"{R}/{self.emp.employee_code}/assess/", body, format="json")


class MetaAndEmptyReview(Base):
    def test_meta_has_everything_the_modal_needs(self):
        d = self.admin.get(f"{R}/meta/").json()["data"]
        self.assertEqual(d["days"], [30, 60, 90])
        self.assertEqual([t["label"] for t in d["tabs"]][0], "All 3 Milestones (30-60-90)")
        self.assertIn("Competent & Strong", [s["label"] for s in d["statuses"]])
        self.assertIn("Recommended for Full Confirmation", [o["label"] for o in d["outcomes"]])
        self.assertEqual(d["score_options"][0], 1.0)
        self.assertEqual(d["score_options"][-1], 5.0)
        self.assertEqual(d["milestones"]["60"]["criteria"][0], "Technical Stack Mastery & Tool Competency")

    def test_unassessed_review_uses_templates_and_joining_dates(self):
        d = self.admin.get(f"{R}/F2E6FDE3/").json()["data"]
        ms = d["milestones"]
        self.assertEqual([m["target_date"] for m in ms], ["2026-10-25", "2026-11-24", "2026-12-24"])
        self.assertEqual([m["heading"] for m in ms],
                         ["30 Days - Performance of the Employee", "60 Days - Technical Strong",
                          "90 Days - Overall Flow"])
        self.assertEqual([len(m["criteria"]) for m in ms], [5, 5, 5])
        self.assertEqual(ms[0]["criteria"][0]["name"], "Role Clarity & Expectation Alignment")
        self.assertTrue(all(m["status"] == "PENDING" and not m["is_assessed"] for m in ms))
        s = d["summary"]
        self.assertEqual((s["milestones_completed"], s["milestones_total"], s["progress_percent"]), (0, 3, 0))
        self.assertIsNone(s["overall_rating"])
        self.assertEqual(d["employee"]["joining_date"], "2026-09-25")

    def test_single_milestone_filter(self):
        d = self.admin.get(f"{R}/F2E6FDE3/?milestone=60").json()["data"]
        self.assertEqual([m["milestone_day"] for m in d["milestones"]], [60])
        self.assertEqual(self.admin.get(f"{R}/F2E6FDE3/?milestone=45").status_code, 400)

    def test_unknown_employee_404(self):
        self.assertEqual(self.admin.get(f"{R}/NOPE/").status_code, 404)


class AssessFlow(Base):
    def full_review(self):
        n30, n60, n90 = (en.DEFAULTS["milestones"][d]["criteria"] for d in (30, 60, 90))
        self.assess(30, 4.6, "Completed", criteria=crit(n30, [5, 4.5, 5, 4.5, 4.8]),
                    strengths="Rapid adaptability\nHigh attention to detail", improvements=["Join brainstorming"],
                    remarks="Commendable start.", reviewer_title="HR Operations & Line Manager",
                    completed_date="2026-10-25")
        self.assess(60, None, "Competent & Strong", criteria=crit(n60, [4.5, 4.2, 4.4, 4.5, 4.4]),
                    completed_date="2026-11-24")
        return self.assess(90, 4.7, "Confirmed", criteria=crit(n90, [4.8, 4.6, 4.7, 4.8, 4.6]),
                           outcome="Recommended for Full Confirmation", completed_date="2026-12-24",
                           reviewer_title="Head of Department & HR Director")

    def test_screenshot_scenario_end_to_end(self):
        r = self.full_review()
        self.assertEqual(r.status_code, 201, r.content)
        d = self.admin.get(f"{R}/F2E6FDE3/").json()["data"]
        ms, s = d["milestones"], d["summary"]
        self.assertEqual([m["rating"] for m in ms], [4.6, 4.4, 4.7])             # 60-day averaged from criteria
        self.assertEqual([m["status_label"] for m in ms], ["Completed", "Competent & Strong", "Confirmed"])
        self.assertEqual((s["overall_rating"], s["overall_percent"]), (4.6, 92))
        self.assertEqual((s["milestones_completed"], s["progress_percent"]), (3, 100))
        self.assertEqual(s["probation_outcome_label"], "Recommended for Full Confirmation")
        self.assertEqual(ms[0]["strengths"], ["Rapid adaptability", "High attention to detail"])
        self.assertEqual(ms[0]["criteria"][1], {"id": ms[0]["criteria"][1]["id"], "position": 2,
                                                "name": "Initial Task Deliverables & Velocity", "score": 4.5,
                                                "note": "note 2"})
        self.assertEqual(ms[2]["outcome"], "RECOMMENDED_CONFIRMATION")
        self.assertEqual(ms[2]["assess_button"], "Assess Day 90 & Confirm")
        self.assertEqual(ms[0]["reviewer_title"], "HR Operations & Line Manager")
        self.assertTrue(all(m["due_state"] == "completed" for m in ms))

    def test_update_replaces_criteria_and_keeps_one_row(self):
        names = en.DEFAULTS["milestones"][30]["criteria"]
        self.assess(30, 4.0, criteria=crit(names, [4] * 5))
        r = self.assess(30, None, criteria=crit(names, [5] * 5), remarks="Better")
        self.assertEqual(r.status_code, 200)
        self.assertEqual(ReviewMilestone.objects.filter(employee=self.emp, milestone_day=30).count(), 1)
        self.assertEqual(ReviewCriterion.objects.filter(milestone__employee=self.emp).count(), 5)
        m = self.admin.get(f"{R}/F2E6FDE3/?milestone=30").json()["data"]["milestones"][0]
        self.assertEqual((m["rating"], m["remarks"]), (5.0, "Better"))

    def test_partial_update_keeps_other_fields(self):
        self.assess(30, 4.0, "Completed", remarks="Keep me", strengths=["A"])
        self.assess(30, 4.5)
        m = ReviewMilestone.objects.get(employee=self.emp, milestone_day=30)
        self.assertEqual((m.score, m.remarks, m.strengths, m.status), (Decimal("4.5"), "Keep me", ["A"], "COMPLETED"))

    def test_status_defaults(self):
        self.assess(30, 4.0)
        self.assertEqual(ReviewMilestone.objects.get(milestone_day=30).status, "COMPLETED")
        r = self.admin.post(f"{R}/F2E6FDE3/assess/", {"milestone_day": 60, "reviewer_name": "X"}, format="json")
        self.assertEqual(ReviewMilestone.objects.get(milestone_day=60).status, "IN_PROGRESS")
        self.assertEqual(r.status_code, 201)

    def test_completed_date_defaults_to_today(self):
        self.assess(30, 4.0, "Completed")
        self.assertEqual(ReviewMilestone.objects.get(milestone_day=30).completed_date, timezone.localdate())

    def test_history_event_logged(self):
        self.assess(30, 4.2, "Completed", remarks="ok")
        ev = HistoryEvent.objects.filter(employee=self.emp, meta__kind="review_306090").first()
        self.assertIn("30-day review completed (4.2/5)", ev.title)

    def test_reset_back_to_pending(self):
        self.assess(30, 4.0, criteria=crit(en.DEFAULTS["milestones"][30]["criteria"], [4] * 5))
        r = self.admin.post(f"{R}/F2E6FDE3/reset/", {"milestone_day": 30}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertFalse(ReviewMilestone.objects.filter(employee=self.emp).exists())
        self.assertFalse(ReviewCriterion.objects.exists())
        self.assertEqual(r.json()["data"]["milestones"][0]["status"], "PENDING")
        self.assertEqual(self.admin.post(f"{R}/F2E6FDE3/reset/", {"milestone_day": 30}, format="json").status_code, 404)


class Validation(Base):
    def bad(self, **body):
        r = self.admin.post(f"{R}/F2E6FDE3/assess/", body, format="json")
        self.assertEqual(r.status_code, 400, r.content)
        return r.json()["message"]

    def test_bad_inputs(self):
        self.assertIn("one of 30, 60, 90", self.bad(milestone_day=45, score=4))
        self.assertIn("between 1.0 and 5.0", self.bad(milestone_day=30, score=5.1))
        self.assertIn("between 1.0 and 5.0", self.bad(milestone_day=30, score=0.5))
        self.assertIn("between 1.0 and 5.0", self.bad(milestone_day=30, score="abc"))
        self.assertIn("Invalid status", self.bad(milestone_day=30, score=4, status="Great"))
        self.assertIn("needs a milestone score", self.bad(milestone_day=30, status="Completed"))
        self.assertIn("not available for the 30-day", self.bad(milestone_day=30, score=4, outcome="Extend Probation"))
        self.assertIn("not available for the 60-day", self.bad(milestone_day=60, score=4, status="Confirmed"))
        self.assertIn("Invalid outcome", self.bad(milestone_day=90, score=4, outcome="Promote"))
        self.assertIn("before the joining date", self.bad(milestone_day=30, score=4, completed_date="2026-01-01"))
        self.assertIn("Invalid date", self.bad(milestone_day=30, score=4, completed_date="25/10/2026"))
        self.assertIn("name is required", self.bad(milestone_day=30, criteria=[{"score": 4}]))
        self.assertIn("Duplicate", self.bad(milestone_day=30, criteria=[{"name": "A"}, {"name": "a"}]))
        self.assertIn("criteria[1].score", self.bad(milestone_day=30, criteria=[{"name": "A", "score": 9}]))
        self.assertIn("at most 20", self.bad(milestone_day=30, strengths=[str(i) for i in range(21)]))
        self.assertIn("must be a list", self.bad(milestone_day=30, strengths=5))
        self.assertFalse(ReviewMilestone.objects.exists())          # nothing half-saved

    def test_score_is_rounded_to_one_decimal(self):
        self.admin.post(f"{R}/F2E6FDE3/assess/", {"milestone_day": 30, "score": 4.26}, format="json")
        self.assertEqual(ReviewMilestone.objects.get().score, Decimal("4.3"))

    def test_accepts_status_code_or_label(self):
        for st in ("COMPETENT_STRONG", "competent & strong", "Competent-Strong"):
            r = self.admin.post(f"{R}/F2E6FDE3/assess/", {"milestone_day": 60, "score": 4, "status": st},
                                format="json")
            self.assertIn(r.status_code, (200, 201), (st, r.content))
        self.assertEqual(ReviewMilestone.objects.get().status, "COMPETENT_STRONG")


class Permissions(Base):
    def test_only_employees_module_users_can_use_it(self):
        self.assertEqual(self.hr_c.get(f"{R}/F2E6FDE3/").status_code, 200)
        self.assertEqual(self.assess(30, 4.0, client=self.hr_c).status_code, 201)         # edit right
        self.assertEqual(self.viewer_c.get(f"{R}/F2E6FDE3/").status_code, 200)            # view right
        self.assertEqual(self.assess(60, 4.0, client=self.viewer_c).status_code, 403)     # no edit right
        self.assertEqual(self.viewer_c.post(f"{R}/F2E6FDE3/reset/", {"milestone_day": 30}, format="json").status_code, 403)
        self.assertIn(self.me.get(f"{R}/F2E6FDE3/").status_code, (401, 403))              # plain employee
        self.assertEqual(self.assess(30, 4.0, client=self.me).status_code, 403)
        self.assertEqual(self.client.get(f"{R}/F2E6FDE3/").status_code, 401)              # anonymous


class B2BIsolation(Base):
    def test_other_company_cannot_see_or_change(self):
        self.assess(30, 4.0)
        self.assertEqual(self.admin2.get(f"{R}/F2E6FDE3/").status_code, 404)
        r = self.admin2.post(f"{R}/F2E6FDE3/assess/", {"milestone_day": 30, "score": 1}, format="json")
        self.assertEqual(r.status_code, 404)
        self.assertEqual(self.admin2.post(f"{R}/F2E6FDE3/reset/", {"milestone_day": 30}, format="json").status_code, 404)
        self.assertEqual(ReviewMilestone.objects.get(milestone_day=30).score, Decimal("4.0"))
        self.assertEqual(self.admin2.get(f"{R}/OT000001/").status_code, 200)               # own employee is fine

    def test_dashboard_is_company_scoped(self):
        self.assess(30, 4.0)
        codes = [r["employee"]["employee_code"] for r in self.admin2.get(f"{R}/").json()["data"]]
        self.assertEqual(codes, ["OT000001"])
        codes1 = [r["employee"]["employee_code"] for r in self.admin.get(f"{R}/").json()["data"]]
        self.assertNotIn("OT000001", codes1)
        self.assertEqual(ReviewMilestone.objects.filter(company=self.other).count(), 0)

    def test_company_is_never_taken_from_the_payload(self):
        self.admin.post(f"{R}/F2E6FDE3/assess/", {"milestone_day": 30, "score": 4, "company": self.other.pk,
                                                  "employee": self.outsider.pk}, format="json")
        m = ReviewMilestone.objects.get()
        self.assertEqual((m.company_id, m.employee_id), (self.co.pk, self.emp.pk))


class Dashboard(Base):
    def setUp(self):
        super().setUp()
        today = timezone.localdate()
        self.new = self.mk_emp(self.co, "NEW00001", "Newbie", joined=today - timedelta(days=5))
        self.old = self.mk_emp(self.co, "OLD00001", "Overdue Olly", joined=today - timedelta(days=40))
        self.vet = self.mk_emp(self.co, "VET00001", "Veteran", joined=date(2015, 1, 1))
        EmployeeDT.objects.filter(pk=self.emp.pk).update(Date_of_Joining=today - timedelta(days=100))
        EmployeeDT.objects.filter(pk__in=[self.hr.pk, self.viewer.pk]).update(Date_of_Joining=date(2015, 1, 1))

    def rows(self, qs=""):
        return self.admin.get(f"{R}/{qs}").json()

    def test_window_hides_veterans_and_counts_states(self):
        j = self.rows()
        codes = {r["employee"]["employee_code"]: r for r in j["data"]}
        self.assertNotIn("VET00001", codes)
        self.assertEqual(codes["OLD00001"]["state"], "overdue")        # 30-day target already passed
        self.assertEqual(codes["NEW00001"]["state"], "upcoming")
        self.assertEqual(codes["OLD00001"]["milestones"][0]["due_state"], "overdue")
        self.assertGreaterEqual(j["counts"]["overdue"], 2)

    def test_filters(self):
        self.assertEqual([r["employee"]["employee_code"] for r in self.rows("?q=olly")["data"]], ["OLD00001"])
        self.assertEqual([r["employee"]["employee_code"] for r in self.rows("?state=upcoming")["data"]], ["NEW00001"])
        self.assertEqual(sorted(r["employee"]["employee_code"] for r in self.rows("?state=overdue")["data"]),
                         ["F2E6FDE3", "OLD00001"])
        self.assertEqual(self.rows("?state=bogus").get("status"), "error")
        self.assertEqual(self.admin.get(f"{R}/?milestone=7").status_code, 400)

    def test_completed_employee_leaves_pending_filter(self):
        for d in (30, 60, 90):
            self.admin.post(f"{R}/OLD00001/assess/", {"milestone_day": d, "score": 4}, format="json")
        j = self.rows("?state=completed")
        self.assertEqual([r["employee"]["employee_code"] for r in j["data"]], ["OLD00001"])
        self.assertEqual(j["counts"]["all_completed"], 1)
        self.assertEqual(j["counts"]["assessed_by_day"], {"30": 1, "60": 1, "90": 1})
        self.assertEqual(j["counts"]["average_rating"], 4.0)
        self.assertNotIn("OLD00001", [r["employee"]["employee_code"] for r in self.rows("?milestone=30")["data"]])

    def test_pagination_meta(self):
        j = self.rows("?page_size=1")
        self.assertEqual((len(j["data"]), j["meta"]["page_size"]), (1, 1))
        self.assertGreaterEqual(j["meta"]["pages"], 3)


class SelfService(Base):
    def test_employee_sees_only_own_finished_milestones(self):
        self.assess(30, 4.5, "Completed", remarks="Great start", strengths=["Fast"],
                    criteria=crit(en.DEFAULTS["milestones"][30]["criteria"], [4.5] * 5))
        self.assess(60, 3.0, "In Progress", remarks="DRAFT - not final", strengths=["secret"])
        d = self.me.get(ME).json()["data"]
        m30, m60, m90 = d["milestones"]
        self.assertEqual((m30["rating"], m30["remarks"], m30["strengths"]), (4.5, "Great start", ["Fast"]))
        self.assertEqual(len(m30["criteria"]), 5)
        self.assertEqual((m60["rating"], m60["remarks"], m60["strengths"], m60["criteria"]), (None, "", [], []))
        self.assertEqual(m90["rating"], None)
        self.assertEqual(d["summary"]["milestones_completed"], 1)

    def test_employee_cannot_see_other_employee_or_company_admin_routes(self):
        other_emp = client_for(employee_token(self.outsider))
        self.assertEqual(other_emp.get(ME).json()["data"]["summary"]["milestones_completed"], 0)
        self.assertEqual(self.client.get(ME).status_code, 401)
        self.assertIn(self.admin.get(ME).status_code, (401, 403))            # company token is not an employee


