# ============================================================
# Training Dashboard + Training Programs   /api/training/
# ============================================================
from decimal import Decimal

from django.db import transaction
from django.db.models import Avg, Count, Sum
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.views import APIView

from Employee.models import Department

from .common import (TrainingAuthMixin, TrainingCrud, complete_enrollment, emp_brief, emp_by_code, enrollment_row,
                     employees_qs, err, iso, next_seq, ok, program_row, resolve_approver, session_row,
                     sync_program_status, to_bool, to_date, to_decimal, to_int)
from .models import (EmployeeSkill, TrainingAttendance, TrainingCertificate, TrainingEnrollment, TrainingProgram,
                     TrainingSession, TrainingSkill)


class DashboardView(TrainingAuthMixin, APIView):
    """GET /api/training/dashboard/?year=2026&status=&limit=10"""

    def get(self, request):
        co, p = self.company(), request.query_params
        sync_program_status(co)
        try:
            year = int(p.get("year", timezone.localdate().year))
        except ValueError:
            return err("VALIDATION", "Invalid year.")
        hours = (TrainingAttendance.objects.filter(company=co, is_active=True, status__in=["Present", "Late"],
                                                   session__session_date__year=year)
                 .aggregate(s=Sum("hours_attended"))["s"] or Decimal("0"))
        certs = TrainingCertificate.objects.filter(company=co, is_active=True)
        issued = certs.filter(status="Issued").count()
        active = TrainingProgram.objects.filter(company=co, is_active=True, status__in=["Upcoming", "Ongoing"])
        cats = [c for c in active.exclude(category__isnull=True).exclude(category="").values_list("category", flat=True).distinct()]
        sat = TrainingEnrollment.objects.filter(company=co, is_active=True, feedback_rating__isnull=False) \
            .aggregate(a=Avg("feedback_rating"), n=Count("id"))
        avg = round(float(sat["a"]), 1) if sat["a"] is not None else None
        cat_qs = TrainingProgram.objects.filter(company=co, is_active=True)
        if p.get("status"):
            cat_qs = cat_qs.filter(status=p["status"])
        limit = max(1, min(to_int(p.get("limit"), 10), 100))
        upcoming = TrainingSession.objects.filter(company=co, is_active=True, status="Scheduled",
                                                  session_date__gte=timezone.localdate()).select_related("program")[:5]
        hrs = float(hours)
        return ok("TRAINING_DASHBOARD", "Training dashboard.", {
            "kpis": {
                "training_hours_logged": {"value": hrs, "display": f"{hrs:,.0f} Hrs", "caption": "Year-to-date total", "year": year},
                "certificates_issued": {"value": issued, "display": str(issued),
                                        "caption": "100% verified credentials" if issued == certs.count() else
                                        f"{round(issued * 100 / certs.count())}% verified credentials" if certs.count() else "No certificates yet"},
                "active_courses": {"value": active.count(), "display": str(active.count()), "caption": " + ".join(sorted(cats)[:3]) or "-"},
                "average_satisfaction": {"value": avg, "display": f"{avg} / 5.0" if avg is not None else "-",
                                         "caption": "Post-session surveys", "responses": sat["n"]},
            },
            "catalog": [program_row(x, request, brief=True) for x in cat_qs.select_related("trainer")[:limit]],
            "upcoming_sessions": [session_row(s) for s in upcoming],
            "pending_nominations": TrainingEnrollment.objects.filter(company=co, is_active=True, status="Pending").count(),
        })


class MetaView(TrainingAuthMixin, APIView):
    """GET /api/training/meta/  - dropdown data for every Training form."""

    def get(self, request):
        co = self.company()
        return ok("TRAINING_META", "Training dropdowns.", {
            "tabs": ["dashboard", "programs", "calendar", "enrollment", "attendance", "certificates", "skill-matrix"],
            "program_statuses": [k for k, _ in TrainingProgram.STATUS], "modes": [k for k, _ in TrainingProgram.MODE],
            "session_statuses": [k for k, _ in TrainingSession.STATUS],
            "enrollment_statuses": [k for k, _ in TrainingEnrollment.STATUS],
            "attendance_statuses": [k for k, _ in TrainingAttendance.STATUS],
            "skill_levels": [{"level": k, "label": v} for k, v in __import__("Training.models", fromlist=["x"]).SKILL_LEVELS.items()],
            "gap_levels": [k for k, _ in TrainingSkill.GAP],
            "categories": sorted(set(TrainingProgram.objects.filter(company=co).exclude(category__isnull=True).values_list("category", flat=True)) | {"Technical", "Leadership", "Compliance", "Soft Skills"}),
            "departments": list(Department.objects.filter(company=co, is_active=True).values("id", "name")),
            "programs": list(TrainingProgram.objects.filter(company=co, is_active=True).values("id", "code", "title", "status")),
            "skills": list(TrainingSkill.objects.filter(company=co, is_active=True).values("id", "domain", "target_level")),
        })


