# python manage.py test Training
from datetime import timedelta

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase, override_settings
from django.utils import timezone
from rest_framework.test import APIClient

from Company.models import company_details
from Employee.leave_models import ReportingHierarchy
from Employee.models import Department, EmployeeDT, EmployeeRole
from Training.models import TrainingEnrollment

MEDIA = override_settings(MEDIA_ROOT="/tmp/training_test_media")


def mk_company(email):
    return company_details.objects.create(email=email, password="x", contact_no=str(abs(hash(email)))[:10],
                                          Registered_Company_Name="Zenith Corp", Company_address="Pune")


def client(user):
    c = APIClient()
    c.force_authenticate(user=user)
    return c


def mk_emp(co, name, dept=None, **kw):
    e = EmployeeDT(company=co, name=name, email=f"{name.split()[0].lower()}@x.com", Employee_Status="Activate", is_active=True,
                   department=dept, Department=dept.name if dept else None, **kw)
    e.save()
    return e


@MEDIA
class TrainingTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("t1@x.com"), mk_company("t2@x.com")
        self.a = client(self.co)
        self.dept = Department.objects.create(company=self.co, name="Technology & Engineering")
        self.boss = mk_emp(self.co, "Boss Man", self.dept)
        self.rahul = mk_emp(self.co, "Rahul Sharma", self.dept)
        self.neha = mk_emp(self.co, "Neha Deshmukh", self.dept)
        self.vik = mk_emp(self.co, "Vikram Rao", self.dept)
        for e in (self.rahul, self.neha, self.vik):
            ReportingHierarchy.objects.create(company=self.co, Employee_ID=e.employee_code, manager_code=self.boss.employee_code, hod_code=self.boss.employee_code)
        self.P = lambda u, d=None, f="json": self.a.post(u, d or {}, format=f)
        t = timezone.localdate()
        self.k8s = self.j(self.P("/api/training/programs/", {
            "title": "Cloud Native Architecture & Kubernetes", "category": "Technical", "trainer_name": "External Specialist",
            "duration_hours": 16, "audience_label": "Engineers", "start_date": str(t - timedelta(days=2)), "end_date": str(t + timedelta(days=5)),
            "certificate_title": "Kubernetes Master Certificate", "pass_attendance_percent": 50, "is_mandatory": True,
            "skill_level_awarded": 4, "skills": ["Kubernetes & Microservices"] if False else []}), 201)["data"]
        self.sec = self.j(self.P("/api/training/programs/", {"title": "Enterprise Security & Threat Modeling", "trainer_name": "SecOps Lead",
                          "duration_hours": 8, "category": "Technical", "start_date": str(t + timedelta(days=20))}), 201)["data"]

    def j(self, r, code=None):
        if code:
            self.assertEqual(r.status_code, code, r.content)
        return r.json()

    # ---------- programs + dashboard ----------
    def test_programs_dashboard(self):
        self.assertEqual((self.k8s["code"], self.sec["code"]), ("TRN-01", "TRN-02"))
        self.assertEqual(self.k8s["status"], "Upcoming")
        lst = self.j(self.a.get("/api/training/programs/"), 200)["data"]               # list auto-moves Upcoming -> Ongoing
        self.assertEqual({r["code"]: r["status"] for r in lst}, {"TRN-01": "Ongoing", "TRN-02": "Upcoming"})
        self.assertEqual(self.P("/api/training/programs/", {"title": "x", "code": "TRN-01"}).status_code, 400)
        self.assertEqual(self.P("/api/training/programs/", {"title": "x", "start_date": "2026-05-02", "end_date": "2026-05-01"}).status_code, 400)
        r = self.j(self.a.patch(f"/api/training/programs/{self.sec['id']}/", {"capacity": 30, "duration_hours": 10}, format="json"), 200)["data"]
        self.assertEqual((r["capacity"], r["duration_label"]), (30, "10 Hours"))
        d = self.j(self.a.get("/api/training/dashboard/"), 200)["data"]
        self.assertEqual(d["kpis"]["active_courses"]["value"], 2)
        self.assertEqual(d["kpis"]["certificates_issued"]["value"], 0)
        self.assertEqual(len(d["catalog"]), 2)
        self.assertEqual(self.j(self.a.get("/api/training/meta/"), 200)["data"]["tabs"][-1], "skill-matrix")

    # ---------- full life-cycle ----------
    def test_enroll_attend_complete_certificate(self):
        a, P, pid = self.a, self.P, self.k8s["id"]
        t = timezone.localdate()
        en = self.j(P(f"/api/training/programs/{pid}/enroll/", {"employee_codes": [self.rahul.employee_code, self.neha.employee_code, "NOPE"]}), 201)["data"]
        self.assertEqual((len(en["enrollments"]), len(en["skipped"])), (2, 1))
        again = self.j(P(f"/api/training/programs/{pid}/enroll/", {"employee_codes": [self.rahul.employee_code]}), 200)["data"]
        self.assertEqual(len(again["skipped"]), 1)
        self.assertEqual(self.j(a.get("/api/training/programs/"))["data"][0]["enrolled_label"], "2 Engineers")
        s1 = self.j(P("/api/training/sessions/", {"program": "TRN-01", "title": "Cloud Native Architecture Workshop", "session_date": str(t - timedelta(days=1)),
                       "start_time": "10:00", "end_time": "02:00 PM", "location": "Pune Tech HQ Lab 2"}), 201)["data"]
        self.assertEqual(s1["hours"], 4.0)
        self.assertIn("10:00 AM - 2:00 PM", s1["label"])
        self.assertEqual(P("/api/training/sessions/", {"program": 999, "session_date": str(t)}).status_code, 400)
        self.assertEqual(P("/api/training/sessions/", {"program": pid, "session_date": str(t), "start_time": "11:00", "end_time": "10:00"}).status_code, 400)
        s2 = self.j(P("/api/training/sessions/", {"program": pid, "title": "Day 2", "session_date": str(t), "start_time": "10:00", "end_time": "14:00"}), 201)["data"]
        sheet = self.j(a.get(f"/api/training/sessions/{s1['id']}/attendance/"), 200)["data"]
        self.assertEqual((sheet["total"], sheet["marked"]), (2, 0))
        m = self.j(P(f"/api/training/sessions/{s1['id']}/mark-attendance/", {"records": [
            {"employee_code": self.rahul.employee_code, "status": "Present"}, {"employee_code": self.neha.employee_code, "status": "Absent"},
            {"employee_code": self.vik.employee_code, "status": "Present"}]}), 200)["data"]
        self.assertEqual((m["saved"], len(m["errors"])), (2, 1))
        self.j(P(f"/api/training/sessions/{s2['id']}/mark-attendance/", {"mark_all": "Present"}), 200)
        summ = self.j(a.get("/api/training/attendance/summary/"), 200)["data"]
        self.assertEqual(summ["average_attendance_percent"], 75)                   # 3 present of 4
        self.assertEqual(self.j(a.get("/api/training/attendance/summary/?mandatory=true"))["data"]["average_attendance_percent"], 75)
        recs = self.j(a.get(f"/api/training/attendance/?employee={self.rahul.employee_code}"))["data"]
        self.assertEqual(len(recs), 2)
        self.j(a.patch(f"/api/training/attendance/{recs[0]['id']}/", {"status": "Late", "remarks": "Traffic"}, format="json"), 200)
        enr = [e for e in self.j(a.get(f"/api/training/programs/{pid}/enrollments/"))["data"]]
        rahul_e = [e for e in enr if e["employee"]["employee_code"] == self.rahul.employee_code][0]
        neha_e = [e for e in enr if e["employee"]["employee_code"] == self.neha.employee_code][0]
        self.assertEqual(rahul_e["attendance_percent"], 100.0)
        self.assertEqual(neha_e["attendance_percent"], 50.0)
        # certificate before completion is blocked, then complete + auto certificate
        self.assertEqual(P("/api/training/certificates/", {"enrollment_id": rahul_e["id"]}).status_code, 400)
        c = self.j(P(f"/api/training/enrollments/{rahul_e['id']}/complete/", {"score": 91}), 200)["data"]
        self.assertEqual(c["certificate"]["title"], "Kubernetes Master Certificate")
        self.assertTrue(c["certificate"]["certificate_no"].startswith("CERT-"))
        cid = c["certificate"]["id"]
        dl = a.get(f"/api/training/certificates/{cid}/download/")
        self.assertEqual(dl.status_code, 200)
        self.assertTrue(b"".join(dl.streaming_content).startswith(b"%PDF"))
        v = self.j(APIClient().get(f"/api/training/certificates/verify/{c['certificate']['verification_code']}/"), 200)["data"]
        self.assertEqual((v["valid"], v["holder"]), (True, "Rahul Sharma"))
        self.assertEqual(self.j(P(f"/api/training/certificates/", {"enrollment_id": rahul_e["id"]}), 200)["code"], "CERTIFICATE_EXISTS")
        self.j(P(f"/api/training/certificates/{cid}/revoke/"), 200)
        self.assertFalse(self.j(APIClient().get(f"/api/training/certificates/verify/{c['certificate']['verification_code']}/"), 200)["data"]["valid"])
        self.assertEqual(APIClient().get("/api/training/certificates/verify/ZZZ/").status_code, 404)
        self.j(P(f"/api/training/certificates/{cid}/regenerate/"), 200)
        d = self.j(a.get("/api/training/dashboard/"))["data"]["kpis"]
        self.assertEqual(d["certificates_issued"]["value"], 0)                      # revoked one not counted
        self.assertEqual(d["training_hours_logged"]["value"], 12.0)                  # rahul 8 + vik n/a ... present hours: r(4+4)+... see below
        # low attendance enrolment needs force
        self.assertEqual(self.j(P(f"/api/training/enrollments/{neha_e['id']}/complete/"), 400)["code"], "NOT_ELIGIBLE") if False else None
        # program complete: neha at 50% meets pass 50 -> completes too
        pc = self.j(P(f"/api/training/programs/{pid}/complete/"), 200)["data"]
        self.assertEqual(pc["program"]["status"], "Completed")
        # skill raised by completion (program has no skills linked -> nothing), external certificate upload
        ext = self.j(P("/api/training/certificates/", {"employee_code": self.vik.employee_code, "title": "AWS SAA", "issuer_name": "Amazon", "is_external": "true",
                       "file": SimpleUploadedFile("aws.pdf", b"%PDF-1.4 x", content_type="application/pdf")}, "multipart"), 201)["data"]
        self.assertTrue(ext["is_external"])
        self.assertEqual(self.P(f"/api/training/certificates/{ext['id']}/regenerate/").status_code, 409)
        self.assertEqual(len(self.j(a.get(f"/api/training/certificates/?employee={self.vik.employee_code}"))["data"]), 1)
        self.j(a.patch(f"/api/training/certificates/{ext['id']}/", {"title": "AWS Solutions Architect"}, format="json"), 200)
        self.j(a.delete(f"/api/training/certificates/{ext['id']}/"), 200)

    # ---------- calendar ----------
    def test_calendar_ics(self):
        t = timezone.localdate()
        s = self.j(self.P("/api/training/sessions/", {"program": self.sec["id"], "title": "Threat Modeling Lab", "session_date": str(t + timedelta(days=21)),
                          "start_time": "10:00", "end_time": "13:00", "location": "Lab 1"}), 201)["data"]
        cal = self.j(self.a.get("/api/training/calendar/"), 200)["data"]
        self.assertEqual(cal[0]["title"], "Threat Modeling Lab")
        ics = self.a.get(s["ics_url"])
        self.assertEqual(ics.status_code, 200)
        self.assertIn("BEGIN:VEVENT", ics.content.decode())
        self.assertEqual(len(self.j(self.a.get(f"/api/training/calendar/?month={(t + timedelta(days=21)).month}&year={(t + timedelta(days=21)).year}"))["data"]), 1)
        self.j(self.P(f"/api/training/sessions/{s['id']}/cancel/"), 200)
        self.assertEqual(len(self.j(self.a.get("/api/training/calendar/"))["data"]), 0)

    # ---------- enrollment / nominations / employee side ----------
    def test_nominations_employee_and_manager_side(self):
        a, pid = self.a, self.sec["id"]
        me, boss = client(EmployeeDT.objects.get(pk=self.rahul.pk)), client(EmployeeDT.objects.get(pk=self.boss.pk))
        cat = self.j(me.get("/employee/training/programs/"), 200)["data"]
        self.assertTrue([c for c in cat if c["code"] == "TRN-02"][0]["can_nominate"])
        n = self.j(me.post(f"/employee/training/programs/{pid}/nominate/", {"reason": "Need for project"}, format="json"), 201)["data"]
        self.assertEqual((n["status"], n["approver_code"]), ("Pending", self.boss.employee_code))
        self.assertEqual(me.post(f"/employee/training/programs/{pid}/nominate/", {}, format="json").status_code, 409)
        ps = self.j(a.get("/api/training/enrollments/pending-summary/"), 200)["data"]
        self.assertEqual(ps["messages"], ["1 nomination pending approval from Technology & Engineering department."])
        # not my queue
        self.assertEqual(client(EmployeeDT.objects.get(pk=self.neha.pk)).post(f"/employee/training/approvals/{n['id']}/approve/", {}, format="json").status_code, 404)
        q = self.j(boss.get("/employee/training/approvals/pending/"), 200)["data"]
        self.assertEqual(len(q), 1)
        self.assertEqual(boss.post(f"/employee/training/approvals/{n['id']}/reject/", {}, format="json").status_code, 400)
        self.j(boss.post(f"/employee/training/approvals/{n['id']}/approve/", {"remarks": "ok"}, format="json"), 200)
        mine = self.j(me.get("/employee/training/enrollments/"), 200)["data"]
        self.assertEqual(mine[0]["status"], "Enrolled")
        self.j(me.post(f"/employee/training/enrollments/{n['id']}/feedback/", {"rating": 4.5, "comment": "great"}, format="json"), 200)
        self.assertEqual(me.post(f"/employee/training/enrollments/{n['id']}/feedback/", {"rating": 9}, format="json").status_code, 400)
        dash = self.j(self.a.get("/api/training/dashboard/"))["data"]["kpis"]["average_satisfaction"]
        self.assertEqual(dash["display"], "4.5 / 5.0")
        # manager nominates a direct report; HR bulk approve; admin reject
        self.j(boss.post("/employee/training/team/nominate/", {"program": pid, "employee_code": self.neha.employee_code}, format="json"), 201)
        self.assertEqual(boss.post("/employee/training/team/nominate/", {"program": pid, "employee_code": self.boss.employee_code}, format="json").status_code, 403)
        self.assertEqual(len(self.j(boss.get("/employee/training/team/"))["data"]), 2)
        nv = client(EmployeeDT.objects.get(pk=self.vik.pk)).post(f"/employee/training/programs/{pid}/nominate/", {}, format="json").json()["data"]
        ba = self.j(self.P("/api/training/enrollments/bulk-approve/", {"ids": [nv["id"], 9999]}), 200)["data"]
        self.assertEqual((len(ba["approved"]), len(ba["failed"])), (1, 1))
        # capacity
        self.a.patch(f"/api/training/programs/{pid}/", {"capacity": 3}, format="json")
        extra = mk_emp(self.co, "Extra Person", self.dept)
        self.assertEqual(self.P("/api/training/enrollments/", {"program": pid, "employee_code": extra.employee_code}).status_code, 400)
        # withdraw
        self.j(me.delete(f"/employee/training/enrollments/{n['id']}/"), 200)
        self.assertEqual(TrainingEnrollment.objects.get(pk=n["id"]).status, "Dropped")
        # admin CRUD
        e = self.j(self.P("/api/training/enrollments/", {"program": "TRN-02", "employee_code": extra.employee_code, "require_approval": True}), 201)["data"]
        self.j(a.patch(f"/api/training/enrollments/{e['id']}/", {"reason": "x"}, format="json"), 200)
        self.assertEqual(self.P(f"/api/training/enrollments/{e['id']}/reject/").status_code, 400)
        self.j(self.P(f"/api/training/enrollments/{e['id']}/reject/", {"remarks": "no budget"}), 200)
        self.j(a.delete(f"/api/training/enrollments/{e['id']}/"), 200)
        self.assertEqual(a.get(f"/api/training/enrollments/{e['id']}/").status_code, 404)

    # ---------- skills ----------
    def test_skill_matrix(self):
        a, P = self.a, self.P
        react = self.j(P("/api/training/skills/", {"domain": "React & Modern Vanilla JS", "target_level": 4, "category": "Engineering"}), 201)["data"]
        k8 = self.j(P("/api/training/skills/", {"domain": "Kubernetes & Microservices", "target_level": 4}), 201)["data"]
        self.assertEqual(P("/api/training/skills/", {"domain": "react & modern vanilla js"}).status_code, 400)
        self.assertEqual(P("/api/training/skills/", {"domain": "Bad", "target_level": 9}).status_code, 400)
        self.assertEqual(k8["proficiency_target"], "Level 4 Expert")
        self.assertEqual(react["gap_level"], "Critical")                               # nobody qualified yet
        self.j(P(f"/api/training/skills/{react['id']}/assess/", {"ratings": [
            {"employee_code": self.rahul.employee_code, "level": 4}, {"employee_code": self.neha.employee_code, "level": 4},
            {"employee_code": self.vik.employee_code, "level": 4}, {"employee_code": self.boss.employee_code, "level": 3},
            {"employee_code": "BAD", "level": 1}]}), 200)
        es = self.j(P("/api/training/employee-skills/", {"employee_code": self.boss.employee_code, "skill": "React & Modern Vanilla JS", "current_level": 4}), 200)["data"]
        self.assertTrue(es["meets_target"])
        m = self.j(a.get("/api/training/skills/matrix/"), 200)["data"]
        row = [r for r in m["rows"] if r["domain"].startswith("React")][0]
        self.assertEqual((row["current_bench_strength"], row["gap_level"], row["proficiency_target"]), ("100% Compliant", "Optimal", "Level 4 Expert"))
        self.j(a.patch(f"/api/training/skills/{k8['id']}/", {"gap_level_override": "Upskilling"}, format="json"), 200)
        self.assertEqual(self.j(a.get(f"/api/training/skills/{k8['id']}/"))["data"]["gap_level"], "Upskilling")
        emps = self.j(a.get(f"/api/training/skills/{k8['id']}/employees/?below_target=true"), 200)["data"]["employees"]
        self.assertEqual(len(emps), 4)
        # completing a linked program raises the level automatically
        pr = self.j(P("/api/training/programs/", {"title": "K8s Bootcamp", "skills": [k8["id"]], "skill_level_awarded": 4, "pass_attendance_percent": 0}), 201)["data"]
        self.assertEqual(pr["skills"][0]["domain"], "Kubernetes & Microservices")
        en = self.j(P(f"/api/training/programs/{pr['id']}/enroll/", {"employee_codes": [self.rahul.employee_code]}), 201)["data"]["enrollments"][0]
        self.j(P(f"/api/training/enrollments/{en['id']}/complete/"), 200)
        lv = self.j(a.get(f"/api/training/employee-skills/?employee={self.rahul.employee_code}&skill={k8['id']}"))["data"][0]
        self.assertEqual((lv["current_level"], lv["source"]), (4, "Training"))
        self.assertEqual(len(self.j(a.get("/api/training/employee-skills/?below_target=true"))["data"]), 0)
        # employee self assessment
        me = client(EmployeeDT.objects.get(pk=self.vik.pk))
        self.j(me.post("/employee/training/skills/", {"skill": k8["id"], "level": 2}, format="json"), 200)
        self.assertEqual(me.post("/employee/training/skills/", {"skill": k8["id"], "level": 7}, format="json").status_code, 400)
        mine = self.j(me.get("/employee/training/skills/"), 200)["data"]
        self.assertEqual([r["gap"] for r in mine if r["skill"]["id"] == k8["id"]], [2])
        self.assertEqual([p["code"] for r in mine if r["skill"]["id"] == k8["id"] for p in r["recommended_programs"]], ["TRN-03"])
        # CRUD end
        self.j(a.delete(f"/api/training/skills/{react['id']}/"), 200)
        self.assertEqual(a.get(f"/api/training/skills/{react['id']}/").status_code, 404)

    # ---------- permissions + isolation ----------
    def test_permissions_and_isolation(self):
        b = client(self.other)
        self.assertEqual(self.j(b.get("/api/training/programs/"), 200)["data"], [])
        self.assertEqual(b.get(f"/api/training/programs/{self.k8s['id']}/").status_code, 404)
        self.assertEqual(b.post(f"/api/training/programs/{self.k8s['id']}/enroll/", {"employee_codes": ["X"]}, format="json").status_code, 404)
        emp = EmployeeDT.objects.get(pk=self.rahul.pk)
        emp.role = None
        self.assertEqual(client(emp).get("/api/training/programs/").status_code, 403)       # plain employee cannot use admin API
        role = EmployeeRole.objects.create(company=self.co, role_name="HR", role_code="hr", can_view_employees=True)
        emp.role = role
        hr = client(emp)
        self.assertEqual(hr.get("/api/training/programs/").status_code, 200)
        self.assertEqual(hr.post("/api/training/programs/", {"title": "T"}, format="json").status_code, 403)
        role.can_manage_employees = True
        emp.role = role
        self.assertEqual(client(emp).post("/api/training/programs/", {"title": "HR made"}, format="json").status_code, 201)
        self.assertEqual(APIClient().get("/api/training/dashboard/").status_code, 401)
        self.assertEqual(APIClient().get("/employee/training/dashboard/").status_code, 401)
        self.assertEqual(self.a.get("/employee/training/dashboard/").status_code, 403)       # company token on employee API
        d = self.j(client(EmployeeDT.objects.get(pk=self.rahul.pk)).get("/employee/training/dashboard/"), 200)["data"]
        self.assertEqual([x["code"] for x in d["mandatory_pending"]], ["TRN-01"])             # mandatory + not yet enrolled -> shown to employee
