# ============================================================
# EMPLOYEE SIDE (self-service)   /employee/training/
# Auth: Employee JWT. An employee sees / changes only their OWN data.
# Managers / HODs (as per Employee.ReportingHierarchy) additionally get an approvals queue
# for nominations of the people reporting to them.
# ============================================================
from decimal import Decimal

from django.db.models import Sum
from django.http import FileResponse, Http404, HttpResponse
from django.utils import timezone
from rest_framework.views import APIView

from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated
from Employee.employee_crud_permissions import actor_label
from Employee.leave_models import ReportingHierarchy
from People.common import (emp_brief, err, iso, ok, paginate, to_bool, to_decimal)

from .certs import session_ics
from .common import (attendance_percent, cert_row, enrollment_row, enrolled_count, level_label, program_row, resolve_approver,
                     session_row, sync_program_status)
from .models import (EmployeeSkill, TrainingAttendance, TrainingCertificate, TrainingEnrollment, TrainingProgram,
                     TrainingSession, TrainingSkill)
from .views_enrollments import seats_full


class SelfBase(APIView):
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

    @property
    def me(self):
        return self.request.user

    @property
    def company(self):
        return self.request.user.company

    def mine(self):
        return TrainingEnrollment.objects.filter(company=self.company, employee=self.me, is_active=True) \
            .select_related("program", "employee", "employee__department")


class MyDashboard(SelfBase):
    """GET /employee/training/dashboard/"""

    def get(self, request):
        sync_program_status(self.company)
        mine = self.mine()
        year = timezone.localdate().year
        hours = TrainingAttendance.objects.filter(enrollment__employee=self.me, is_active=True, status__in=["Present", "Late"],
                                                  session__session_date__year=year).aggregate(s=Sum("hours_attended"))["s"] or Decimal("0")
        enrolled_ids = mine.filter(status="Enrolled").values_list("program_id", flat=True)
        upcoming = TrainingSession.objects.filter(program_id__in=enrolled_ids, is_active=True, status="Scheduled",
                                                  session_date__gte=timezone.localdate()).select_related("program")[:5]
        certs = TrainingCertificate.objects.filter(employee=self.me, is_active=True, status="Issued")
        return ok("MY_TRAINING_DASHBOARD", "My training dashboard.", {
            "hours_logged": float(hours), "hours_display": f"{float(hours):,.0f} Hrs", "year": year,
            "enrolled_programs": mine.filter(status="Enrolled").count(), "completed_programs": mine.filter(status="Completed").count(),
            "pending_nominations": mine.filter(status="Pending").count(), "certificates": certs.count(),
            "upcoming_sessions": [session_row(s) for s in upcoming],
            "mandatory_pending": [program_row(p, request, brief=True) for p in
                                  TrainingProgram.objects.filter(company=self.company, is_active=True, is_mandatory=True, status__in=["Upcoming", "Ongoing"])
                                  .exclude(enrollments__employee=self.me, enrollments__is_active=True, enrollments__status__in=["Enrolled", "Completed", "Pending"])],
        })


class MyPrograms(SelfBase):
    """GET /employee/training/programs/  ?status= ?search= ?category=   (catalog + my enrollment state)"""

    def get(self, request):
        sync_program_status(self.company)
        p = request.query_params
        qs = TrainingProgram.objects.filter(company=self.company, is_active=True).exclude(status__in=["Draft", "Cancelled"])
        if p.get("status"):
            qs = qs.filter(status=p["status"])
        if p.get("category"):
            qs = qs.filter(category__iexact=p["category"])
        if p.get("search"):
            qs = qs.filter(title__icontains=p["search"])
        mine = {e.program_id: e for e in self.mine().exclude(status__in=["Rejected", "Dropped", "Cancelled"])}

        def build(pr):
            row = program_row(pr, request, brief=True)
            e = mine.get(pr.id)
            row["my_status"] = e.status if e else None
            row["my_enrollment_id"] = e.id if e else None
            row["can_nominate"] = e is None and pr.status in ("Upcoming", "Ongoing") and not seats_full(pr)
            return row
        rows, meta = paginate(request, qs, build)
        return ok("MY_PROGRAMS", "Training catalog.", rows, meta=meta)


