# ============================================================
# Training Calendar (sessions) + Attendance   /api/training/
# ============================================================
import re
from datetime import datetime, timedelta
from decimal import Decimal

from django.db import transaction
from django.db.models import Count, Q
from django.http import HttpResponse
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.views import APIView

from .certs import session_ics
from .common import (TrainingAuthMixin, TrainingCrud, attendance_percent, dept_name, emp_brief, employees_qs, err, iso, ok,
                     paginate, session_row, to_bool, to_date, to_decimal, to_int)
from .models import TrainingAttendance, TrainingEnrollment, TrainingProgram, TrainingSession


def to_time(v):
    if v in (None, ""):
        return None
    s = str(v).strip().upper()
    for fmt in ("%H:%M", "%H:%M:%S", "%I:%M %p", "%I:%M%p", "%I %p"):
        try:
            return datetime.strptime(s, fmt).time()
        except ValueError:
            continue
    raise ValueError(f"Invalid time '{v}' (use HH:MM, e.g. 10:00 or 02:00 PM).")


def find_program(company, ref):
    q = TrainingProgram.objects.filter(company=company, is_active=True)
    p = q.filter(pk=int(ref)).first() if str(ref).isdigit() else q.filter(code__iexact=str(ref or "")).first()
    if p is None:
        raise ValueError(f"Program '{ref}' not found.")
    return p


