# ============================================================
# Training - shared helpers (reuses People.common: envelope, paging, parsing, CrudBase)
# ============================================================
from decimal import Decimal

from django.db.models import Avg, Count, Q, Sum
from django.utils import timezone
from rest_framework.permissions import BasePermission

from Employee.employee_crud_permissions import (_role_is_usable, resolve_actor_role, role_allows)
from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated
from Employee.leave_models import ReportingHierarchy
from People.common import (CrudBase, PeopleAuthMixin, dept_name, emp_brief, emp_by_code, employees_qs, err, iso,  # noqa: F401
                           ok, paginate, to_bool, to_date, to_decimal, to_int, next_seq)  # noqa: F401

from .models import (EmployeeSkill, SKILL_LEVELS, TrainingAttendance, TrainingCertificate, TrainingEnrollment,
                     TrainingProgram, TrainingSession, TrainingSkill)

MODULE = "training"


# ---------------------------------------------------------------
# permissions: Company Admin always. Employee/HR: can_<action>_training if that checkbox exists,
# otherwise the same action on the "employees" module (so existing HR roles work without a new migration).
# ---------------------------------------------------------------
def training_allows(user, action):
    actor = resolve_actor_role(user)
    if actor == "admin":
        return True
    if actor is None:
        return False
    role = _role_is_usable(user)
    if role is None:
        return False
    a = "edit" if action == "approve" else action
    return role_allows(role, MODULE, a) or role_allows(role, "employees", a)


class IsTrainingUser(BasePermission):
    message = "You do not have permission to manage Training."
    METHOD_ACTION = {"GET": "view", "HEAD": "view", "OPTIONS": "view", "POST": "create",
                     "PUT": "edit", "PATCH": "edit", "DELETE": "delete"}

    def has_permission(self, request, view):
        act = getattr(view, "permission_action", None)
        if act is None:
            va = getattr(view, "action", None)
            act = {"update_post": "edit", "delete_post": "delete"}.get(va) or \
                  (getattr(view, "permission_action_map", None) or {}).get(va)
        act = act or self.METHOD_ACTION.get(request.method)
        return bool(act) and training_allows(request.user, act)


class TrainingAuthMixin(PeopleAuthMixin):
    permission_classes = [IsTrainingUser]


class TrainingCrud(TrainingAuthMixin, CrudBase):
    employee_field = None          # ORM path to the employee code, set per resource (None = no ?employee= filter)

    def filter(self, qs, p):
        emp = p.get("employee")
        qs = super().filter(qs, {k: v for k, v in p.items() if k != "employee"})
        if emp and self.employee_field:
            qs = qs.filter(**{self.employee_field: emp})
        return qs


# ---------------------------------------------------------------
# domain helpers
# ---------------------------------------------------------------
def sync_program_status(company):
    """Idempotent date-driven status moves (Upcoming -> Ongoing -> Completed). Draft/Cancelled untouched."""
    t = timezone.localdate()
    base = TrainingProgram.objects.filter(company=company, is_active=True)
    base.filter(status="Upcoming", start_date__lte=t).update(status="Ongoing")
    base.filter(status__in=["Upcoming", "Ongoing"], end_date__lt=t).update(status="Completed")


def enrolled_count(program):
    return program.enrollments.filter(is_active=True, status__in=["Enrolled", "Completed"]).count()


def attendance_percent(enr):
    """% of non-cancelled, already-held sessions attended (Present/Late/Excused counts as attended)."""
    held = TrainingSession.objects.filter(program=enr.program, is_active=True).exclude(status="Cancelled") \
        .filter(Q(status="Completed") | Q(session_date__lte=timezone.localdate()))
    n = held.count()
    if n == 0:
        return None
    ok_n = TrainingAttendance.objects.filter(enrollment=enr, session__in=held, status__in=["Present", "Late", "Excused"]).count()
    return round(ok_n * 100 / n, 1)


def resolve_approver(company, emp):
    h = ReportingHierarchy.objects.filter(company=company, Employee_ID=emp.employee_code, is_active=True).first()
    return (h.hod_code or h.manager_code) if h else None


def program_row(p, request=None, brief=False):
    n = enrolled_count(p)
    row = {"id": p.id, "code": p.code, "title": p.title, "category": p.category, "trainer": p.trainer_name or (p.trainer.name if p.trainer else None),
           "trainer_employee": emp_brief(p.trainer) if p.trainer_id else None, "mode": p.mode,
           "duration_hours": float(p.duration_hours), "duration_label": f"{p.duration_hours.normalize():f} Hours",
           "enrolled": n, "enrolled_label": f"{n} {p.audience_label}", "capacity": p.capacity, "status": p.status,
           "start_date": iso(p.start_date), "end_date": iso(p.end_date), "is_mandatory": p.is_mandatory}
    if not brief:
        row.update(description=p.description, audience_label=p.audience_label, awards_certificate=p.awards_certificate,
                   certificate_title=p.certificate_title, certificate_validity_months=p.certificate_validity_months,
                   pass_attendance_percent=p.pass_attendance_percent, skill_level_awarded=p.skill_level_awarded,
                   skills=[{"id": s.id, "domain": s.domain} for s in p.skills.all()],
                   sessions_count=p.sessions.filter(is_active=True).count(),
                   pending_nominations=p.enrollments.filter(is_active=True, status="Pending").count(),
                   seats_left=(p.capacity - n) if p.capacity is not None else None)
    return row


