# ============================================================
# ADDITIVE: Employee self-service (mobile / web app) - Document Vault
# Mounted at /employee/vault/   (Employee JWT; an employee only sees / changes OWN data)
#
#   GET  docs/types/                       uploadable document types
#   GET  docs/                             my documents + compliance summary
#   POST docs/                             multipart: document_type, file, document_name?, expiry_date?
#   GET  docs/<id>/                        one of my documents
#   PUT|PATCH|POST docs/<id>/(update/)     rename / replace file (not once Verified)
#   DELETE|POST    docs/<id>/(delete/)     remove (not once Verified)
#   GET  letters/ , letters/<id>/ , letters/<id>/download/ , letters/<id>/pdf/    my issued letters
#   GET  policies/ , policies/<id>/ , policies/<id>/download/                     company policies
#   GET  hr-forms/ , hr-forms/<id>/ , hr-forms/<id>/download/                     HR forms (category FORM)
# ============================================================
from django.db import transaction
from rest_framework.decorators import action
from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
from rest_framework.routers import SimpleRouter
from rest_framework.viewsets import ViewSet

from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated
from Employee.employee_crud_permissions import actor_label
from Employee.models import EmployeeDocument

from .common import err, iso, ok, paginate, to_date
from .models import CompanyPolicy, DocumentCheck, EmployeeLetter, HRDocument
from .views_documents import CATEGORIES, _set_check, category_status, check_status, doc_row
from .views_vault import FileRecordBase, check_upload, file_name, file_url, send_file

# company-issued types the employee cannot upload themselves
COMPANY_ISSUED = {"OFFER_LETTER", "APPOINTMENT_LETTER", "SALARY_SLIP"}
# one active copy only (update / delete the old one instead of duplicating)
SINGLE = {"AADHAAR", "PAN", "RESUME", "PASSPORT_PHOTO", "BANK"}


class EmployeeBase:
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

    @property
    def me(self):
        return self.request.user

    def company(self):
        return self.request.user.company

    def actor(self):
        return actor_label(self.request.user)