class SessionViewSet(TrainingCrud):
    """
    CRUD  /api/training/sessions/        ?program=<id|code> ?status= ?date_from= ?date_to= ?search=
    GET   /api/training/sessions/<id>/attendance/            attendance sheet
    POST  /api/training/sessions/<id>/mark-attendance/       {records:[{employee_code,status,hours_attended?,remarks?}]} | {mark_all:"Present"}
    POST  /api/training/sessions/<id>/complete/              {auto_absent?:false}
    POST  /api/training/sessions/<id>/cancel/
    """
    model = TrainingSession
    code = "SESSION"
    select = ("program",)
    search_fields = ("title", "location", "program__title", "program__code")

    def build(self, s):
        return session_row(s, 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("date_from"):
            qs = qs.filter(session_date__gte=to_date(p["date_from"]))
        if p.get("date_to"):
            qs = qs.filter(session_date__lte=to_date(p["date_to"]))
        return qs

    def apply(self, s, d, creating):
        if creating or "program" in d:
            s.program = find_program(self.company(), d.get("program"))
        if s.program.status == "Cancelled":
            raise ValueError("Cannot schedule sessions for a cancelled program.")
        s.title = (d.get("title") or s.title or s.program.title).strip()
        if "session_date" in d or creating:
            s.session_date = to_date(d.get("session_date"))
            if not s.session_date:
                raise ValueError("session_date is required.")
        if "start_time" in d:
            s.start_time = to_time(d["start_time"])
        if "end_time" in d:
            s.end_time = to_time(d["end_time"])
        if s.start_time and s.end_time and s.end_time <= s.start_time:
            raise ValueError("end_time must be after start_time.")
        for k in ("location", "meeting_link", "trainer_name", "notes"):
            if k in d:
                setattr(s, k, d[k])
        if "status" in d:
            if d["status"] not in dict(TrainingSession.STATUS):
                raise ValueError(f"Invalid status. Allowed: {', '.join(dict(TrainingSession.STATUS))}")
            s.status = d["status"]

    def _s(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    def _roster(self, s):
        return TrainingEnrollment.objects.filter(program=s.program, is_active=True, status__in=["Enrolled", "Completed"]).select_related("employee", "employee__department")

    @action(detail=True, methods=["get"])
    def attendance(self, request, pk=None):
        s = self._s(pk)
        if s is None:
            return err("NOT_FOUND", "Session not found.", 404)
        marks = {a.enrollment_id: a for a in s.attendance.filter(is_active=True)}
        rows = [{"enrollment_id": e.id, "employee": emp_brief(e.employee, request), "department": dept_name(e.employee),
                 "status": marks[e.id].status if e.id in marks else None,
                 "hours_attended": float(marks[e.id].hours_attended) if e.id in marks else None,
                 "remarks": marks[e.id].remarks if e.id in marks else None} for e in self._roster(s)]
        marked = sum(1 for r in rows if r["status"])
        return ok("SESSION_ATTENDANCE", "Attendance sheet.", {"session": session_row(s), "total": len(rows), "marked": marked, "rows": rows})

    @action(detail=True, methods=["post"], url_path="mark-attendance")
    @transaction.atomic
    def mark_attendance(self, request, pk=None):
        s = self._s(pk)
        if s is None:
            return err("NOT_FOUND", "Session not found.", 404)
        if s.status == "Cancelled":
            return err("INVALID_STATE", "Session is cancelled.", 409)
        d, roster = request.data, {e.employee.employee_code: e for e in self._roster(s)}
        by_id = {e.id: e for e in roster.values()}
        recs = d.get("records") or []
        if d.get("mark_all"):
            recs = [{"employee_code": c, "status": d["mark_all"]} for c in roster] + [r for r in recs]
        if not recs:
            return err("VALIDATION", "records (list) or mark_all is required.")
        saved, errors = 0, []
        for r in recs:
            enr = roster.get(str(r.get("employee_code"))) or by_id.get(r.get("enrollment_id"))
            st = r.get("status") or "Present"
            if enr is None:
                errors.append({"record": r, "reason": "Employee is not enrolled in this program."})
                continue
            if st not in dict(TrainingAttendance.STATUS):
                errors.append({"record": r, "reason": f"Invalid status. Allowed: {', '.join(dict(TrainingAttendance.STATUS))}"})
                continue
            try:
                hrs = to_decimal(r.get("hours_attended"))
            except ValueError as ex:
                errors.append({"record": r, "reason": str(ex)})
                continue
            if hrs is None:
                hrs = s.hours if st in ("Present", "Late") else Decimal("0")
            a, _ = TrainingAttendance.objects.get_or_create(session=s, enrollment=enr, defaults={"company": s.company, "created_by": self.actor()})
            a.status, a.hours_attended, a.remarks, a.marked_by, a.is_active, a.updated_by = st, hrs, r.get("remarks"), self.actor(), True, self.actor()
            a.save()
            saved += 1
        return ok("ATTENDANCE_MARKED", f"{saved} attendance record(s) saved.", {"saved": saved, "errors": errors})

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def complete(self, request, pk=None):
        s = self._s(pk)
        if s is None:
            return err("NOT_FOUND", "Session not found.", 404)
        n = 0
        if to_bool(request.data.get("auto_absent")):
            for e in self._roster(s):
                _, created = TrainingAttendance.objects.get_or_create(
                    session=s, enrollment=e, defaults={"company": s.company, "status": "Absent", "marked_by": self.actor(), "created_by": self.actor()})
                n += created
        s.status, s.updated_by = "Completed", self.actor()
        s.save()
        return ok("SESSION_COMPLETED", "Session completed.", {**session_row(s), "auto_absent_marked": n})

    @action(detail=True, methods=["post"])
    def cancel(self, request, pk=None):
        s = self._s(pk)
        if s is None:
            return err("NOT_FOUND", "Session not found.", 404)
        s.status, s.updated_by = "Cancelled", self.actor()
        s.save()
        return ok("SESSION_CANCELLED", "Session cancelled.", session_row(s))


class CalendarView(TrainingAuthMixin, APIView):
    """GET /api/training/calendar/   default = upcoming. ?month=&year= | ?date_from=&date_to= | ?program="""

    def get(self, request):
        co, p = self.company(), request.query_params
        qs = TrainingSession.objects.filter(company=co, is_active=True).exclude(status="Cancelled").select_related("program")
        try:
            if p.get("month") and p.get("year"):
                qs = qs.filter(session_date__year=int(p["year"]), session_date__month=int(p["month"]))
            elif p.get("date_from") or p.get("date_to"):
                if p.get("date_from"):
                    qs = qs.filter(session_date__gte=to_date(p["date_from"]))
                if p.get("date_to"):
                    qs = qs.filter(session_date__lte=to_date(p["date_to"]))
            else:
                qs = qs.filter(session_date__gte=timezone.localdate())
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        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"])
        return ok("TRAINING_CALENDAR", "Training schedule.", [session_row(s) for s in qs])


class SessionICSView(TrainingAuthMixin, APIView):
    """GET /api/training/calendar/<session_id>/ics/  -> .ics file ('Add to Outlook')"""

    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, s.company.Registered_Company_Name or ""), content_type="text/calendar; charset=utf-8")
        r["Content-Disposition"] = f'attachment; filename="training-session-{s.pk}.ics"'
        return r


