# ============================================================
# Employee Enrollment (nominations)   /api/training/enrollments/
# ============================================================
from django.db import transaction
from django.db.models import Count
from django.utils import timezone
from rest_framework.decorators import action

from .common import (TrainingCrud, complete_enrollment, cert_row, dept_name, emp_by_code, enrollment_row, err, ok,
                     resolve_approver, to_bool, to_decimal)
from .models import TrainingEnrollment, TrainingProgram
from .views_sessions import find_program

OPEN = ["Pending", "Enrolled", "Completed"]


def seats_full(p):
    return p.capacity is not None and p.enrollments.filter(is_active=True, status__in=["Enrolled", "Completed"]).count() >= p.capacity


class EnrollmentViewSet(TrainingCrud):
    """
    CRUD   /api/training/enrollments/      ?status= ?program= ?employee=<code> ?department= ?search=
    POST   /api/training/enrollments/      {program, employee_code, require_approval?:false, reason?}
    POST   /api/training/enrollments/<id>/approve/      {remarks?}
    POST   /api/training/enrollments/<id>/reject/       {remarks}
    POST   /api/training/enrollments/<id>/complete/     {score?, force?, issue_certificate?}
    POST   /api/training/enrollments/<id>/drop/
    POST   /api/training/enrollments/bulk-approve/      {ids:[..], remarks?}
    GET    /api/training/enrollments/pending-summary/   "2 nominations pending approval from <dept> department."
    """
    employee_field = "employee__employee_code"
    model = TrainingEnrollment
    code = "ENROLLMENT"
    select = ("program", "employee", "employee__department")
    search_fields = ("employee__name", "employee__employee_code", "program__title", "program__code")

    def build(self, e):
        return enrollment_row(e, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("program"):
            qs = qs.filter(program_id=int(p["program"])) if str(p["program"]).isdigit() else qs.filter(program__code__iexact=p["program"])
        if p.get("department"):
            qs = qs.filter(employee__department_id=int(p["department"])) if str(p["department"]).isdigit() else qs.filter(employee__Department__iexact=p["department"])
        if p.get("approver"):
            qs = qs.filter(approver_code=p["approver"])
        return qs

    def apply(self, e, d, creating):
        co = self.company()
        if creating:
            prog = find_program(co, d.get("program"))
            emp = emp_by_code(co, d.get("employee_code"))
            if prog.status in ("Cancelled", "Completed"):
                raise ValueError(f"Program is {prog.status.lower()}.")
            if TrainingEnrollment.objects.filter(program=prog, employee=emp, is_active=True, status__in=OPEN).exists():
                raise ValueError("Employee already has an active enrollment/nomination for this program.")
            e.program, e.employee, e.source, e.nominated_by = prog, emp, "HR", self.actor()
            if to_bool(d.get("require_approval")):
                e.status, e.approver_code = "Pending", resolve_approver(co, emp)
            else:
                if seats_full(prog):
                    raise ValueError("Program is full.")
                e.status, e.decided_by, e.decided_at = "Enrolled", self.actor(), timezone.now()
        for k in ("reason", "decision_remarks", "feedback_comment"):
            if k in d:
                setattr(e, k, d[k])
        if "score" in d:
            e.score = to_decimal(d["score"])
        if "feedback_rating" in d:
            r = to_decimal(d["feedback_rating"])
            if r is not None and not (1 <= r <= 5):
                raise ValueError("feedback_rating must be between 1 and 5.")
            e.feedback_rating = r

    def _e(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    def _decide(self, e, approve, remarks):
        if e.status != "Pending":
            return err("INVALID_STATE", f"Enrollment is {e.status}.", 409)
        if approve and seats_full(e.program):
            return err("PROGRAM_FULL", "Program is full.", 409)
        e.status = "Enrolled" if approve else "Rejected"
        e.decided_by, e.decided_at, e.decision_remarks, e.updated_by = self.actor(), timezone.now(), remarks, self.actor()
        e.save()
        return None

    @action(detail=True, methods=["post"])
    def approve(self, request, pk=None):
        e = self._e(pk)
        if e is None:
            return err("NOT_FOUND", "Enrollment not found.", 404)
        bad = self._decide(e, True, request.data.get("remarks"))
        return bad or ok("ENROLLMENT_APPROVED", "Nomination approved.", self.build(e))

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        e = self._e(pk)
        if e is None:
            return err("NOT_FOUND", "Enrollment not found.", 404)
        if not (request.data.get("remarks") or "").strip():
            return err("VALIDATION", "remarks are required when rejecting.")
        bad = self._decide(e, False, request.data["remarks"])
        return bad or ok("ENROLLMENT_REJECTED", "Nomination rejected.", self.build(e))

    @action(detail=False, methods=["post"], url_path="bulk-approve")
    @transaction.atomic
    def bulk_approve(self, request):
        ids = request.data.get("ids") or []
        done, failed = [], []
        for i in ids:
            e = self._e(i) if str(i).isdigit() else None
            if e is None:
                failed.append({"id": i, "reason": "Not found."})
                continue
            bad = self._decide(e, True, request.data.get("remarks"))
            (failed.append({"id": i, "reason": bad.data["message"]}) if bad else done.append(e.id))
        return ok("ENROLLMENT_BULK_APPROVED", f"{len(done)} approved.", {"approved": done, "failed": failed})

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def complete(self, request, pk=None):
        e = self._e(pk)
        if e is None:
            return err("NOT_FOUND", "Enrollment not found.", 404)
        if e.status != "Enrolled":
            return err("INVALID_STATE", f"Only enrolled employees can be completed (current: {e.status}).", 409)
        d = request.data
        try:
            issue = d.get("issue_certificate")
            cert = complete_enrollment(e, self.actor(), None if issue is None else to_bool(issue), to_bool(d.get("force")), to_decimal(d.get("score")))
        except ValueError as ex:
            return err("NOT_ELIGIBLE", str(ex))
        return ok("ENROLLMENT_COMPLETED", "Training completed.", {**self.build(e), "certificate": cert_row(cert, request) if cert else None})

    @action(detail=True, methods=["post"])
    def drop(self, request, pk=None):
        e = self._e(pk)
        if e is None:
            return err("NOT_FOUND", "Enrollment not found.", 404)
        if e.status in ("Completed", "Rejected", "Dropped", "Cancelled"):
            return err("INVALID_STATE", f"Enrollment is {e.status}.", 409)
        e.status, e.decision_remarks, e.updated_by = "Dropped", request.data.get("remarks") or e.decision_remarks, self.actor()
        e.save()
        return ok("ENROLLMENT_DROPPED", "Employee dropped from the program.", self.build(e))

    @action(detail=False, methods=["get"], url_path="pending-summary")
    def pending_summary(self, request):
        qs = self.scope().filter(is_active=True, status="Pending")
        by = {}
        for e in qs:
            by[dept_name(e.employee) or "Unassigned"] = by.get(dept_name(e.employee) or "Unassigned", 0) + 1
        msgs = [f"{n} nomination{'s' if n != 1 else ''} pending approval from {d} department." for d, n in by.items()]
        return ok("ENROLLMENT_PENDING", "Pending nominations.", {"total_pending": qs.count(), "messages": msgs,
                  "by_department": [{"department": d, "count": n} for d, n in by.items()]})
