# ============================================================
# 4. EMPLOYEE DOCUMENTS  /api/people/documents/
# Re-uses the EXISTING Employee.EmployeeDocument table/files.
# ============================================================
from django.db import transaction
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
from rest_framework.viewsets import ViewSet

from Employee.models import EmployeeDocument

from .common import (PeopleAuthMixin, emp_brief, emp_by_code, employees_qs, err, iso, ok, paginate, to_bool,
                     to_date)
from .models import DocumentCheck

# matrix columns -> EmployeeDocument.document_type values
CATEGORIES = {
    "government_id": {"label": "Government ID (Aadhaar/PAN)", "types": ["AADHAAR", "PAN"]},
    "education_certificate": {"label": "Education Certificate", "types": ["EDUCATION"]},
    "previous_relieving": {"label": "Previous Relieving", "types": ["EXPERIENCE"]},
}


def check_status(doc):
    c = getattr(doc, "people_check", None)
    try:
        c = doc.people_check
    except DocumentCheck.DoesNotExist:
        c = None
    if c is not None:
        return c.status
    return "Verified" if doc.is_verified else "Pending"


def doc_row(d, request=None):
    try:
        c = d.people_check
    except DocumentCheck.DoesNotExist:
        c = None
    return {"id": d.id, "document_type": d.document_type, "document_name": d.document_name,
            "status": check_status(d), "is_verified": d.is_verified, "verified_by": d.verified_by,
            "verified_at": iso(d.verified_at), "expiry_date": iso(d.expiry_date),
            "remarks": (c.remarks if c else d.remarks), "uploaded_at": iso(d.uploaded_at),
            "file": request.build_absolute_uri(d.file.url) if request and d.file else None}


def category_status(docs, types):
    mine = [d for d in docs if d.document_type in types]
    if not mine:
        return "Missing"
    sts = {check_status(d) for d in mine}
    if "Rejected" in sts:
        return "Rejected"
    return "Verified" if sts == {"Verified"} else "Pending"


def matrix_row(e, docs):
    cols = {k: category_status(docs, v["types"]) for k, v in CATEGORIES.items()}
    done = sum(1 for s in cols.values() if s == "Verified")
    pct = round(done * 100 / len(cols))
    return {"employee": emp_brief(e), **cols, "compliance_percent": pct,
            "compliance_status": "100% Compliant" if pct == 100 else f"{pct}% Compliant"}


def _set_check(doc, status, actor, remarks=None):
    c, _ = DocumentCheck.objects.get_or_create(document=doc, defaults={"created_by": actor})
    c.status, c.remarks, c.reviewed_by, c.reviewed_at, c.updated_by = status, remarks, actor, timezone.now(), actor
    c.save()
    doc.is_verified = status == "Verified"
    doc.verified_by = actor if status == "Verified" else None
    doc.verified_at = timezone.now() if status == "Verified" else None
    if remarks:
        doc.remarks = remarks
    doc.save()
    return c


