# ============================================================
# ADDITIVE tests - Performance Management & OKRs
#   python manage.py test Employee.tests_performance
# ============================================================

from datetime import date, timedelta
from decimal import Decimal

from rest_framework.test import APIClient, APITestCase

from Company.models import company_details
from Employee.leave_models import ReportingHierarchy
from Employee.models import EmployeeAccount, EmployeeDT, EmployeeRole, Target
from Employee.performance_models import (
    PerfAppraisal, PerfGoal, PerfRatingHistory, PerfReviewCycle,
)
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People.models import PromotionRequest

API = "/api/performance"
ME = "/employee/performance"


class PerfBase(APITestCase):

    def mk_company(self, n):
        return company_details.objects.create(
            email=f"pc{n}@x.com", password="pw", contact_no=f"91000000{n:02d}",
            status=True, is_verified=True)

    def mk_emp(self, company, name, role=None, n=0, joined=None, designation="Engineer"):
        e = EmployeeDT.objects.create(
            company=company, name=name, email=f"{name.lower()}{n}@x.com",
            Designation=designation, Date_of_Joining=joined)
        EmployeeAccount.objects.create(employee=e, role=role)
        return e

    def setUp(self):
        self.company = self.mk_company(1)
        self.other = self.mk_company(2)

        self.hr_role = EmployeeRole.objects.create(
            company=self.company, role_name="HR", role_code="hr",
            can_view_performance=True, can_create_performance=True,
            can_edit_performance=True, can_delete_performance=True)
        self.view_role = EmployeeRole.objects.create(
            company=self.company, role_name="Viewer", role_code="viewer",
            can_view_performance=True)

        self.rahul = self.mk_emp(self.company, "Rahul", n=1, joined=date(2024, 1, 10),
                                 designation="Senior Full Stack Engineer")
        self.amit = self.mk_emp(self.company, "Amit", n=2, joined=date(2022, 5, 1),
                                designation="Principal Software Architect")
        self.priya = self.mk_emp(self.company, "Priya", n=3, joined=date(2026, 6, 1))
        self.hr = self.mk_emp(self.company, "Hrperson", role=self.hr_role, n=4)
        self.viewer = self.mk_emp(self.company, "Viewer", role=self.view_role, n=5)
        self.stranger = self.mk_emp(self.company, "Stranger", n=6)
        self.outsider = self.mk_emp(self.other, "Outsider", n=7)

        ReportingHierarchy.objects.create(
            company=self.company, Employee_ID=self.rahul.employee_code,
            manager_code=self.amit.employee_code)

        self.admin = client_for(company_token(self.company))
        self.hr_c = client_for(employee_token(self.hr))
        self.view_c = client_for(employee_token(self.viewer))
        self.rahul_c = client_for(employee_token(self.rahul))
        self.amit_c = client_for(employee_token(self.amit))
        self.stranger_c = client_for(employee_token(self.stranger))
        self.other_admin = client_for(company_token(self.other))

    # helpers -------------------------------------------------
    def mk_cycle(self, name="Mid-Year Performance Review (H1 2026)", **kw):
        body = {"name": name, "cycle_type": "Mid-Year", "period_label": "H1 2026",
                "submission_deadline": "2026-09-30", "eligible_joined_before": "2026-04-01",
                **kw}
        r = self.admin.post(f"{API}/review-cycles/", body, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        return r.json()["data"]

    def mk_appraisal(self, emp, cycle_id, **kw):
        body = {"employee_code": emp.employee_code, "cycle": cycle_id, **kw}
        r = self.admin.post(f"{API}/appraisals/", body, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        return r.json()["data"]


class PermissionTests(PerfBase):

    def test_requires_auth(self):
        self.assertEqual(APIClient().get(f"{API}/goals/").status_code, 401)

    def test_plain_employee_forbidden(self):
        r = self.stranger_c.get(f"{API}/goals/")
        self.assertEqual(r.status_code, 403)
        self.assertEqual(r.json()["code"], "permission_denied")

    def test_viewer_can_read_not_write(self):
        self.assertEqual(self.view_c.get(f"{API}/goals/").status_code, 200)
        r = self.view_c.post(f"{API}/goals/", {"employee_code": self.rahul.employee_code,
                                               "title": "x"}, format="json")
        self.assertEqual(r.status_code, 403)

    def test_hr_role_can_write(self):
        r = self.hr_c.post(f"{API}/goals/", {"employee_code": self.rahul.employee_code,
                                             "title": "Ship v2"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        self.assertTrue(r.json()["data"]["created_at"])

    def test_manage_employees_fallback(self):
        role = EmployeeRole.objects.create(company=self.company, role_name="Mgr",
                                           role_code="mgr", can_manage_employees=True)
        e = self.mk_emp(self.company, "Fallback", role=role, n=9)
        self.assertEqual(client_for(employee_token(e)).get(f"{API}/goals/").status_code, 200)

    def test_company_isolation(self):
        c = self.mk_cycle()
        self.assertEqual(self.other_admin.get(f"{API}/review-cycles/{c['id']}/").status_code, 404)
        self.assertEqual(self.other_admin.get(f"{API}/review-cycles/").json()["data"]["count"], 0)
        r = self.other_admin.post(f"{API}/goals/", {"employee_code": self.rahul.employee_code,
                                                    "title": "x"}, format="json")
        self.assertEqual(r.status_code, 400)
        self.assertIn("employee_code", r.json()["errors"])


class ReviewCycleTests(PerfBase):

    def test_crud(self):
        c = self.mk_cycle()
        self.assertEqual(c["financial_year"], "2026-27")
        self.assertEqual(c["submission_deadline_label"], "30 September 2026")
        self.assertEqual(c["eligibility_label"], "All employees joined before 01 April 2026")

        dup = self.admin.post(f"{API}/review-cycles/", {"name": c["name"]}, format="json")
        self.assertEqual(dup.status_code, 409)

        r = self.admin.patch(f"{API}/review-cycles/{c['id']}/", {"status": "Active"}, format="json")
        self.assertEqual(r.json()["data"]["status"], "Active")

        r = self.admin.put(f"{API}/review-cycles/{c['id']}/", {
            "name": c["name"], "cycle_type": "Mid-Year", "status": "Active",
            "start_date": "2026-10-01", "end_date": "2026-09-01"}, format="json")
        self.assertEqual(r.status_code, 400)

        lst = self.admin.get(f"{API}/review-cycles/?status=Active").json()["data"]
        self.assertEqual(lst["count"], 1)
        self.assertEqual(self.admin.delete(f"{API}/review-cycles/{c['id']}/").status_code, 200)

    def test_launch_only_eligible(self):
        c = self.mk_cycle()
        r = self.admin.post(f"{API}/review-cycles/{c['id']}/launch/", {}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        d = r.json()["data"]
        # Rahul + Amit joined before 1 Apr 2026; Priya (Jun 2026) is not eligible.
        # hr / viewer / stranger have no joining date -> included, flagged.
        self.assertFalse(PerfAppraisal.objects.filter(employee=self.priya).exists())
        self.assertTrue(PerfAppraisal.objects.filter(employee=self.rahul).exists())
        self.assertEqual(d["joining_date_missing"], 3)
        self.assertEqual(d["cycle"]["status"], "Active")
        rahul = PerfAppraisal.objects.get(employee=self.rahul)
        self.assertEqual(rahul.reviewer_code, self.amit.employee_code)

        again = self.admin.post(f"{API}/review-cycles/{c['id']}/launch/", {}, format="json")
        self.assertEqual(again.json()["data"]["appraisals_created"], 0)

    def test_delete_blocked_when_in_use(self):
        c = self.mk_cycle()
        self.mk_appraisal(self.rahul, c["id"])
        self.assertEqual(self.admin.delete(f"{API}/review-cycles/{c['id']}/").status_code, 409)
        self.assertEqual(
            self.admin.delete(f"{API}/review-cycles/{c['id']}/?force=true").status_code, 200)
        self.assertFalse(PerfAppraisal.objects.exists())

    def test_activate_close(self):
        c = self.mk_cycle()
        self.assertEqual(self.admin.post(f"{API}/review-cycles/{c['id']}/activate/").json()
                         ["data"]["status"], "Active")
        self.assertEqual(self.admin.post(f"{API}/review-cycles/{c['id']}/close/").json()
                         ["data"]["status"], "Closed")
        self.assertEqual(self.admin.post(f"{API}/review-cycles/{c['id']}/launch/").status_code, 409)


class GoalTests(PerfBase):

    def test_progress_autocalc_and_status(self):
        r = self.admin.post(f"{API}/goals/", {
            "employee_code": self.rahul.employee_code,
            "title": "Improve Lighthouse score", "target_value": 95, "current_value": 78,
            "unit": "score"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        g = r.json()["data"]
        self.assertEqual(g["progress_percent"], 82.11)
        self.assertEqual(g["status"], "In Progress")
        self.assertEqual(g["employee"]["name"], "Rahul")

        r = self.admin.post(f"{API}/goals/{g['id']}/progress/", {"current_value": 95}, format="json")
        d = r.json()["data"]
        self.assertEqual(d["progress_percent"], 100.0)
        self.assertEqual(d["status"], "Completed")
        self.assertIsNotNone(d["completed_at"])

        r = self.admin.patch(f"{API}/goals/{g['id']}/", {"status": "At Risk"}, format="json")
        self.assertIsNone(r.json()["data"]["completed_at"])

    def test_validation(self):
        r = self.admin.post(f"{API}/goals/", {
            "employee_code": self.rahul.employee_code, "title": "x",
            "progress_percent": 120, "start_date": "2026-05-01", "due_date": "2026-04-01"},
            format="json")
        self.assertEqual(r.status_code, 400)
        self.assertIn("progress_percent", r.json()["errors"])
        r = self.admin.post(f"{API}/goals/", {"title": "x"}, format="json")
        self.assertIn("employee_code", r.json()["errors"])

    def test_filters_search_and_crud(self):
        for emp, title in ((self.rahul, "Alpha"), (self.amit, "Beta")):
            self.admin.post(f"{API}/goals/", {"employee_code": emp.employee_code,
                                              "title": title}, format="json")
        self.assertEqual(self.admin.get(
            f"{API}/goals/?employee_code={self.amit.employee_code}").json()["data"]["count"], 1)
        self.assertEqual(self.admin.get(f"{API}/goals/?search=alp").json()["data"]["count"], 1)
        gid = self.admin.get(f"{API}/goals/?search=alp").json()["data"]["results"][0]["id"]
        self.assertEqual(self.admin.put(f"{API}/goals/{gid}/", {
            "employee_code": self.rahul.employee_code, "title": "Alpha 2", "weight": 40},
            format="json").json()["data"]["weight"], 40.0)
        self.assertEqual(self.admin.delete(f"{API}/goals/{gid}/").status_code, 200)
        self.assertEqual(self.admin.get(f"{API}/goals/{gid}/").status_code, 404)

    def test_set_objectives_bulk_all_or_nothing(self):
        c = self.mk_cycle()
        body = {"employee_codes": [self.rahul.employee_code, self.amit.employee_code],
                "cycle": c["id"],
                "objectives": [{"title": "Reduce latency", "weight": 50},
                               {"title": "Mentor juniors", "weight": 50}]}
        r = self.admin.post(f"{API}/goals/set-objectives/", body, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        self.assertEqual(r.json()["data"]["created"], 4)
        again = self.admin.post(f"{API}/goals/set-objectives/", body, format="json")
        self.assertEqual(again.json()["data"]["skipped_duplicates"], 4)

        bad = {**body, "objectives": [{"title": "ok"}, {"title": "bad", "weight": 500}]}
        r = self.admin.post(f"{API}/goals/set-objectives/", bad, format="json")
        self.assertEqual(r.status_code, 400)
        self.assertEqual(PerfGoal.objects.count(), 4)

    def test_import_old_targets_once(self):
        Target.objects.create(employee=self.rahul, company=self.company, titel="Old target",
                              create_date=date(2026, 5, 1), target_date=date(2026, 12, 1),
                              completed=True, completed_date=date(2026, 9, 1))
        r = self.admin.post(f"{API}/goals/import-targets/", {}, format="json")
        self.assertEqual(r.json()["data"]["created"], 1)
        g = PerfGoal.objects.get()
        self.assertEqual(g.status, "Completed")
        self.assertEqual(g.progress_percent, Decimal("100"))
        self.assertEqual(Target.objects.count(), 1)
        r = self.admin.post(f"{API}/goals/import-targets/", {}, format="json")
        self.assertEqual(r.json()["data"]["skipped_already_imported"], 1)

    def test_overview_cards(self):
        c = self.mk_cycle(status="Active")
        self.admin.post(f"{API}/goals/", {"employee_code": self.rahul.employee_code,
                                          "cycle": c["id"], "title": "G1",
                                          "progress_percent": 85}, format="json")
        r = self.admin.get(f"{API}/goals/overview/")
        card = r.json()["data"]["employees"][0]
        self.assertEqual(card["title"], "Rahul (Senior Full Stack Engineer)")
        self.assertEqual(card["goals"][0]["progress_percent"], 85)


class AppraisalTests(PerfBase):

    def test_create_validate_and_labels(self):
        c = self.mk_cycle()
        a = self.mk_appraisal(self.rahul, c["id"], self_score=4.9, manager_score=4.8,
                              promotion_proposed=True, proposed_level="L4")
        self.assertEqual(a["normalized_rating"], 4.8)
        self.assertEqual(a["normalized_badge"], "4.8 (Exceeds)")
        self.assertEqual(a["promotion_label"], "Yes (L4)")
        self.assertEqual(a["rating_label"], "Exceeds Expectations")

        r = self.admin.post(f"{API}/appraisals/", {"employee_code": self.rahul.employee_code,
                                                   "cycle": c["id"]}, format="json")
        self.assertEqual(r.status_code, 409)
        r = self.admin.post(f"{API}/appraisals/", {"employee_code": self.amit.employee_code,
                                                   "cycle": c["id"], "manager_score": 5.5},
                            format="json")
        self.assertEqual(r.status_code, 400)
        r = self.admin.post(f"{API}/appraisals/", {"employee_code": self.amit.employee_code,
                                                   "cycle": c["id"],
                                                   "promotion_proposed": True}, format="json")
        self.assertIn("proposed_level", r.json()["errors"])

    def test_calibration_overrides_manager_score(self):
        c = self.mk_cycle()
        a = self.mk_appraisal(self.rahul, c["id"], manager_score=4.0)
        r = self.admin.patch(f"{API}/appraisals/{a['id']}/", {"normalized_rating": 4.5}, format="json")
        self.assertEqual(r.json()["data"]["normalized_rating"], 4.5)
        r = self.admin.patch(f"{API}/appraisals/{a['id']}/", {"manager_score": 3.2}, format="json")
        self.assertEqual(r.json()["data"]["normalized_rating"], 4.5)   # still calibrated
        r = self.admin.patch(f"{API}/appraisals/{a['id']}/", {"normalized_rating": None}, format="json")
        self.assertEqual(r.json()["data"]["normalized_rating"], 3.2)   # follows manager again

    def test_complete_writes_rating_history(self):
        c = self.mk_cycle()
        a = self.mk_appraisal(self.rahul, c["id"])
        r = self.admin.post(f"{API}/appraisals/{a['id']}/complete/", {}, format="json")
        self.assertEqual(r.status_code, 400)          # no manager score yet

        self.admin.patch(f"{API}/appraisals/{a['id']}/", {"manager_score": 4.6}, format="json")
        r = self.admin.post(f"{API}/appraisals/{a['id']}/complete/", {}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        self.assertEqual(r.json()["data"]["status"], "Completed")
        h = PerfRatingHistory.objects.get(employee=self.rahul)
        self.assertEqual((h.rating, h.rating_bucket, h.source), (Decimal("4.6"), 4, "appraisal"))
        self.assertEqual(h.period_label, "H1 2026")

        # editing a completed appraisal keeps history in sync
        self.admin.patch(f"{API}/appraisals/{a['id']}/", {"manager_score": 5.0}, format="json")
        h.refresh_from_db()
        self.assertEqual((h.rating, h.rating_bucket), (Decimal("5.0"), 5))
        self.assertEqual(PerfRatingHistory.objects.count(), 1)

        self.assertEqual(self.admin.post(
            f"{API}/appraisals/{a['id']}/complete/", {}, format="json").status_code, 409)

    def test_nominate_promotion_reuses_people_model(self):
        c = self.mk_cycle()
        a = self.mk_appraisal(self.rahul, c["id"], manager_score=4.8,
                              promotion_proposed=True, proposed_level="L4")
        r = self.admin.post(f"{API}/appraisals/{a['id']}/nominate-promotion/", {}, format="json")
        self.assertEqual(r.status_code, 400)
        r = self.admin.post(f"{API}/appraisals/{a['id']}/nominate-promotion/",
                            {"proposed_designation": "Lead Architect", "hike_percent": 12},
                            format="json")
        self.assertEqual(r.status_code, 201, r.json())
        p = PromotionRequest.objects.get()
        self.assertEqual((p.proposed_designation, p.proposed_grade, p.status),
                         ("Lead Architect", "L4", "Nominated"))
        self.assertEqual(p.current_designation, "Senior Full Stack Engineer")
        self.assertEqual(self.admin.post(
            f"{API}/appraisals/{a['id']}/nominate-promotion/",
            {"proposed_designation": "x"}, format="json").status_code, 409)

    def test_summary_and_dashboard_cards(self):
        c = self.mk_cycle(status="Active")
        a1 = self.mk_appraisal(self.rahul, c["id"], manager_score=4.8, potential="High")
        a2 = self.mk_appraisal(self.amit, c["id"], manager_score=4.0, potential="Medium")
        self.admin.post(f"{API}/appraisals/{a1['id']}/complete/", {}, format="json")
        self.admin.post(f"{API}/pips/", {"employee_code": self.stranger.employee_code,
                                         "reason": "Missed targets"}, format="json")

        d = self.admin.get(f"{API}/dashboard/").json()["data"]
        cards = d["cards"]
        self.assertEqual(cards["company_average_rating"]["value"], 4.4)
        self.assertEqual(cards["company_average_rating"]["label"], "4.4 / 5.0")
        self.assertEqual(cards["company_average_rating"]["caption"], "Based on H1 2026")
        self.assertEqual(cards["appraisal_completion"]["label"], "50.0%")
        self.assertEqual(cards["high_potential_talent"]["value"], 1)
        self.assertEqual(cards["performance_pips"]["value"], 1)
        self.assertEqual(d["scope"]["cycle_id"], c["id"])
        names = [e["employee"]["name"] for e in d["employees"]]
        self.assertEqual(names, ["Amit", "Rahul"])
        rahul = d["employees"][1]
        self.assertEqual(rahul["rating_badge"], "4.8 - Exceeds Expectations")
        self.assertEqual(rahul["cycle_label"], c["name"])

        s = self.admin.get(f"{API}/appraisals/summary/").json()["data"]
        self.assertEqual(s["total"], 2)
        self.assertEqual(s["by_status"]["Completed"], 1)

        self.assertEqual(self.admin.get(f"{API}/dashboard/?financial_year=bad").status_code, 400)
        self.assertEqual(self.admin.get(f"{API}/dashboard/?cycle_id=9999").status_code, 400)

    def test_filters(self):
        c = self.mk_cycle()
        self.mk_appraisal(self.rahul, c["id"], promotion_proposed=True, proposed_level="L4")
        self.mk_appraisal(self.amit, c["id"])
        q = f"{API}/appraisals/?promotion_proposed=true"
        self.assertEqual(self.admin.get(q).json()["data"]["count"], 1)
        self.assertEqual(self.admin.get(f"{API}/appraisals/?search=amit").json()["data"]["count"], 1)


class FeedbackSelfReviewPIPTests(PerfBase):

    def test_manager_feedback_crud(self):
        r = self.admin.post(f"{API}/manager-feedback/", {
            "employee_code": self.rahul.employee_code, "manager_code": self.amit.employee_code,
            "feedback": "Exceptional technical ownership.", "feedback_type": "1-on-1",
            "meeting_date": "2026-09-20"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        f = r.json()["data"]
        self.assertEqual(f["heading"], "Amit (Manager) on Rahul (Senior Full Stack Engineer):")
        self.assertFalse(f["visible_to_employee"])

        bad = self.admin.post(f"{API}/manager-feedback/", {
            "employee_code": self.rahul.employee_code, "manager_code": self.rahul.employee_code,
            "feedback": "self"}, format="json")
        self.assertEqual(bad.status_code, 400)

        r = self.admin.patch(f"{API}/manager-feedback/{f['id']}/",
                             {"visible_to_employee": True}, format="json")
        self.assertTrue(r.json()["data"]["visible_to_employee"])
        self.assertEqual(self.admin.get(
            f"{API}/manager-feedback/?manager_code={self.amit.employee_code}"
        ).json()["data"]["count"], 1)
        self.assertEqual(self.admin.delete(f"{API}/manager-feedback/{f['id']}/").status_code, 200)

    def test_self_review_submit_updates_appraisal(self):
        c = self.mk_cycle()
        a = self.mk_appraisal(self.rahul, c["id"])
        r = self.admin.post(f"{API}/self-reviews/", {
            "employee_code": self.rahul.employee_code, "cycle": c["id"],
            "summary": "Delivered the engine ahead of schedule.", "self_score": 4.9},
            format="json")
        self.assertEqual(r.status_code, 201, r.json())
        sr = r.json()["data"]
        self.assertEqual(sr["status"], "Draft")

        r = self.admin.post(f"{API}/self-reviews/{sr['id']}/submit/", {}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        self.assertIsNotNone(r.json()["data"]["submitted_at"])
        ap = PerfAppraisal.objects.get(pk=a["id"])
        self.assertEqual(ap.self_score, Decimal("4.9"))
        self.assertEqual(ap.status, "Pending Manager Review")
        self.assertEqual(self.admin.post(
            f"{API}/self-reviews/{sr['id']}/submit/", {}, format="json").status_code, 409)

        dup = self.admin.post(f"{API}/self-reviews/", {
            "employee_code": self.rahul.employee_code, "cycle": c["id"], "summary": "again"},
            format="json")
        self.assertEqual(dup.status_code, 409)

    def test_self_review_creates_missing_appraisal(self):
        c = self.mk_cycle()
        self.admin.post(f"{API}/self-reviews/", {
            "employee_code": self.amit.employee_code, "cycle": c["id"],
            "summary": "Done", "status": "Submitted"}, format="json")
        self.assertTrue(PerfAppraisal.objects.filter(employee=self.amit, cycle_id=c["id"]).exists())

    def test_empty_summary_cannot_be_submitted(self):
        c = self.mk_cycle()
        r = self.admin.post(f"{API}/self-reviews/", {
            "employee_code": self.amit.employee_code, "cycle": c["id"],
            "summary": "  ", "status": "Submitted"}, format="json")
        self.assertEqual(r.status_code, 400)

    def test_pip_crud_complete(self):
        r = self.admin.post(f"{API}/pips/", {
            "employee_code": self.stranger.employee_code, "reason": "Missed deadlines",
            "coaching_plan": "Weekly coaching", "start_date": "2026-09-01",
            "end_date": "2026-11-30"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        pid = r.json()["data"]["id"]
        self.assertEqual(r.json()["data"]["status"], "Active")
        r = self.admin.post(f"{API}/pips/{pid}/complete/", {"outcome": "Improved"}, format="json")
        self.assertEqual(r.json()["data"]["status"], "Completed")
        self.assertEqual(self.admin.post(f"{API}/pips/{pid}/complete/").status_code, 409)
        self.assertEqual(self.admin.get(f"{API}/pips/?status=Completed").json()["data"]["count"], 1)
        self.assertEqual(self.admin.delete(f"{API}/pips/{pid}/").status_code, 200)


class RatingHistoryTests(PerfBase):

    def test_manual_crud_and_bell_curve(self):
        c = self.mk_cycle()
        rows = [(self.rahul, 5.0), (self.amit, 4.2), (self.priya, 4.6), (self.hr, 3.1),
                (self.viewer, 2.4)]
        for emp, rating in rows:
            r = self.admin.post(f"{API}/rating-history/", {
                "employee_code": emp.employee_code, "cycle": c["id"], "rating": rating},
                format="json")
            self.assertEqual(r.status_code, 201, r.json())
            self.assertEqual(r.json()["data"]["source"], "manual")
            self.assertEqual(r.json()["data"]["period_label"], "H1 2026")

        dup = self.admin.post(f"{API}/rating-history/", {
            "employee_code": self.rahul.employee_code, "cycle": c["id"], "rating": 4.0},
            format="json")
        self.assertEqual(dup.status_code, 409)

        d = self.admin.get(f"{API}/rating-history/distribution/").json()["data"]
        by = {x["rating"]: x for x in d["distribution"]}
        self.assertEqual(d["total_rated"], 5)
        self.assertEqual((by[5]["count"], by[4]["count"], by[3]["count"], by[2]["count"]),
                         (1, 2, 1, 1))
        self.assertEqual(by[4]["percent"], 40.0)
        self.assertEqual(by[4]["title"], "Rating 4 (Exceeds)")
        self.assertEqual(by[4]["reference_percent"], 55)
        self.assertEqual(len(d["history"]), 5)

        rid = d["history"][0]["id"]
        r = self.admin.patch(f"{API}/rating-history/{rid}/", {"rating": 1.5}, format="json")
        self.assertEqual(r.json()["data"]["rating_bucket"], 1)
        self.assertEqual(self.admin.delete(f"{API}/rating-history/{rid}/").status_code, 200)
        self.assertEqual(self.admin.get(f"{API}/rating-history/?rating_bucket=5"
                                        ).json()["data"]["count"], 1)

    def test_distribution_latest_per_employee(self):
        c1 = self.mk_cycle("Annual FY25", financial_year="2025-26", submission_deadline="2026-03-31")
        c2 = self.mk_cycle("Mid-Year FY26", financial_year="2026-27")
        for cyc, rating in ((c1, 3.0), (c2, 4.0)):
            self.admin.post(f"{API}/rating-history/", {
                "employee_code": self.rahul.employee_code, "cycle": cyc["id"], "rating": rating},
                format="json")
        d = self.admin.get(f"{API}/rating-history/distribution/").json()["data"]
        self.assertEqual(d["total_rated"], 1)          # latest rating only
        d = self.admin.get(f"{API}/rating-history/distribution/?financial_year=2025-26").json()["data"]
        by = {x["rating"]: x["count"] for x in d["distribution"]}
        self.assertEqual(by[3], 1)


class EmployeeSelfServiceTests(PerfBase):

    def test_own_goals_only(self):
        r = self.rahul_c.post(f"{ME}/goals/", {"title": "Learn Rust",
                                               "employee_code": self.amit.employee_code},
                              format="json")
        self.assertEqual(r.status_code, 201, r.json())
        g = r.json()["data"]
        self.assertEqual(g["employee_code"], self.rahul.employee_code)   # forced to ME
        self.assertTrue(g["created_at"])
        self.assertEqual(PerfGoal.objects.get().created_by, f"employee:{self.rahul.employee_code}")

        self.assertEqual(self.amit_c.get(f"{ME}/goals/").json()["data"]["count"], 0)
        self.assertEqual(self.amit_c.get(f"{ME}/goals/{g['id']}/").status_code, 404)
        self.assertEqual(self.rahul_c.get(f"{ME}/goals/").json()["data"]["count"], 1)

        r = self.rahul_c.post(f"{ME}/goals/{g['id']}/progress/", {"progress_percent": 60},
                              format="json")
        self.assertEqual(r.json()["data"]["status"], "In Progress")
        r = self.rahul_c.patch(f"{ME}/goals/{g['id']}/", {"title": "Learn Rust 2"}, format="json")
        self.assertEqual(r.json()["data"]["title"], "Learn Rust 2")
        self.assertEqual(self.rahul_c.delete(f"{ME}/goals/{g['id']}/").status_code, 200)

    def test_self_review_flow_and_lock(self):
        c = self.mk_cycle(status="Active")
        a = self.mk_appraisal(self.rahul, c["id"])
        cyc = self.rahul_c.get(f"{ME}/review-cycles/").json()["data"]["results"][0]
        self.assertTrue(cyc["eligible"])
        self.assertEqual(cyc["my_appraisal_id"], a["id"])

        r = self.rahul_c.post(f"{ME}/self-reviews/", {"cycle": c["id"], "summary": "Draft v1",
                                                      "self_score": 4.5}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        sid = r.json()["data"]["id"]
        self.assertEqual(self.rahul_c.patch(f"{ME}/self-reviews/{sid}/",
                                            {"summary": "Draft v2"}, format="json").status_code, 200)
        r = self.rahul_c.post(f"{ME}/self-reviews/{sid}/submit/")
        self.assertEqual(r.json()["data"]["status"], "Submitted")
        self.assertEqual(self.rahul_c.patch(f"{ME}/self-reviews/{sid}/",
                                            {"summary": "late"}, format="json").status_code, 409)
        self.assertEqual(self.rahul_c.delete(f"{ME}/self-reviews/{sid}/").status_code, 409)
        self.assertEqual(self.rahul_c.get(f"{ME}/appraisals/").json()["data"]["results"][0]
                         ["status"], "Pending Manager Review")
        self.assertEqual(self.amit_c.get(f"{ME}/self-reviews/").json()["data"]["count"], 0)

    def test_employee_cannot_write_appraisals_or_history(self):
        c = self.mk_cycle()
        a = self.mk_appraisal(self.rahul, c["id"])
        self.assertEqual(self.rahul_c.post(f"{ME}/appraisals/", {}, format="json").status_code, 405)
        self.assertEqual(self.rahul_c.patch(f"{ME}/appraisals/{a['id']}/",
                                            {"manager_score": 5}, format="json").status_code, 405)
        self.assertEqual(self.rahul_c.post(f"{ME}/rating-history/", {}, format="json").status_code, 405)

    def test_feedback_only_when_shared(self):
        body = {"employee_code": self.rahul.employee_code, "manager_code": self.amit.employee_code,
                "feedback": "Great work."}
        self.admin.post(f"{API}/manager-feedback/", body, format="json")
        self.assertEqual(self.rahul_c.get(f"{ME}/feedback/").json()["data"]["count"], 0)
        self.admin.post(f"{API}/manager-feedback/", {**body, "feedback": "Shared",
                                                     "visible_to_employee": True}, format="json")
        res = self.rahul_c.get(f"{ME}/feedback/").json()["data"]
        self.assertEqual(res["count"], 1)
        self.assertEqual(res["results"][0]["feedback"], "Shared")

    def test_manager_team_flow(self):
        c = self.mk_cycle(status="Active")
        a = self.mk_appraisal(self.rahul, c["id"])
        self.rahul_c.post(f"{ME}/goals/", {"title": "G", "progress_percent": 50}, format="json")

        team = self.amit_c.get(f"{ME}/team/").json()["data"]
        self.assertEqual([r["employee"]["name"] for r in team["results"]], ["Rahul"])
        self.assertEqual(team["results"][0]["goal_progress_average"], 50.0)
        self.assertEqual(self.amit_c.get(f"{ME}/team/goals/").json()["data"]["count"], 1)
        self.assertEqual(self.stranger_c.get(f"{ME}/team/").json()["data"]["count"], 0)
        self.assertEqual(self.stranger_c.get(f"{ME}/team/goals/").json()["data"]["count"], 0)

        # manager review
        r = self.amit_c.post(f"{ME}/team/appraisals/{a['id']}/manager-review/", {
            "manager_score": 4.8, "manager_comments": "Strong year", "potential": "High",
            "promotion_proposed": True, "proposed_level": "L4",
            "status": "Completed", "normalized_rating": 1}, format="json")
        self.assertEqual(r.status_code, 200, r.json())
        d = r.json()["data"]
        self.assertEqual(d["status"], "Calibration")            # cannot self-complete
        self.assertEqual(d["normalized_rating"], 4.8)           # cannot calibrate
        self.assertEqual(d["reviewer_code"], self.amit.employee_code)
        self.assertEqual(self.stranger_c.post(
            f"{ME}/team/appraisals/{a['id']}/manager-review/",
            {"manager_score": 1}, format="json").status_code, 404)

        # feedback
        r = self.amit_c.post(f"{ME}/team/feedback/", {
            "employee_code": self.rahul.employee_code, "feedback": "Keep going",
            "visible_to_employee": True}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        fid = r.json()["data"]["id"]
        self.assertEqual(r.json()["data"]["manager_code"], self.amit.employee_code)
        r = self.amit_c.post(f"{ME}/team/feedback/", {
            "employee_code": self.stranger.employee_code, "feedback": "no"}, format="json")
        self.assertEqual(r.status_code, 403)
        self.assertEqual(self.amit_c.patch(f"{ME}/team/feedback/{fid}/",
                                           {"feedback": "Edited"}, format="json"
                                           ).json()["data"]["feedback"], "Edited")
        self.assertEqual(self.stranger_c.get(f"{ME}/team/feedback/{fid}/").status_code, 404)
        self.assertEqual(self.amit_c.delete(f"{ME}/team/feedback/{fid}/").status_code, 200)

    def test_dashboard(self):
        c = self.mk_cycle(status="Active")
        a = self.mk_appraisal(self.rahul, c["id"], manager_score=4.8)
        self.admin.post(f"{API}/appraisals/{a['id']}/complete/", {}, format="json")
        self.rahul_c.post(f"{ME}/goals/", {"title": "G", "progress_percent": 40}, format="json")
        d = self.rahul_c.get(f"{ME}/dashboard/").json()["data"]
        self.assertEqual(d["latest_rating"]["badge"], "4.8 - Exceeds Expectations")
        self.assertEqual(d["goals"]["open"], 1)
        self.assertFalse(d["is_manager"])
        self.assertTrue(self.amit_c.get(f"{ME}/dashboard/").json()["data"]["is_manager"])