class MyProgramDetail(SelfBase):
    """GET /employee/training/programs/<id>/"""

    def get(self, request, pk):
        pr = TrainingProgram.objects.filter(company=self.company, pk=pk, is_active=True).exclude(status="Draft").first()
        if pr is None:
            return err("NOT_FOUND", "Program not found.", 404)
        row = program_row(pr, request)
        row["sessions"] = [session_row(s) for s in pr.sessions.filter(is_active=True).exclude(status="Cancelled").select_related("program")]
        e = self.mine().filter(program=pr).exclude(status__in=["Rejected", "Dropped", "Cancelled"]).first()
        row["my_enrollment"] = enrollment_row(e, request) if e else None
        return ok("MY_PROGRAM_DETAIL", "Program detail.", row)


class MyNominate(SelfBase):
    """POST /employee/training/programs/<id>/nominate/  {reason?}  -> goes to your HOD/manager for approval"""

    def post(self, request, pk):
        pr = TrainingProgram.objects.filter(company=self.company, pk=pk, is_active=True).first()
        if pr is None:
            return err("NOT_FOUND", "Program not found.", 404)
        if pr.status not in ("Upcoming", "Ongoing"):
            return err("INVALID_STATE", f"Program is {pr.status.lower()}; nominations are closed.", 409)
        if self.mine().filter(program=pr, status__in=["Pending", "Enrolled", "Completed"]).exists():
            return err("EXISTS", "You already have an active nomination/enrollment for this program.", 409)
        if seats_full(pr):
            return err("PROGRAM_FULL", "Program is full.", 409)
        approver = resolve_approver(self.company, self.me)
        e = TrainingEnrollment.objects.create(company=self.company, program=pr, employee=self.me, status="Pending", source="Self",
                                              nominated_by=actor_label(self.me), reason=request.data.get("reason"),
                                              approver_code=approver, created_by=actor_label(self.me), updated_by=actor_label(self.me))
        return ok("NOMINATED", "Nomination sent for approval." if approver else "Nomination sent to HR for approval.", enrollment_row(e, request), 201)


class MyEnrollments(SelfBase):
    """GET /employee/training/enrollments/ ?status="""

    def get(self, request):
        qs = self.mine()
        if request.query_params.get("status"):
            qs = qs.filter(status=request.query_params["status"])
        return ok("MY_ENROLLMENTS", "My enrollments.", [enrollment_row(e, request) for e in qs])


class MyEnrollmentDetail(SelfBase):
    """GET /employee/training/enrollments/<id>/ | DELETE = withdraw (Pending) / drop (Enrolled)"""

    def _e(self, pk):
        return self.mine().filter(pk=pk).first()

    def get(self, request, pk):
        e = self._e(pk)
        return ok("MY_ENROLLMENT", "Enrollment.", enrollment_row(e, request)) if e else err("NOT_FOUND", "Enrollment not found.", 404)

    def delete(self, request, pk):
        e = self._e(pk)
        if e is None:
            return err("NOT_FOUND", "Enrollment not found.", 404)
        if e.status not in ("Pending", "Enrolled"):
            return err("INVALID_STATE", f"A {e.status.lower()} enrollment cannot be withdrawn.", 409)
        e.status, e.updated_by = ("Cancelled" if e.status == "Pending" else "Dropped"), actor_label(self.me)
        e.save()
        return ok("ENROLLMENT_WITHDRAWN", "Withdrawn.", enrollment_row(e, request))


class MyFeedback(SelfBase):
    """POST /employee/training/enrollments/<id>/feedback/  {rating:1-5, comment?}  (post-session survey)"""

    def post(self, request, pk):
        e = self.mine().filter(pk=pk).first()
        if e is None:
            return err("NOT_FOUND", "Enrollment not found.", 404)
        if e.status not in ("Enrolled", "Completed"):
            return err("INVALID_STATE", "Feedback is allowed only for programs you attended.", 409)
        try:
            r = to_decimal(request.data.get("rating"))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        if r is None or not (1 <= r <= 5):
            return err("VALIDATION", "rating must be between 1 and 5.")
        e.feedback_rating, e.feedback_comment, e.updated_by = r, request.data.get("comment"), actor_label(self.me)
        e.save()
        return ok("FEEDBACK_SAVED", "Thanks for your feedback.", enrollment_row(e, request))


class MyCalendar(SelfBase):
    """GET /employee/training/calendar/ ?scope=mine(default)|all ?month=&year=   |  GET calendar/<session_id>/ics/"""

    def get(self, request):
        p = request.query_params
        qs = TrainingSession.objects.filter(company=self.company, is_active=True).exclude(status="Cancelled").select_related("program")
        if p.get("scope") != "all":
            qs = qs.filter(program_id__in=self.mine().filter(status__in=["Enrolled", "Completed"]).values_list("program_id", flat=True))
        if p.get("month") and p.get("year"):
            qs = qs.filter(session_date__year=int(p["year"]), session_date__month=int(p["month"]))
        else:
            qs = qs.filter(session_date__gte=timezone.localdate())
        return ok("MY_CALENDAR", "Training schedule.", [session_row(s) for s in qs])