class ProgramViewSet(TrainingCrud):
    """
    CRUD   /api/training/programs/            ?status= ?category= ?search=
    POST   /api/training/programs/<id>/enroll/        {employee_codes:[..], require_approval?:false}   (HR / Admin)
    GET    /api/training/programs/<id>/enrollments/   ?status=
    GET    /api/training/programs/<id>/sessions/
    POST   /api/training/programs/<id>/cancel/
    POST   /api/training/programs/<id>/complete/      {issue_certificates?, force?}
    """
    model = TrainingProgram
    code = "PROGRAM"
    select = ("trainer",)
    search_fields = ("code", "title", "trainer_name", "category")

    def list(self, request):
        sync_program_status(self.company())
        return super().list(request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        return qs.filter(category__iexact=p["category"]) if p.get("category") else qs

    def build(self, p):
        return program_row(p, self.request)

    def apply(self, p, d, creating):
        co = self.company()
        title = (d.get("title") or p.title or "").strip()
        if not title:
            raise ValueError("title is required.")
        p.title = title
        if creating:
            code = (d.get("code") or "").strip() or next_seq(TrainingProgram, co, "code", "TRN-", 2)
            if TrainingProgram.objects.filter(company=co, code__iexact=code).exists():
                raise ValueError(f"Program code '{code}' already exists.")
            p.code = code
        elif d.get("code") and d["code"] != p.code:
            if TrainingProgram.objects.filter(company=co, code__iexact=d["code"]).exclude(pk=p.pk).exists():
                raise ValueError("Program code already exists.")
            p.code = d["code"]
        for k in ("description", "category", "trainer_name", "audience_label", "certificate_title"):
            if k in d:
                setattr(p, k, d[k])
        if "mode" in d:
            if d["mode"] not in dict(TrainingProgram.MODE):
                raise ValueError(f"Invalid mode. Allowed: {', '.join(dict(TrainingProgram.MODE))}")
            p.mode = d["mode"]
        if "status" in d:
            if d["status"] not in dict(TrainingProgram.STATUS):
                raise ValueError(f"Invalid status. Allowed: {', '.join(dict(TrainingProgram.STATUS))}")
            p.status = d["status"]
        if "duration_hours" in d:
            h = to_decimal(d["duration_hours"], Decimal("0"))
            if h < 0:
                raise ValueError("duration_hours cannot be negative.")
            p.duration_hours = h
        if "capacity" in d:
            p.capacity = to_int(d["capacity"])
        for k in ("start_date", "end_date"):
            if k in d:
                setattr(p, k, to_date(d[k]))
        if p.start_date and p.end_date and p.end_date < p.start_date:
            raise ValueError("end_date cannot be before start_date.")
        for k in ("is_mandatory", "awards_certificate"):
            if k in d:
                setattr(p, k, to_bool(d[k]))
        if "certificate_validity_months" in d:
            p.certificate_validity_months = to_int(d["certificate_validity_months"])
        if "pass_attendance_percent" in d:
            v = to_int(d["pass_attendance_percent"], 75)
            if not 0 <= v <= 100:
                raise ValueError("pass_attendance_percent must be 0-100.")
            p.pass_attendance_percent = v
        if "skill_level_awarded" in d:
            v = to_int(d["skill_level_awarded"], 0)
            if not 0 <= v <= 4:
                raise ValueError("skill_level_awarded must be 0-4.")
            p.skill_level_awarded = v
        if "trainer" in d or "trainer_code" in d:
            p.trainer = emp_by_code(co, d.get("trainer", d.get("trainer_code")), required=False)
        p._skills_ref = d.get("skills") if "skills" in d else None

    def after_save(self, p, creating):
        refs = getattr(p, "_skills_ref", None)
        if refs is None:
            return
        refs = refs if isinstance(refs, list) else [refs]
        found = []
        for r in refs:
            q = TrainingSkill.objects.filter(company=p.company, is_active=True)
            sk = q.filter(pk=int(r)).first() if str(r).isdigit() else q.filter(domain__iexact=str(r)).first()
            if sk is None:
                raise ValueError(f"Skill '{r}' not found.")
            found.append(sk)
        p.skills.set(found)

    def _p(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def enroll(self, request, pk=None):
        p = self._p(pk)
        if p is None:
            return err("NOT_FOUND", "Program not found.", 404)
        if p.status in ("Cancelled", "Completed"):
            return err("INVALID_STATE", f"Program is {p.status.lower()}.", 409)
        codes = request.data.get("employee_codes") or ([request.data["employee_code"]] if request.data.get("employee_code") else [])
        if not codes:
            return err("VALIDATION", "employee_codes (list) is required.")
        pending_only = to_bool(request.data.get("require_approval"))
        done, skipped = [], []
        for code in codes:
            try:
                e = emp_by_code(self.company(), code)
            except ValueError as ex:
                skipped.append({"employee_code": code, "reason": str(ex)})
                continue
            enr = TrainingEnrollment.objects.filter(program=p, employee=e, is_active=True).first()
            if enr and enr.status in ("Enrolled", "Completed"):
                skipped.append({"employee_code": code, "reason": f"Already {enr.status.lower()}."})
                continue
            if not pending_only and p.capacity is not None and \
                    p.enrollments.filter(is_active=True, status__in=["Enrolled", "Completed"]).count() >= p.capacity:
                skipped.append({"employee_code": code, "reason": "Program is full."})
                continue
            enr = enr or TrainingEnrollment(company=p.company, program=p, employee=e, created_by=self.actor())
            enr.source, enr.nominated_by, enr.updated_by = "HR", self.actor(), self.actor()
            enr.reason = request.data.get("reason") or enr.reason
            if pending_only:
                enr.status, enr.approver_code = "Pending", resolve_approver(p.company, e)
            else:
                enr.status, enr.decided_by, enr.decided_at = "Enrolled", self.actor(), timezone.now()
            enr.save()
            done.append(enrollment_row(enr, request))
        return ok("PROGRAM_ENROLL", f"{len(done)} employee(s) processed.", {"enrollments": done, "skipped": skipped},
                  201 if done else 200)

    @action(detail=True, methods=["get"])
    def enrollments(self, request, pk=None):
        p = self._p(pk)
        if p is None:
            return err("NOT_FOUND", "Program not found.", 404)
        qs = p.enrollments.filter(is_active=True).select_related("employee", "employee__department", "program")
        if request.query_params.get("status"):
            qs = qs.filter(status=request.query_params["status"])
        return ok("PROGRAM_ENROLLMENTS", "Enrollments.", [enrollment_row(e, request) for e in qs])

    @action(detail=True, methods=["get"])
    def sessions(self, request, pk=None):
        p = self._p(pk)
        if p is None:
            return err("NOT_FOUND", "Program not found.", 404)
        return ok("PROGRAM_SESSIONS", "Sessions.", [session_row(s) for s in p.sessions.filter(is_active=True).select_related("program")])

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def cancel(self, request, pk=None):
        p = self._p(pk)
        if p is None:
            return err("NOT_FOUND", "Program not found.", 404)
        if p.status in ("Completed", "Cancelled"):
            return err("INVALID_STATE", f"Program is already {p.status.lower()}.", 409)
        p.status, p.updated_by = "Cancelled", self.actor()
        p.save()
        p.sessions.filter(status="Scheduled").update(status="Cancelled")
        n = p.enrollments.filter(status__in=["Pending", "Enrolled"]).update(status="Cancelled")
        return ok("PROGRAM_CANCELLED", "Program cancelled.", {**program_row(p, request), "enrollments_cancelled": n})

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def complete(self, request, pk=None):
        p = self._p(pk)
        if p is None:
            return err("NOT_FOUND", "Program not found.", 404)
        if p.status == "Cancelled":
            return err("INVALID_STATE", "A cancelled program cannot be completed.", 409)
        force, issue = to_bool(request.data.get("force")), request.data.get("issue_certificates")
        completed, blocked = [], []
        for enr in p.enrollments.filter(is_active=True, status="Enrolled").select_related("employee"):
            try:
                cert = complete_enrollment(enr, self.actor(), None if issue is None else to_bool(issue), force)
                completed.append({"employee_code": enr.employee.employee_code, "certificate_no": cert.certificate_no if cert else None})
            except ValueError as ex:
                blocked.append({"employee_code": enr.employee.employee_code, "reason": str(ex)})
        p.sessions.filter(status="Scheduled", session_date__lte=timezone.localdate()).update(status="Completed")
        p.status, p.updated_by = "Completed", self.actor()
        p.save()
        return ok("PROGRAM_COMPLETED", "Program completed.", {"program": program_row(p, request), "completed": completed, "blocked": blocked})