def fmt_time(t):
    return t.strftime("%I:%M %p").lstrip("0") if t else None


def session_row(s, request=None):
    label = f"{s.title}: {s.session_date.strftime('%d %b %Y')}"
    if s.start_time:
        label += f" • {fmt_time(s.start_time)}" + (f" - {fmt_time(s.end_time)}" if s.end_time else "")
    if s.location:
        label += f" ({s.location})"
    return {"id": s.id, "program": {"id": s.program_id, "code": s.program.code, "title": s.program.title}, "title": s.title,
            "session_date": iso(s.session_date), "start_time": s.start_time.strftime("%H:%M") if s.start_time else None,
            "end_time": s.end_time.strftime("%H:%M") if s.end_time else None, "hours": float(s.hours), "location": s.location,
            "meeting_link": s.meeting_link, "trainer": s.trainer_name or s.program.trainer_name, "status": s.status,
            "notes": s.notes, "label": label, "ics_url": f"/api/training/calendar/{s.id}/ics/"}


def enrollment_row(e, request=None):
    return {"id": e.id, "program": {"id": e.program_id, "code": e.program.code, "title": e.program.title},
            "employee": emp_brief(e.employee, request), "department": dept_name(e.employee), "status": e.status,
            "source": e.source, "nominated_by": e.nominated_by, "reason": e.reason, "approver_code": e.approver_code,
            "decided_by": e.decided_by, "decided_at": iso(e.decided_at), "decision_remarks": e.decision_remarks,
            "completed_on": iso(e.completed_on), "score": float(e.score) if e.score is not None else None,
            "feedback_rating": float(e.feedback_rating) if e.feedback_rating is not None else None,
            "feedback_comment": e.feedback_comment, "attendance_percent": attendance_percent(e),
            "created_at": iso(e.created_at)}


def cert_row(c, request=None):
    return {"id": c.id, "certificate_no": c.certificate_no, "verification_code": c.verification_code, "title": c.title,
            "issued_to": emp_brief(c.employee, request), "program": ({"id": c.program_id, "code": c.program.code, "title": c.program.title} if c.program_id else None),
            "issued_on": iso(c.issued_on), "expiry_date": iso(c.expiry_date), "status": c.status, "is_external": c.is_external,
            "issuer_name": c.issuer_name, "issued_by": c.issued_by,
            "pdf_url": request.build_absolute_uri(c.file.url) if request and c.file else None,
            "download_url": f"/api/training/certificates/{c.id}/download/"}


def level_label(n):
    return f"Level {n} {SKILL_LEVELS.get(n, '')}".strip()


def skill_stats(skill):
    """Bench strength = % of in-scope active employees whose level >= target."""
    emps = employees_qs(skill.company).filter(is_active=True)
    if skill.department_id:
        emps = emps.filter(department_id=skill.department_id)
    total = emps.count()
    ok_n = EmployeeSkill.objects.filter(skill=skill, employee__in=emps, is_active=True, current_level__gte=skill.target_level).count() if total else 0
    pct = round(ok_n * 100 / total) if total else 0
    gap = skill.gap_level_override or ("Optimal" if pct >= 90 else "Active Track" if pct >= 80 else "Upskilling" if pct >= 60 else "Critical")
    return total, ok_n, pct, gap


def skill_row(s):
    total, ok_n, pct, gap = skill_stats(s)
    return {"id": s.id, "domain": s.domain, "category": s.category, "description": s.description,
            "target_level": s.target_level, "proficiency_target": level_label(s.target_level),
            "department": ({"id": s.department_id, "name": s.department.name} if s.department_id else None),
            "bench_total": total, "bench_qualified": ok_n, "bench_strength_percent": pct,
            "current_bench_strength": f"{pct}% Compliant", "gap_level": gap, "gap_level_override": s.gap_level_override}


def complete_enrollment(enr, actor, issue_cert=None, force=False, score=None, completed_on=None):
    """Mark completed, raise skill levels, issue certificate. Returns (certificate|None, warnings)."""
    from .certs import issue_certificate
    p = enr.program
    pct = attendance_percent(enr)
    if not force and pct is not None and pct < p.pass_attendance_percent:
        raise ValueError(f"Attendance {pct}% is below the required {p.pass_attendance_percent}%. Pass force=true to override.")
    enr.status, enr.completed_on = "Completed", completed_on or timezone.localdate()
    if score is not None:
        enr.score = score
    enr.updated_by = actor
    enr.save()
    if p.skill_level_awarded:
        for sk in p.skills.all():
            es, _ = EmployeeSkill.objects.get_or_create(employee=enr.employee, skill=sk,
                                                        defaults={"company": enr.company, "created_by": actor})
            if es.current_level < p.skill_level_awarded:
                es.current_level, es.source, es.assessed_on = p.skill_level_awarded, "Training", timezone.localdate()
                es.assessed_by = actor
                es.save()
    cert = None
    if (p.awards_certificate if issue_cert is None else issue_cert):
        cert, _ = issue_certificate(enr.company, enr.employee, p, enr, actor)
    return cert