class MySessionICS(SelfBase):
    def get(self, request, session_id):
        s = TrainingSession.objects.filter(company=self.company, pk=session_id, is_active=True).select_related("program").first()
        if s is None:
            return err("NOT_FOUND", "Session not found.", 404)
        r = HttpResponse(session_ics(s, ""), content_type="text/calendar; charset=utf-8")
        r["Content-Disposition"] = f'attachment; filename="training-session-{s.pk}.ics"'
        return r


class MyAttendance(SelfBase):
    """GET /employee/training/attendance/"""

    def get(self, request):
        qs = TrainingAttendance.objects.filter(enrollment__employee=self.me, is_active=True).select_related("session", "session__program")
        denom = qs.exclude(status="Excused").count()
        pct = round(qs.filter(status__in=["Present", "Late"]).count() * 100 / denom) if denom else None
        return ok("MY_ATTENDANCE", "My attendance.", {
            "attendance_percent": pct,
            "records": [{"session": {"id": a.session_id, "title": a.session.title, "date": iso(a.session.session_date)},
                         "program": {"id": a.session.program_id, "code": a.session.program.code, "title": a.session.program.title},
                         "status": a.status, "hours_attended": float(a.hours_attended)} for a in qs]})


class MyCertificates(SelfBase):
    """GET /employee/training/certificates/    GET certificates/<id>/download/"""

    def get(self, request):
        qs = TrainingCertificate.objects.filter(employee=self.me, is_active=True).select_related("employee", "program")
        rows = [{**cert_row(c, request), "download_url": f"/employee/training/certificates/{c.id}/download/"} for c in qs]
        return ok("MY_CERTIFICATES", "My certificates.", rows)


class MyCertificateDownload(SelfBase):
    def get(self, request, pk):
        c = TrainingCertificate.objects.filter(pk=pk, employee=self.me, is_active=True, status="Issued").first()
        if c is None or not c.file:
            raise Http404("Certificate not found.")
        return FileResponse(c.file.open("rb"), as_attachment=True, filename=f"{c.certificate_no}.pdf")


class MySkills(SelfBase):
    """GET /employee/training/skills/   |  POST {skill(id|domain), level 0-4}  self-assessment"""

    def get(self, request):
        levels = {r.skill_id: r for r in EmployeeSkill.objects.filter(employee=self.me, is_active=True)}
        rows = []
        for s in TrainingSkill.objects.filter(company=self.company, is_active=True).select_related("department"):
            if s.department_id and s.department_id != self.me.department_id:
                continue
            cur = levels[s.id].current_level if s.id in levels else 0
            rows.append({"skill": {"id": s.id, "domain": s.domain, "category": s.category}, "current_level": cur,
                         "level_label": level_label(cur), "target_level": s.target_level, "proficiency_target": level_label(s.target_level),
                         "gap": max(s.target_level - cur, 0), "meets_target": cur >= s.target_level,
                         "source": levels[s.id].source if s.id in levels else None,
                         "recommended_programs": [{"id": p.id, "code": p.code, "title": p.title, "status": p.status} for p in
                                                  s.programs.filter(is_active=True, status__in=["Upcoming", "Ongoing"])] if cur < s.target_level else []})
        return ok("MY_SKILLS", "My skill matrix.", rows)

    def post(self, request):
        ref, lvl = request.data.get("skill"), request.data.get("level", request.data.get("current_level"))
        q = TrainingSkill.objects.filter(company=self.company, is_active=True)
        s = q.filter(pk=int(ref)).first() if str(ref).isdigit() else q.filter(domain__iexact=str(ref or "")).first()
        if s is None:
            return err("NOT_FOUND", "Skill not found.", 404)
        try:
            lvl = int(lvl)
        except (TypeError, ValueError):
            return err("VALIDATION", "level must be 0-4.")
        if not 0 <= lvl <= 4:
            return err("VALIDATION", "level must be 0-4.")
        es, _ = EmployeeSkill.objects.get_or_create(employee=self.me, skill=s, defaults={"company": self.company, "created_by": actor_label(self.me)})
        if es.source in ("Manual", "Training") and es.current_level > lvl and es.pk:
            return err("LOCKED", "Your level was assessed by HR/training; you cannot lower it yourself. Ask your manager.", 409)
        es.current_level, es.source, es.assessed_on, es.assessed_by = lvl, "Self", timezone.localdate(), actor_label(self.me)
        es.remarks, es.is_active, es.updated_by = request.data.get("remarks"), True, actor_label(self.me)
        es.save()
        return ok("MY_SKILL_SAVED", "Self-assessment saved.", {"skill": s.domain, "current_level": lvl, "level_label": level_label(lvl)})