class AttendanceViewSet(TrainingCrud):
    """
    CRUD  /api/training/attendance/      ?session= ?program= ?employee=<code> ?status= ?date_from= ?date_to=
    GET   /api/training/attendance/summary/    ?program= ?mandatory=true ?year=   (the "96% average attendance" card)
    Use sessions/<id>/mark-attendance/ for bulk marking.
    """
    employee_field = "enrollment__employee__employee_code"
    model = TrainingAttendance
    code = "ATTENDANCE"
    select = ("session", "session__program", "enrollment", "enrollment__employee", "enrollment__employee__department")
    search_fields = ("enrollment__employee__name", "enrollment__employee__employee_code", "session__title")

    def scope(self):
        return super().scope()

    def build(self, a):
        return {"id": a.id, "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},
                "employee": emp_brief(a.enrollment.employee, self.request), "enrollment_id": a.enrollment_id,
                "status": a.status, "hours_attended": float(a.hours_attended), "remarks": a.remarks, "marked_by": a.marked_by}

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("employee"):
            qs = qs.filter(enrollment__employee__employee_code=p["employee"])
        if p.get("session"):
            qs = qs.filter(session_id=int(p["session"]))
        if p.get("program"):
            qs = qs.filter(session__program_id=int(p["program"])) if str(p["program"]).isdigit() else qs.filter(session__program__code__iexact=p["program"])
        if p.get("date_from"):
            qs = qs.filter(session__session_date__gte=to_date(p["date_from"]))
        if p.get("date_to"):
            qs = qs.filter(session__session_date__lte=to_date(p["date_to"]))
        return qs

    def apply(self, a, d, creating):
        co = self.company()
        if creating:
            s = TrainingSession.objects.filter(company=co, pk=to_int(d.get("session")), is_active=True).first()
            if s is None:
                raise ValueError("session (id) is required.")
            enr = None
            if d.get("enrollment_id"):
                enr = TrainingEnrollment.objects.filter(company=co, pk=to_int(d["enrollment_id"]), program=s.program, is_active=True).first()
            elif d.get("employee_code"):
                enr = TrainingEnrollment.objects.filter(company=co, program=s.program, employee__employee_code=d["employee_code"], is_active=True,
                                                        status__in=["Enrolled", "Completed"]).first()
            if enr is None:
                raise ValueError("Employee is not enrolled in this session's program.")
            if TrainingAttendance.objects.filter(session=s, enrollment=enr).exists():
                raise ValueError("Attendance already exists for this employee/session. Update it instead.")
            a.session, a.enrollment = s, enr
        if "status" in d or creating:
            st = d.get("status") or "Present"
            if st not in dict(TrainingAttendance.STATUS):
                raise ValueError(f"Invalid status. Allowed: {', '.join(dict(TrainingAttendance.STATUS))}")
            a.status = st
        if "hours_attended" in d:
            a.hours_attended = to_decimal(d["hours_attended"], Decimal("0"))
        elif creating:
            a.hours_attended = a.session.hours if a.status in ("Present", "Late") else Decimal("0")
        if "remarks" in d:
            a.remarks = d["remarks"]
        a.marked_by = self.actor()

    @action(detail=False, methods=["get"])
    def summary(self, request):
        p, co = request.query_params, self.company()
        qs = TrainingAttendance.objects.filter(company=co, is_active=True)
        if to_bool(p.get("mandatory")):
            qs = qs.filter(session__program__is_mandatory=True)
        if p.get("program"):
            qs = qs.filter(session__program_id=int(p["program"]))
        if p.get("year"):
            qs = qs.filter(session__session_date__year=int(p["year"]))
        def pct(q):
            denom = q.exclude(status="Excused").count()
            return round(q.filter(status__in=["Present", "Late"]).count() * 100 / denom) if denom else None
        by_prog = []
        for pr in TrainingProgram.objects.filter(company=co, is_active=True, id__in=qs.values("session__program_id")):
            by_prog.append({"program": {"id": pr.id, "code": pr.code, "title": pr.title, "is_mandatory": pr.is_mandatory},
                            "attendance_percent": pct(qs.filter(session__program=pr)),
                            "records": qs.filter(session__program=pr).count()})
        overall = pct(qs)
        label = "mandatory L&D compliance tracks" if to_bool(p.get("mandatory")) else "all training programs"
        return ok("ATTENDANCE_SUMMARY", "Attendance summary.", {
            "average_attendance_percent": overall, "total_records": qs.count(),
            "status_counts": {r["status"]: r["n"] for r in qs.values("status").annotate(n=Count("id"))},
            "caption": f"{overall}% average session attendance across {label}." if overall is not None else "No attendance recorded yet.",
            "by_program": by_prog})