class MyDocumentsViewSet(EmployeeBase, ViewSet):
    parser_classes = [JSONParser, MultiPartParser, FormParser]

    def _mine(self):
        return EmployeeDocument.objects.filter(company=self.company(), employee=self.me, is_active=True)

    def _doc(self, pk):
        return self._mine().filter(pk=pk).first() if str(pk).isdigit() else None

    @action(detail=False, methods=["get"])
    def types(self, request):
        return ok("MY_DOCUMENT_TYPES", "Document types.",
                  [{"code": c, "label": l, "single_copy": c in SINGLE}
                   for c, l in EmployeeDocument.DOCUMENT_TYPE_CHOICES if c not in COMPANY_ISSUED])

    def list(self, request):
        docs = list(self._mine().order_by("-uploaded_at"))
        status = {k: category_status(docs, v["types"]) for k, v in CATEGORIES.items()}
        done = sum(1 for s in status.values() if s == "Verified")
        rows = [doc_row(d, request) for d in docs]
        t = (request.query_params.get("document_type") or "").upper()
        if t:
            rows = [r for r in rows if r["document_type"] == t]
        if request.query_params.get("status"):
            rows = [r for r in rows if r["status"].lower() == request.query_params["status"].lower()]
        return ok("MY_DOCUMENTS", "My documents.", rows,
                  summary={"total": len(docs), "verified": sum(1 for d in docs if check_status(d) == "Verified"),
                           "pending": sum(1 for d in docs if check_status(d) == "Pending"),
                           "rejected": sum(1 for d in docs if check_status(d) == "Rejected"),
                           "compliance_percent": round(done * 100 / len(CATEGORIES)),
                           "checklist": [{"key": k, "label": v["label"], "status": status[k]}
                                         for k, v in CATEGORIES.items()]})

    def retrieve(self, request, pk=None):
        d = self._doc(pk)
        return ok("MY_DOCUMENT", "Document.", doc_row(d, request)) if d else err("NOT_FOUND", "Document not found.", 404)

    @transaction.atomic
    def create(self, request):
        d, f = request.data, request.FILES.get("file")
        try:
            dtype = (d.get("document_type") or "").upper()
            if dtype not in dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES) or dtype in COMPANY_ISSUED:
                raise ValueError("Invalid document_type. Call docs/types/ for the allowed list.")
            if f is None:
                raise ValueError("file is required (multipart/form-data).")
            check_upload(f)
            if dtype in SINGLE and self._mine().filter(document_type=dtype).exists():
                raise ValueError("You have already uploaded this document. Update or delete the existing one.")
            doc = EmployeeDocument(company=self.company(), employee=self.me, document_type=dtype, file=f,
                                   document_name=d.get("document_name") or f"{self.me.name} {dtype.title()}",
                                   expiry_date=to_date(d.get("expiry_date")), 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, "Pending", self.actor())
        return ok("MY_DOCUMENT_UPLOADED", "Document uploaded. HR will verify it shortly.", doc_row(doc, request), 201)

    def partial_update(self, request, pk=None):
        doc = self._doc(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        if check_status(doc) == "Verified":
            return err("LOCKED", "A verified document cannot be changed. Please contact HR.", 403)
        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 request.FILES.get("file"):
                check_upload(request.FILES["file"])
                doc.file = request.FILES["file"]
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        doc.updated_by = self.actor()
        doc.save()
        if request.FILES.get("file"):                      # re-uploaded -> back to HR review
            _set_check(doc, "Pending", self.actor())
        return ok("MY_DOCUMENT_UPDATED", "Document updated.", doc_row(doc, request))

    update = partial_update

    def destroy(self, request, pk=None):
        doc = self._doc(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        if check_status(doc) == "Verified":
            return err("LOCKED", "A verified document cannot be deleted. Please contact HR.", 403)
        doc.is_active, doc.updated_by = False, self.actor()
        doc.save()
        return ok("MY_DOCUMENT_DELETED", "Document removed.", {"id": doc.id})

    @action(detail=True, methods=["post"], url_path="update")
    def update_post(self, request, pk=None):
        return self.partial_update(request, pk)

    @action(detail=True, methods=["post"], url_path="delete")
    def delete_post(self, request, pk=None):
        return self.destroy(request, pk)


class MyLettersViewSet(EmployeeBase, ViewSet):
    def _qs(self):
        return EmployeeLetter.objects.filter(company=self.company(), employee=self.me, is_active=True,
                                             status="Issued")

    def _row(self, l, request, body=False):
        r = {"id": l.id, "letter_no": l.letter_no, "letter_type": l.letter_type,
             "letter_type_label": dict(EmployeeLetter.TYPES).get(l.letter_type), "subject": l.subject,
             "issued_on": iso(l.issued_on), "view_url": f"/employee/vault/letters/{l.id}/pdf/",
             "download_url": f"/employee/vault/letters/{l.id}/download/"}
        if body:
            r["body"] = l.body
        return r

    def list(self, request):
        qs = self._qs()
        if request.query_params.get("letter_type"):
            qs = qs.filter(letter_type=request.query_params["letter_type"].upper())
        rows, meta = paginate(request, qs, lambda l: self._row(l, request))
        return ok("MY_LETTERS", "My letters.", rows, meta=meta)

    def retrieve(self, request, pk=None):
        l = self._qs().filter(pk=pk).first() if str(pk).isdigit() else None
        return ok("MY_LETTER", "Letter.", self._row(l, request, True)) if l else err("NOT_FOUND", "Letter not found.", 404)

    def _pdf(self, pk, inline):
        l = self._qs().filter(pk=pk).first() if str(pk).isdigit() else None
        if l is None or not l.pdf_file:
            from django.http import Http404
            raise Http404("Letter PDF not found.")
        return send_file(l.pdf_file, f"{l.letter_no}.pdf", inline=inline)

    @action(detail=True, methods=["get"])
    def download(self, request, pk=None):
        return self._pdf(pk, False)

    @action(detail=True, methods=["get"])
    def pdf(self, request, pk=None):
        return self._pdf(pk, True)


class _ReadOnlyFiles(EmployeeBase, ViewSet):
    model, prefix = None, ""

    def _qs(self):
        return self.model.objects.filter(company=self.company(), is_active=True)

    def _row(self, o):
        raise NotImplementedError

    def list(self, request):
        qs, q = self._qs(), (request.query_params.get("search") or "").strip()
        if q:
            qs = qs.filter(title__icontains=q)
        return ok("MY_FILES", "List fetched.", [self._row(o) for o in qs])

    def retrieve(self, request, pk=None):
        o = self._qs().filter(pk=pk).first() if str(pk).isdigit() else None
        return ok("MY_FILE", "Detail.", self._row(o)) if o else err("NOT_FOUND", "Not found.", 404)

    @action(detail=True, methods=["get"])
    def download(self, request, pk=None):
        o = self._qs().filter(pk=pk).first() if str(pk).isdigit() else None
        if o is None or not o.file:
            from django.http import Http404
            raise Http404("File not found.")
        return send_file(o.file)


class MyPoliciesViewSet(_ReadOnlyFiles):
    model, prefix = CompanyPolicy, "/employee/vault/policies/"

    def _row(self, o):
        sub = f"Version {o.version}" + (f" • Effective: {o.effective_date.strftime('%d %b %Y')}"
                                         if o.effective_date else "")
        if o.is_mandatory:
            sub += f" • {o.compliance_note or 'Mandatory Compliance'}"
        return {"id": o.id, "title": o.title, "version": o.version, "effective_date": iso(o.effective_date),
                "is_mandatory": o.is_mandatory, "compliance_note": o.compliance_note,
                "description": o.description, "subtitle": sub, "file_name": file_name(o.file),
                "download_url": f"{self.prefix}{o.id}/download/" if o.file else None}


class MyHRFormsViewSet(_ReadOnlyFiles):
    """Only category FORM is shared with employees; SOPs / manuals stay HR-internal."""
    model, prefix = HRDocument, "/employee/vault/hr-forms/"

    def _qs(self):
        return super()._qs().filter(category="FORM")

    def _row(self, o):
        return {"id": o.id, "title": o.title, "version": o.version, "description": o.description,
                "file_name": file_name(o.file),
                "download_url": f"{self.prefix}{o.id}/download/" if o.file else None}


router = SimpleRouter()
router.register(r"docs", MyDocumentsViewSet, basename="emp-vault-docs")
router.register(r"letters", MyLettersViewSet, basename="emp-vault-letters")
router.register(r"policies", MyPoliciesViewSet, basename="emp-vault-policies")
router.register(r"hr-forms", MyHRFormsViewSet, basename="emp-vault-hr-forms")
urlpatterns = router.urls