class DocumentViewSet(PeopleAuthMixin, ViewSet):
    """
    GET  /api/people/documents/                       repository matrix (+ ?search= &compliance=pending)
    GET  /api/people/documents/<employee_code>/vault/ every document of one employee ("Vault")
    POST /api/people/documents/upload/                multipart: employee_code, document_type, document_name?,
                                                       file, expiry_date?, verified? (default true)
    POST /api/people/documents/<doc_id>/verify/      {remarks?}
    POST /api/people/documents/<doc_id>/reject/      {remarks}
    POST /api/people/documents/<doc_id>/update/      {document_name?, expiry_date?, remarks?, document_type?}
    POST /api/people/documents/<doc_id>/delete/
    """
    parser_classes = [JSONParser, MultiPartParser, FormParser]
    lookup_value_regex = r"[^/]+"

    def _docs(self):
        return EmployeeDocument.objects.filter(company=self.company(), is_active=True)

    def list(self, request):
        company, p = self.company(), request.query_params
        qs = employees_qs(company).filter(is_active=True)
        q = (p.get("search") or "").strip()
        if q:
            from django.db.models import Q
            qs = qs.filter(Q(name__icontains=q) | Q(employee_code__icontains=q))
        qs = qs.order_by("name")
        rows_all = []
        by_emp = {}
        for d in self._docs().filter(employee__in=qs).select_related("employee"):
            by_emp.setdefault(d.employee_id, []).append(d)
        for e in qs:
            rows_all.append(matrix_row(e, by_emp.get(e.id, [])))
        if p.get("compliance") == "pending":
            rows_all = [r for r in rows_all if r["compliance_percent"] < 100]
        rows, meta = paginate(request, rows_all, lambda r: r)
        return ok("DOCUMENT_MATRIX", "Employee document repository & verification.", rows, meta=meta,
                  summary={"employees": len(rows_all),
                           "fully_compliant": sum(1 for r in rows_all if r["compliance_percent"] == 100)},
                  columns=[{"key": k, "label": v["label"]} for k, v in CATEGORIES.items()])

    @action(detail=True, methods=["get"])
    def vault(self, request, pk=None):
        try:
            e = emp_by_code(self.company(), pk)
        except ValueError as ex:
            return err("NOT_FOUND", str(ex), 404)
        docs = list(self._docs().filter(employee=e).order_by("-uploaded_at"))
        return ok("DOCUMENT_VAULT", "Document vault.",
                  {"employee": emp_brief(e, request), "matrix": matrix_row(e, docs),
                   "documents": [doc_row(d, request) for d in docs]})

    @action(detail=False, methods=["post"])
    @transaction.atomic
    def upload(self, request):
        d, company = request.data, self.company()
        f = request.FILES.get("file")
        try:
            e = emp_by_code(company, d.get("employee_code"))
            dtype = (d.get("document_type") or "").upper()
            if dtype not in dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES):
                raise ValueError("Invalid document_type. Allowed: " +
                                 ", ".join(dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES)))
            if f is None:
                raise ValueError("file is required (multipart/form-data).")
            doc = EmployeeDocument(company=company, employee=e, document_type=dtype, file=f,
                                   document_name=d.get("document_name") or f"{e.name} {dtype.title()}",
                                   expiry_date=to_date(d.get("expiry_date")), remarks=d.get("remarks"),
                                   created_by=self.actor(), updated_by=self.actor())
            doc.save()
        except ValueError as ex:
            transaction.set_rollback(True)
            return err("VALIDATION", str(ex))
        _set_check(doc, "Verified" if to_bool(d.get("verified"), True) else "Pending", self.actor())
        return ok("DOCUMENT_UPLOADED", "Document uploaded.", doc_row(doc, request), 201)

    def _doc(self, pk):
        return self._docs().filter(pk=pk).first() if str(pk).isdigit() else None

    @action(detail=True, methods=["post"])
    def verify(self, request, pk=None):
        doc = self._doc(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        _set_check(doc, "Verified", self.actor(), request.data.get("remarks"))
        return ok("DOCUMENT_VERIFIED", "Document verified.", doc_row(doc, request))

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        doc = self._doc(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        if not (request.data.get("remarks") or "").strip():
            return err("VALIDATION", "remarks are required when rejecting a document.")
        _set_check(doc, "Rejected", self.actor(), request.data.get("remarks"))
        return ok("DOCUMENT_REJECTED", "Document rejected.", doc_row(doc, request))

    def retrieve(self, request, pk=None):
        doc = self._doc(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        return ok("DOCUMENT_DETAIL", "Document.", doc_row(doc, request))

    def partial_update(self, request, pk=None):          # PATCH/PUT /documents/<id>/
        return self.update_post(request, pk)

    update = partial_update

    def destroy(self, request, pk=None):                  # DELETE /documents/<id>/
        return self.delete_post(request, pk)

    @action(detail=True, methods=["post"], url_path="update")
    def update_post(self, request, pk=None):
        doc = self._doc(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        d = request.data
        try:
            if "document_name" in d:
                doc.document_name = d["document_name"]
            if "expiry_date" in d:
                doc.expiry_date = to_date(d["expiry_date"])
            if "remarks" in d:
                doc.remarks = d["remarks"]
            if "document_type" in d:
                if d["document_type"].upper() not in dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES):
                    raise ValueError("Invalid document_type.")
                doc.document_type = d["document_type"].upper()
            if request.FILES.get("file"):
                doc.file = request.FILES["file"]
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        doc.updated_by = self.actor()
        doc.save()
        return ok("DOCUMENT_UPDATED", "Document updated.", doc_row(doc, request))

    @action(detail=True, methods=["post"], url_path="delete")
    def delete_post(self, request, pk=None):
        doc = self._doc(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        doc.is_active, doc.updated_by = False, self.actor()
        doc.save()
        return ok("DOCUMENT_DELETED", "Document removed.", {"id": doc.id})


    # ---- ADDITIVE: Employee Documents tab extras ----
    @action(detail=False, methods=["get"])
    def types(self, request):
        return ok("DOCUMENT_TYPES", "Document types.",
                  [{"code": c, "label": l} for c, l in EmployeeDocument.DOCUMENT_TYPE_CHOICES])

    @action(detail=False, methods=["get"])
    def files(self, request):
        """Flat list of every employee document: ?status=Pending|Verified|Rejected ?document_type= ?employee=<code> ?search="""
        from django.db.models import Q
        p = request.query_params
        qs = self._docs().select_related("employee")
        if p.get("document_type"):
            qs = qs.filter(document_type=p["document_type"].upper())
        if p.get("employee"):
            qs = qs.filter(employee__employee_code=p["employee"])
        q = (p.get("search") or "").strip()
        if q:
            qs = qs.filter(Q(document_name__icontains=q) | Q(employee__name__icontains=q)
                           | Q(employee__employee_code__icontains=q))
        rows = [dict(doc_row(d, request), employee=emp_brief(d.employee)) for d in qs.order_by("-uploaded_at")]
        if p.get("status"):
            rows = [r for r in rows if r["status"].lower() == p["status"].lower()]
        page, meta = paginate(request, rows, lambda r: r)
        return ok("DOCUMENT_FILES", "Employee documents.", page, meta=meta)
