# ============================================================
# Certificates   /api/training/certificates/
# ============================================================
from django.http import FileResponse, Http404
from rest_framework.decorators import action
from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
from rest_framework.permissions import AllowAny
from rest_framework.views import APIView

from .certs import issue_certificate, render_certificate_pdf
from django.core.files.base import ContentFile

from .common import TrainingCrud, cert_row, emp_by_code, err, iso, ok, to_bool, to_date
from .models import TrainingCertificate, TrainingEnrollment, TrainingProgram
from .views_sessions import find_program


class CertificateViewSet(TrainingCrud):
    """
    CRUD  /api/training/certificates/       ?employee=<code> ?program=<id|code> ?status= ?search=
    POST  /api/training/certificates/       A) {enrollment_id}                       issue for a completed training
                                            B) {employee_code, program?, title?}     issue manually
                                            C) multipart: employee_code,title,issuer_name,file,is_external=true  (3rd-party certificate)
    GET   /api/training/certificates/<id>/download/     PDF / uploaded file
    POST  /api/training/certificates/<id>/revoke/       {remarks?}
    POST  /api/training/certificates/<id>/regenerate/  re-render the PDF (internal certificates)
    GET   /api/training/certificates/verify/<code>/     PUBLIC credential check (no login)
    """
    employee_field = "employee__employee_code"
    model = TrainingCertificate
    code = "CERTIFICATE"
    parser_classes = [JSONParser, MultiPartParser, FormParser]
    select = ("employee", "employee__department", "program")
    search_fields = ("certificate_no", "title", "employee__name", "employee__employee_code", "verification_code")

    def build(self, c):
        return cert_row(c, 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"])
        return qs

    def create(self, request):
        d, co = request.data, self.company()
        try:
            if d.get("enrollment_id"):
                enr = TrainingEnrollment.objects.filter(company=co, pk=int(d["enrollment_id"]), is_active=True).select_related("program", "employee").first()
                if enr is None:
                    raise ValueError("Enrollment not found.")
                if enr.status != "Completed" and not to_bool(d.get("force")):
                    raise ValueError("Enrollment is not completed. Complete it first (or pass force=true).")
                cert, created = issue_certificate(co, enr.employee, enr.program, enr, self.actor(), d.get("title"), to_date(d.get("issued_on")))
                return ok("CERTIFICATE_ISSUED" if created else "CERTIFICATE_EXISTS", "Certificate issued." if created else "Certificate already issued.",
                          cert_row(cert, request), 201 if created else 200)
            emp = emp_by_code(co, d.get("employee_code"))
            prog = find_program(co, d["program"]) if d.get("program") else None
            ext = to_bool(d.get("is_external"))
            if ext or request.FILES.get("file"):
                title = (d.get("title") or "").strip()
                if not title:
                    raise ValueError("title is required for an external certificate.")
                from .common import next_seq
                import secrets
                issued = to_date(d.get("issued_on"))
                from django.utils import timezone
                issued = issued or timezone.localdate()
                c = TrainingCertificate(company=co, employee=emp, program=prog, certificate_no=next_seq(TrainingCertificate, co, "certificate_no", f"CERT-{issued.year}-"),
                                        verification_code=secrets.token_hex(6).upper(), title=title, issued_on=issued, expiry_date=to_date(d.get("expiry_date")),
                                        issued_by=self.actor(), is_external=True, issuer_name=d.get("issuer_name"), created_by=self.actor(), updated_by=self.actor())
                if request.FILES.get("file"):
                    c.file = request.FILES["file"]
                c.save()
                return ok("CERTIFICATE_ADDED", "External certificate added.", cert_row(c, request), 201)
            cert, created = issue_certificate(co, emp, prog, None, self.actor(), d.get("title"), to_date(d.get("issued_on")))
            return ok("CERTIFICATE_ISSUED", "Certificate issued.", cert_row(cert, request), 201)
        except (ValueError, TypeError) as ex:
            return err("VALIDATION", str(ex))

    def apply(self, c, d, creating):
        for k in ("title", "issuer_name"):
            if k in d:
                setattr(c, k, d[k])
        if "expiry_date" in d:
            c.expiry_date = to_date(d["expiry_date"])
        if "issued_on" in d:
            c.issued_on = to_date(d["issued_on"]) or c.issued_on
        if "status" in d:
            if d["status"] not in dict(TrainingCertificate.STATUS):
                raise ValueError("Invalid status.")
            c.status = d["status"]
        f = self.request.FILES.get("file")
        if f:
            c.file = f

    def _c(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    @action(detail=True, methods=["get"])
    def download(self, request, pk=None):
        c = self._c(pk)
        if c is None or not c.file:
            raise Http404("Certificate file not found.")
        return FileResponse(c.file.open("rb"), as_attachment=True, filename=f"{c.certificate_no}.pdf" if c.file.name.lower().endswith(".pdf") else c.file.name.rsplit("/", 1)[-1])

    @action(detail=True, methods=["post"])
    def revoke(self, request, pk=None):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Certificate not found.", 404)
        c.status, c.updated_by = "Revoked", self.actor()
        c.save()
        return ok("CERTIFICATE_REVOKED", "Certificate revoked.", cert_row(c, request))

    @action(detail=True, methods=["post"])
    def regenerate(self, request, pk=None):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Certificate not found.", 404)
        if c.is_external:
            return err("INVALID_STATE", "External certificates cannot be regenerated.", 409)
        co = c.company
        pdf = render_certificate_pdf(co.Registered_Company_Name or co.Brand_Name or "Company", c.employee.name, c.title,
                                     c.program.title if c.program_id else None, c.issued_on, c.certificate_no, c.verification_code, c.expiry_date)
        c.file.save(f"{c.certificate_no}.pdf", ContentFile(pdf), save=True)
        return ok("CERTIFICATE_REGENERATED", "Certificate PDF regenerated.", cert_row(c, request))


class VerifyCertificateView(APIView):
    """PUBLIC: GET /api/training/certificates/verify/<verification_code>/  (so third parties can validate credentials)"""
    authentication_classes = []
    permission_classes = [AllowAny]

    def get(self, request, code):
        c = TrainingCertificate.objects.filter(verification_code__iexact=code, is_active=True).select_related("employee", "program", "company").first()
        if c is None:
            return err("NOT_FOUND", "No certificate found for this verification code.", 404)
        return ok("CERTIFICATE_VERIFIED", "Certificate is genuine." if c.status == "Issued" else "Certificate has been revoked.", {
            "valid": c.status == "Issued", "certificate_no": c.certificate_no, "title": c.title, "holder": c.employee.name,
            "issued_on": iso(c.issued_on), "expiry_date": iso(c.expiry_date), "issuer": c.company.Registered_Company_Name or c.company.Brand_Name})