# ---------------- manager / HOD approvals ----------------
class ApprovalsPending(SelfBase):
    """GET /employee/training/approvals/pending/   nominations of people reporting to me (manager or HOD)"""

    def get(self, request):
        qs = TrainingEnrollment.objects.filter(company=self.company, is_active=True, status="Pending", approver_code=self.me.employee_code) \
            .select_related("program", "employee", "employee__department")
        return ok("TRAINING_APPROVALS", "Pending nominations for approval.", [enrollment_row(e, request) for e in qs])


class _Decide(SelfBase):
    approve = True

    def post(self, request, pk):
        e = TrainingEnrollment.objects.filter(company=self.company, pk=pk, is_active=True).select_related("program", "employee").first()
        if e is None or e.approver_code != self.me.employee_code:
            return err("NOT_FOUND", "Nomination not found in your approvals queue.", 404)
        if e.status != "Pending":
            return err("INVALID_STATE", f"Nomination is already {e.status.lower()}.", 409)
        remarks = request.data.get("remarks")
        if not self.approve and not (remarks or "").strip():
            return err("VALIDATION", "remarks are required when rejecting.")
        if self.approve and seats_full(e.program):
            return err("PROGRAM_FULL", "Program is full.", 409)
        e.status = "Enrolled" if self.approve else "Rejected"
        e.decided_by, e.decided_at, e.decision_remarks, e.updated_by = actor_label(self.me), timezone.now(), remarks, actor_label(self.me)
        e.save()
        return ok("NOMINATION_APPROVED" if self.approve else "NOMINATION_REJECTED",
                  "Nomination approved." if self.approve else "Nomination rejected.", enrollment_row(e, request))


class ApproveNomination(_Decide):
    approve = True


class RejectNomination(_Decide):
    approve = False


class NominateReport(SelfBase):
    """POST /employee/training/team/nominate/  {program, employee_code, reason?}  manager nominates a direct report (auto-approved by you)"""

    def post(self, request):
        d = request.data
        pr = TrainingProgram.objects.filter(company=self.company, is_active=True, pk=d.get("program") if str(d.get("program", "")).isdigit() else 0).first() \
            or TrainingProgram.objects.filter(company=self.company, is_active=True, code__iexact=str(d.get("program") or "")).first()
        h = ReportingHierarchy.objects.filter(company=self.company, Employee_ID=str(d.get("employee_code") or ""), is_active=True).first()
        if pr is None:
            return err("NOT_FOUND", "Program not found.", 404)
        if h is None or self.me.employee_code not in (h.manager_code, h.hod_code):
            return err("FORBIDDEN", "You can nominate only people who report to you.", 403)
        from .common import emp_by_code
        emp = emp_by_code(self.company, d["employee_code"])
        if TrainingEnrollment.objects.filter(program=pr, employee=emp, is_active=True, status__in=["Pending", "Enrolled", "Completed"]).exists():
            return err("EXISTS", "Already nominated/enrolled.", 409)
        if seats_full(pr):
            return err("PROGRAM_FULL", "Program is full.", 409)
        e = TrainingEnrollment.objects.create(company=self.company, program=pr, employee=emp, status="Enrolled", source="Manager",
                                              nominated_by=actor_label(self.me), reason=d.get("reason"), approver_code=self.me.employee_code,
                                              decided_by=actor_label(self.me), decided_at=timezone.now(), created_by=actor_label(self.me), updated_by=actor_label(self.me))
        return ok("TEAM_NOMINATED", "Team member enrolled.", enrollment_row(e, request), 201)


class TeamTraining(SelfBase):
    """GET /employee/training/team/  training status of my direct reports (manager / HOD)"""

    def get(self, request):
        codes = list(ReportingHierarchy.objects.filter(company=self.company, is_active=True).filter(
            manager_code=self.me.employee_code).values_list("Employee_ID", flat=True)) + list(
            ReportingHierarchy.objects.filter(company=self.company, is_active=True, hod_code=self.me.employee_code).values_list("Employee_ID", flat=True))
        qs = TrainingEnrollment.objects.filter(company=self.company, is_active=True, employee__employee_code__in=set(codes)) \
            .select_related("program", "employee", "employee__department")
        return ok("TEAM_TRAINING", "Team training.", [enrollment_row(e, request) for e in qs])
