# ============================================================
# ADDITIVE: Hiring Plus API  (mounted via Recruitment/urls_plus.py)
#
#   /api/recruitment/hiring-plus/...
# ============================================================
import logging
import os
import secrets
from datetime import timedelta

from django.conf import settings
from django.db import transaction
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.permissions import AllowAny
from rest_framework.throttling import SimpleRateThrottle
from rest_framework.views import APIView

from Employee.employee_crud_permissions import (AdminOrEmployeeJWTAuthentication, _role_is_usable,
                                                resolve_actor_role)
from rest_framework.viewsets import ViewSet

from Employee.models import EmployeeDocument, EmployeeDT

from . import hiring_plus as hp
from .common import (RecruitmentAuthMixin, recruitment_allows, candidate_by_ref, candidates_qs, emp_brief, employee_by_code, err,
                     get_profile, ok, set_stage, to_bool, to_date)
from .models import DocumentReview, JobRequisition, StageHistory
from .models_plus import (CandidateApproval, DocumentUploadLink, HikeApproval, HiringChecklistItem,
                          HiringQuestion, IdentityVerification, InterviewerAssignment, RequisitionRoles)

logger = logging.getLogger(__name__)
DOC_TYPES = dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES)
ALLOWED_EXT = {".pdf", ".jpg", ".jpeg", ".png"}
MAX_FILE = 10 * 1024 * 1024


def _cand(view, ref):
    # candidate first, then any person of the same company (so KYC also works for existing employees)
    return hp.person_by_ref(view.company(), ref)


def _nf(what="Candidate"):
    if what == "Candidate":
        return err("NOT_FOUND", "Candidate / employee not found in your company. Use the numeric id (or candidate_id / "
                                "employee_code) from GET /api/recruitment/candidates/ - it must belong to the same "
                                "company as the login token.", 404)
    return err("NOT_FOUND", f"{what} not found in your company (check the id and that your token is for the "
                            "same company).", 404)


def _need_m_level(view):
    if not hp.is_m_level(view.request.user):
        return err("FORBIDDEN", "Only an M-level role (manager / HR head / management) can take this decision.", 403)
    return None


# ============================================================
# serializers
# ============================================================
def ser_verification(v):
    return {"id": v.id, "candidate": v.candidate_id, "id_type": v.id_type, "status": v.status, "method": v.method,
            "id_masked": ("XXXX XXXX " + v.id_last4) if v.id_type == "AADHAAR" and v.id_last4
            else (("******" + v.id_last4) if v.id_last4 else None),
            "provider": v.provider, "name_on_record": v.name_on_record, "name_match": v.name_match,
            "dob_match": v.dob_match, "remarks": v.remarks, "verified_by": v.verified_by,
            "verified_at": v.verified_at, "updated_at": v.updated_at}


def ser_approval(a):
    c = a.candidate
    return {"id": a.id, "candidate": {"id": c.id, "candidate_id": c.candidate_id, "name": c.name,
                                      "applied_position": c.applied_position},
            "status": a.status, "maker": a.maker, "checker": a.checker, "remarks": a.remarks,
            "decided_at": a.decided_at, "created_at": a.created_at}


def ser_hike(h):
    c = h.candidate
    return {"id": h.id, "candidate": {"id": c.id, "candidate_id": c.candidate_id, "name": c.name},
            "offer_id": h.offer.offer_id if h.offer_id else None, "last_ctc_lpa": float(h.last_ctc_lpa),
            "offered_ctc_lpa": float(h.offered_ctc_lpa), "hike_percent": float(h.hike_percent),
            "limit_percent": float(h.limit_percent), "status": h.status, "requested_by": h.requested_by,
            "decided_by": h.decided_by, "decided_at": h.decided_at, "remarks": h.remarks,
            "notice": f"Policy violation - hike {h.hike_percent}% is above the {h.limit_percent}% limit - "
                      "management approval required"}


def ser_item(i):
    return {"id": i.id, "candidate": i.candidate_id, "title": i.title, "category": i.category,
            "doc_type": i.doc_type, "is_done": i.is_done, "done_by": i.done_by, "done_at": i.done_at,
            "due_date": i.due_date, "sort_order": i.sort_order}


def ser_question(q):
    return {"id": q.id, "requisition": q.requisition.requisition_id if q.requisition_id else None,
            "candidate": q.candidate_id, "question": q.question, "category": q.category, "answer": q.answer,
            "asked_by": q.asked_by, "sort_order": q.sort_order}


def ser_panel(p, request=None):
    return {"id": p.id, "candidate": p.candidate_id, "interviewer": emp_brief(p.interviewer, request),
            "round_name": p.round_name, "is_confirmed": p.is_confirmed}


def ser_link(l, request=None):
    base = str(getattr(settings, "SITE_BASE_URL", "")).rstrip("/")
    return {"id": l.id, "candidate": l.candidate_id, "document_types": l.document_types,
            "expires_at": l.expires_at, "max_uses": l.max_uses, "use_count": l.use_count, "revoked": l.revoked,
            "sent_to": l.sent_to, "last_used_at": l.last_used_at,
            "upload_url": f"{base}/api/recruitment/hiring-plus/public/upload/{l.token}/",
            "frontend_path": f"/candidate-upload/{l.token}"}


# ============================================================
# candidate level: kit / experience / jd / onboarding
# ============================================================
class CandidateKitView(RecruitmentAuthMixin, APIView):
    """GET /hiring-plus/candidates/<id>/kit/ - everything the candidate form side panel needs."""

    def get(self, request, pk):
        c = _cand(self, pk)
        if c is None:
            return _nf()
        hp.seed_checklist(c, self.actor())
        ap = CandidateApproval.objects.filter(candidate=c).first()
        from People.models import OnboardingRecord
        rec = OnboardingRecord.objects.filter(employee=c).first()
        return ok("HIRING_KIT", "Hiring kit.", {
            "candidate": {"id": c.id, "candidate_id": c.candidate_id, "name": c.name, "stage": c.candidate_status},
            "todo_checklist": [ser_item(i) for i in HiringChecklistItem.objects.filter(
                candidate=c, is_active=True, category="Todo")],
            "documentation_checklist": [ser_item(i) for i in HiringChecklistItem.objects.filter(
                candidate=c, is_active=True, category="Documentation")],
            "checklist_progress": hp.checklist_progress(c),
            "hiring_questions": [ser_question(q) for q in HiringQuestion.objects.filter(
                candidate=c, is_active=True)],
            "interviewers": [ser_panel(p, request) for p in InterviewerAssignment.objects.filter(
                candidate=c, is_active=True).select_related("interviewer")],
            "verification": {"readiness": hp.candidate_readiness(c),
                             "records": [ser_verification(v) for v in IdentityVerification.objects.filter(
                                 candidate=c, is_active=True)],
                             "summary": hp.verification_summary(c)},
            "approval": ser_approval(ap) if ap else None,
            "hike": hp.hike_info(c),
            # tokens are secrets: only users who can edit recruitment may see them
            "upload_links": ([ser_link(l, request) for l in DocumentUploadLink.objects.filter(
                candidate=c, revoked=False, expires_at__gt=timezone.now())]
                if recruitment_allows(request.user, "edit") else []),
            "onboarding": ({"status": rec.status, "tasks": [{"id": t.id, "title": t.title, "category": t.category,
                                                            "is_done": t.is_done} for t in rec.tasks.all()]}
                           if rec else None),
        })


class CandidateExperienceView(RecruitmentAuthMixin, APIView):
    """GET /hiring-plus/candidates/<id>/experience/ - fresher / years of exp + previous experience table."""

    def get(self, request, pk):
        c = _cand(self, pk)
        if c is None:
            return _nf()
        return ok("EXPERIENCE_TABLE", "Previous experience.", hp.experience_summary(c, request))


class CandidateJDView(RecruitmentAuthMixin, APIView):
    """GET /hiring-plus/candidates/<id>/jd/ - 'click to view JD'."""

    def get(self, request, pk):
        c = _cand(self, pk)
        if c is None:
            return _nf()
        prof = get_profile(c, create=False)
        if not prof or not prof.requisition_id:
            return err("NO_REQUISITION", "This candidate is not linked to a requisition.", 404)
        jd = getattr(prof.requisition, "job_description", None)
        if jd is None:
            return err("NO_JD", "No job description has been created for this requisition yet.", 404)
        from .views_core import serialize_jd
        return ok("CANDIDATE_JD", "Job description.", serialize_jd(jd, request))


class OnboardingTriggerView(RecruitmentAuthMixin, APIView):
    """POST /hiring-plus/candidates/<id>/onboarding/ - trigger Asset / Email / Desk / Kit / Documentation / NDA."""

    POST_OFFER = ("OFFER_ACCEPTED", "DOCS_PENDING", "BGV", "READY_TO_JOIN", "JOINED")

    def post(self, request, pk):
        c = _cand(self, pk)
        if c is None:
            return _nf()
        stage = (c.candidate_status or "").upper()
        if stage not in self.POST_OFFER and not to_bool(request.data.get("force")):
            return err("NOT_READY", "Onboarding can be triggered once the offer is accepted.")
        rec, created, added = hp.trigger_onboarding(self.company(), c, self.actor())
        return ok("ONBOARDING_TRIGGERED", "Onboarding triggered.", {
            "created": created, "tasks_added": added,
            "tasks": [{"id": t.id, "title": t.title, "category": t.category, "is_done": t.is_done}
                      for t in rec.tasks.all()]}, status=201 if created else 200)

    def get(self, request, pk):
        c = _cand(self, pk)
        if c is None:
            return _nf()
        from People.models import OnboardingRecord
        rec = OnboardingRecord.objects.filter(employee=c).first()
        return ok("ONBOARDING_STATUS", "Onboarding status.", None if rec is None else {
            "status": rec.status, "tasks": [{"id": t.id, "title": t.title, "category": t.category,
                                            "is_done": t.is_done} for t in rec.tasks.all()]})


# ============================================================
# checklist / questions / interviewer panel
# ============================================================
class ChecklistViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"toggle": "edit"}

    def _get(self, pk):
        return HiringChecklistItem.objects.filter(company=self.company(), pk=pk, is_active=True).first()

    def list(self, request):
        c = _cand(self, request.query_params.get("candidate"))
        if c is None:
            return err("VALIDATION", "?candidate=<id or candidate_id> is required.")
        hp.seed_checklist(c, self.actor())
        qs = HiringChecklistItem.objects.filter(candidate=c, is_active=True)
        return ok("CHECKLIST", "Checklist.", [ser_item(i) for i in qs], progress=hp.checklist_progress(c))

    def create(self, request):
        c = _cand(self, request.data.get("candidate"))
        if c is None:
            return _nf()
        title = (request.data.get("title") or "").strip()
        if not title:
            return err("VALIDATION", "title is required.")
        cat = request.data.get("category") or "Todo"
        if cat not in ("Todo", "Documentation"):
            return err("VALIDATION", "category must be Todo or Documentation.")
        i = HiringChecklistItem.objects.create(
            company=self.company(), candidate=c, title=title, category=cat, doc_type=request.data.get("doc_type"),
            due_date=to_date(request.data.get("due_date")), created_by=self.actor(), updated_by=self.actor(),
            sort_order=HiringChecklistItem.objects.filter(candidate=c).count() + 1)
        return ok("CHECKLIST_ITEM_CREATED", "Added.", ser_item(i), status=201)

    @action(detail=True, methods=["post"])
    def toggle(self, request, pk=None):
        i = self._get(pk)
        if i is None:
            return _nf("Item")
        done = to_bool(request.data.get("is_done"), default=not i.is_done)
        i.is_done, i.done_by = done, (self.actor() if done else None)
        i.done_at = timezone.now() if done else None
        i.updated_by = self.actor()
        i.save()
        return ok("CHECKLIST_ITEM_UPDATED", "Updated.", ser_item(i), progress=hp.checklist_progress(i.candidate))

    def partial_update(self, request, pk=None):
        i = self._get(pk)
        if i is None:
            return _nf("Item")
        for f in ("title", "doc_type"):
            if f in request.data:
                setattr(i, f, request.data.get(f))
        if "due_date" in request.data:
            try:
                i.due_date = to_date(request.data.get("due_date"))
            except ValueError as e:
                return err("VALIDATION", str(e))
        i.updated_by = self.actor()
        i.save()
        return ok("CHECKLIST_ITEM_UPDATED", "Updated.", ser_item(i))

    update = partial_update

    def destroy(self, request, pk=None):
        i = self._get(pk)
        if i is None:
            return _nf("Item")
        i.is_active = False
        i.save()
        return ok("CHECKLIST_ITEM_DELETED", "Removed.")


class HiringQuestionViewSet(RecruitmentAuthMixin, ViewSet):
    def _get(self, pk):
        return HiringQuestion.objects.filter(company=self.company(), pk=pk, is_active=True).first()

    def list(self, request):
        qs = HiringQuestion.objects.filter(company=self.company(), is_active=True)
        p = request.query_params
        if p.get("candidate"):
            c = _cand(self, p["candidate"])
            qs = qs.filter(candidate=c) if c else qs.none()
        if p.get("requisition"):
            qs = qs.filter(requisition__requisition_id=p["requisition"])
        return ok("HIRING_QUESTIONS", "Hiring questions.", [ser_question(q) for q in qs])

    def create(self, request):
        d, company = request.data, self.company()
        if not (d.get("question") or "").strip():
            return err("VALIDATION", "question is required.")
        c = _cand(self, d.get("candidate")) if d.get("candidate") else None
        r = JobRequisition.objects.filter(company=company, requisition_id=d.get("requisition"),
                                          is_active=True).first() if d.get("requisition") else None
        if c is None and r is None:
            return err("VALIDATION", "Send a valid candidate or requisition.")
        q = HiringQuestion.objects.create(company=company, candidate=c, requisition=r,
                                          question=d["question"].strip(), category=d.get("category"),
                                          answer=d.get("answer"), asked_by=self.actor(),
                                          created_by=self.actor(), updated_by=self.actor())
        return ok("HIRING_QUESTION_CREATED", "Added.", ser_question(q), status=201)

    def partial_update(self, request, pk=None):
        q = self._get(pk)
        if q is None:
            return _nf("Question")
        for f in ("question", "category", "answer"):
            if f in request.data:
                setattr(q, f, request.data.get(f))
        q.updated_by = self.actor()
        q.save()
        return ok("HIRING_QUESTION_UPDATED", "Updated.", ser_question(q))

    update = partial_update

    def destroy(self, request, pk=None):
        q = self._get(pk)
        if q is None:
            return _nf("Question")
        q.is_active = False
        q.save()
        return ok("HIRING_QUESTION_DELETED", "Removed.")


class InterviewerPanelViewSet(RecruitmentAuthMixin, ViewSet):
    """Interviewer identification for a candidate."""

    def _get(self, pk):
        return InterviewerAssignment.objects.filter(company=self.company(), pk=pk, is_active=True).first()

    def list(self, request):
        c = _cand(self, request.query_params.get("candidate"))
        if c is None:
            return err("VALIDATION", "?candidate=<id or candidate_id> is required.")
        qs = InterviewerAssignment.objects.filter(candidate=c, is_active=True).select_related("interviewer")
        return ok("INTERVIEWER_PANEL", "Interviewer panel.", [ser_panel(p, request) for p in qs])

    def create(self, request):
        d = request.data
        c = _cand(self, d.get("candidate"))
        if c is None:
            return _nf()
        try:
            iv = employee_by_code(self.company(), d.get("interviewer"))
        except ValueError as e:
            return err("VALIDATION", str(e))
        if iv is None:
            return err("VALIDATION", "interviewer (employee_code) is required.")
        if iv.pk == c.pk:
            return err("VALIDATION", "A candidate cannot interview themselves.")
        if not iv.is_active:
            return err("VALIDATION", "Interviewer must be an active employee.")
        rn = (d.get("round_name") or "").strip() or None
        p, created = InterviewerAssignment.objects.get_or_create(
            candidate=c, interviewer=iv, round_name=rn,
            defaults={"company": self.company(), "created_by": self.actor(), "updated_by": self.actor()})
        if not created and not p.is_active:
            p.is_active = True
            p.save()
        elif not created:
            return err("DUPLICATE", "This interviewer is already assigned for that round.", 409)
        return ok("INTERVIEWER_ASSIGNED", "Interviewer identified.", ser_panel(p, request), status=201)

    @action(detail=True, methods=["post"])
    def confirm(self, request, pk=None):
        p = self._get(pk)
        if p is None:
            return _nf("Assignment")
        p.is_confirmed, p.updated_by = True, self.actor()
        p.save()
        return ok("INTERVIEWER_CONFIRMED", "Confirmed.", ser_panel(p, request))

    def destroy(self, request, pk=None):
        p = self._get(pk)
        if p is None:
            return _nf("Assignment")
        p.is_active = False
        p.save()
        return ok("INTERVIEWER_REMOVED", "Removed.")

    permission_action_map = {"confirm": "edit"}


# ============================================================
# VERIFICATION: PAN / Aadhaar / Education / Experience
# ============================================================
def _upsert(company, c, id_type, actor):
    v, _ = IdentityVerification.objects.get_or_create(
        candidate=c, id_type=id_type, defaults={"company": company, "created_by": actor, "updated_by": actor})
    if not v.is_active:
        v.is_active = True
    return v


def _tick_checklist(c, title_part, actor):
    for i in HiringChecklistItem.objects.filter(candidate=c, is_done=False, title__icontains=title_part):
        i.is_done, i.done_by, i.done_at = True, actor, timezone.now()
        i.save()


def _duplicate_aadhaar(company, c, number):
    h = hp.id_hash(number)
    if EmployeeDT.objects.filter(company=company, aadhaar_number=number).exclude(pk=c.pk).exists():
        return True
    return IdentityVerification.objects.filter(company=company, id_type="AADHAAR", id_hash=h,
                                               status="Verified").exclude(candidate=c).exists()


class VerificationViewSet(RecruitmentAuthMixin, ViewSet):
    """
    GET  /hiring-plus/verifications/?candidate=<id>
    POST /hiring-plus/verifications/initiate/              {candidate, types?}
    POST /hiring-plus/verifications/aadhaar-validate/      {aadhaar_number, candidate?}   (offline, no OTP)
    POST /hiring-plus/verifications/aadhaar-send-otp/      {candidate, consent: true, aadhaar_number?}
    POST /hiring-plus/verifications/aadhaar-verify-otp/    {candidate, otp}
    POST /hiring-plus/verifications/<id>/verify/           {remarks}   manual / document verification
    POST /hiring-plus/verifications/<id>/reject/           {remarks}
    """
    permission_action_map = {"initiate": "edit", "upload_document": "edit", "aadhaar_validate": "view", "aadhaar_send_otp": "edit",
                             "aadhaar_verify_otp": "edit", "verify": "approve", "reject": "approve"}

    def _get(self, pk):
        return IdentityVerification.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("candidate").first()

    def list(self, request):
        c = _cand(self, request.query_params.get("candidate"))
        if c is None:
            return err("VALIDATION", "?candidate=<id or candidate_id> is required.")
        recs = IdentityVerification.objects.filter(candidate=c, is_active=True)
        return ok("VERIFICATIONS", "Verification status.", {
            "readiness": hp.candidate_readiness(c), "records": [ser_verification(v) for v in recs],
            "summary": hp.verification_summary(c)})

    # ---- initiate verification ------------------------------------------
    @action(detail=False, methods=["post"])
    @transaction.atomic
    def initiate(self, request):
        c = _cand(self, request.data.get("candidate"))
        if c is None:
            return _nf()
        types = [t.upper() for t in (request.data.get("types") or hp.VERIFY_TYPES)]
        bad = [t for t in types if t not in hp.VERIFY_TYPES]
        if bad:
            return err("VALIDATION", f"Unknown verification type(s): {', '.join(bad)}.")
        company, actor, ready, out = self.company(), self.actor(), hp.candidate_readiness(c), []
        for t in types:
            v = _upsert(company, c, t, actor)
            if v.status == "Verified":
                out.append(ser_verification(v))
                continue
            v.updated_by, v.remarks, v.meta = actor, None, {**(v.meta or {}), "readiness": ready[t]}
            if t == "AADHAAR":
                if not c.aadhaar_number:
                    v.status, v.remarks = "Pending", "Aadhaar number is missing on the candidate."
                else:
                    try:
                        n = hp.normalize_aadhaar(c.aadhaar_number)
                        if _duplicate_aadhaar(company, c, n):
                            v.status, v.remarks = "Failed", "This Aadhaar number is already used by another person."
                        else:
                            v.status, v.method = "Pending", "Checksum"
                            v.id_last4, v.id_hash = n[-4:], hp.id_hash(n)
                    except ValueError as e:
                        v.status, v.remarks = "Failed", str(e)
            elif t == "PAN":
                if not c.pan_number:
                    v.status, v.remarks = "Pending", "PAN number is missing on the candidate."
                else:
                    try:
                        pan = hp.normalize_pan(c.pan_number)
                        v.status, v.method, v.id_last4, v.id_hash = "Pending", "Checksum", pan[-4:], hp.id_hash(pan)
                        last = (c.name or "").split()[-1:] or [""]
                        v.meta["surname_initial_ok"] = (pan[4] == last[0][:1].upper()) if pan[3] == "P" else None
                    except ValueError as e:
                        v.status, v.remarks = "Failed", str(e)
            elif t == "EDUCATION":
                v.status = "Pending"
                v.remarks = None if ready[t]["ready"] else "Education details are missing."
            elif t == "EXPERIENCE":
                if ready[t]["fresher"]:
                    v.status, v.method, v.remarks = "Not Applicable", "None", "Fresher - no experience to verify."
                else:
                    v.status = "Pending"
            v.save()
            out.append(ser_verification(v))
        _tick_checklist(c, "verification", actor)
        return ok("VERIFICATION_INITIATED", "Verification initiated.", out,
                  summary=hp.verification_summary(c), readiness=ready)

    # ---- file upload (multipart) ----------------------------------------------
    @action(detail=False, methods=["post"], url_path="upload-document")
    @transaction.atomic
    def upload_document(self, request):
        """multipart: candidate, id_type (AADHAAR|PAN|EDUCATION|EXPERIENCE), file (pdf/jpg/png, max 10 MB)"""
        d = request.data
        c = _cand(self, d.get("candidate"))
        if c is None:
            return _nf()
        id_type = (d.get("id_type") or "").upper()
        if id_type not in hp.VERIFY_TYPES:
            return err("VALIDATION", "id_type must be one of: " + ", ".join(hp.VERIFY_TYPES))
        f = request.FILES.get("file")
        if f is None:
            return err("VALIDATION", "file is required (send as multipart/form-data, field name 'file').")
        if os.path.splitext(f.name)[1].lower() not in ALLOWED_EXT:
            return err("VALIDATION", "Only PDF, JPG or PNG files are accepted.")
        if f.size > MAX_FILE:
            return err("VALIDATION", "File too large (max 10 MB).")
        actor = self.actor()
        doc = EmployeeDocument.objects.create(
            company=self.company(), employee=c, document_type=id_type,
            document_name=(d.get("document_name") or f"{c.name} {DOC_TYPES.get(id_type, id_type)}"),
            file=f, created_by=actor, updated_by=actor)
        DocumentReview.objects.create(document=doc, status="Pending")
        HiringChecklistItem.objects.filter(candidate=c, doc_type=id_type, is_done=False).update(
            is_done=True, done_by=actor, done_at=timezone.now())
        return ok("VERIFICATION_DOCUMENT_UPLOADED", "Document uploaded.", {
            "document_id": doc.id, "id_type": id_type, "file_name": os.path.basename(doc.file.name),
            "file_url": request.build_absolute_uri(doc.file.url) if doc.file else None,
            "readiness": hp.candidate_readiness(c)[id_type]}, status=201)

    # ---- Aadhaar -----------------------------------------------------------
    @action(detail=False, methods=["post"], url_path="aadhaar-validate")
    def aadhaar_validate(self, request):
        c = _cand(self, request.data.get("candidate")) if request.data.get("candidate") else None
        try:
            n = hp.normalize_aadhaar(request.data.get("aadhaar_number") or (c.aadhaar_number if c else None))
        except ValueError as e:
            return ok("AADHAAR_CHECK", str(e), {"valid": False, "reason": str(e)})
        dup = _duplicate_aadhaar(self.company(), c or EmployeeDT(pk=-1), n)
        return ok("AADHAAR_CHECK", "Aadhaar number format and checksum are valid.", {
            "valid": True, "masked": hp.mask_aadhaar(n), "duplicate": dup,
            "linked_to_candidate": bool(c and c.aadhaar_number == n),
            "note": "This is an offline format check. Identity is confirmed only by OTP or document verification."})

    @action(detail=False, methods=["post"], url_path="aadhaar-send-otp")
    @transaction.atomic
    def aadhaar_send_otp(self, request):
        d = request.data
        c = _cand(self, d.get("candidate"))
        if c is None:
            return _nf()
        if not to_bool(d.get("consent")):
            return err("CONSENT_REQUIRED", "The candidate's consent to verify their Aadhaar is required "
                                           "(send consent=true).")
        try:
            n = hp.normalize_aadhaar(d.get("aadhaar_number") or c.aadhaar_number)
        except ValueError as e:
            return err("VALIDATION", str(e))
        # link the number to the candidate
        if c.aadhaar_number and c.aadhaar_number != n:
            if not to_bool(d.get("update_number")):
                return err("NUMBER_MISMATCH", "This number differs from the Aadhaar number saved on the candidate. "
                                              "Send update_number=true to replace it.", 409)
        if _duplicate_aadhaar(self.company(), c, n):
            return err("DUPLICATE_AADHAAR", "This Aadhaar number is already linked to another person.", 409)
        try:
            prov = hp.get_provider()
            res = prov.send_otp(n)
        except hp.ProviderUnavailable as e:
            return err("PROVIDER_UNAVAILABLE", str(e), 503)
        except hp.ProviderError as e:
            return err("PROVIDER_ERROR", str(e), 502)
        if c.aadhaar_number != n:
            c.aadhaar_number = n
            c.save(update_fields=["aadhaar_number"])
        v = _upsert(self.company(), c, "AADHAAR", self.actor())
        v.status, v.method, v.provider, v.provider_ref = "OTP Sent", "OTP", prov.name, res["ref"]
        v.id_last4, v.id_hash, v.updated_by, v.remarks = n[-4:], hp.id_hash(n), self.actor(), None
        v.meta = {**(v.meta or {}), "consent_at": timezone.now().isoformat(), "consent_by": self.actor()}
        v.save()
        return ok("AADHAAR_OTP_SENT", "OTP sent to the mobile number registered with Aadhaar.",
                  ser_verification(v))

    @action(detail=False, methods=["post"], url_path="aadhaar-verify-otp")
    @transaction.atomic
    def aadhaar_verify_otp(self, request):
        d = request.data
        c = _cand(self, d.get("candidate"))
        if c is None:
            return _nf()
        v = IdentityVerification.objects.filter(candidate=c, id_type="AADHAAR", is_active=True).first()
        if v is None or v.status != "OTP Sent" or not v.provider_ref:
            return err("NO_OTP_PENDING", "Send an OTP first.", 409)
        if not str(d.get("otp") or "").strip():
            return err("VALIDATION", "otp is required.")
        try:
            res = hp.get_provider().submit_otp(v.provider_ref, str(d["otp"]).strip())
        except hp.ProviderUnavailable as e:
            return err("PROVIDER_UNAVAILABLE", str(e), 503)
        except hp.ProviderError as e:
            return err("OTP_FAILED", str(e), 400)
        v.name_on_record = res.get("name")
        v.name_match = hp.names_match(res.get("name"), c.name) if res.get("name") else None
        v.dob_match = (str(res.get("dob"))[:10] == str(c.Date_of_Birth)) if res.get("dob") and c.Date_of_Birth else None
        v.meta = {**(v.meta or {}), "gender": res.get("gender")}
        v.updated_by = self.actor()
        if v.name_match is False or v.dob_match is False:
            v.status, v.remarks = "Mismatch", "Name / date of birth on Aadhaar does not match the candidate profile."
        else:
            v.status, v.verified_by, v.verified_at, v.remarks = "Verified", self.actor(), timezone.now(), None
        v.provider_ref = None          # one-time reference, not kept
        v.save()
        return ok("AADHAAR_VERIFIED" if v.status == "Verified" else "AADHAAR_MISMATCH",
                  "Aadhaar verified." if v.status == "Verified" else v.remarks, ser_verification(v),
                  summary=hp.verification_summary(c))

    # ---- manual / document verification ------------------------------------
    @action(detail=True, methods=["post"])
    @transaction.atomic
    def verify(self, request, pk=None):
        v = self._get(pk)
        if v is None:
            return _nf("Verification")
        remarks = (request.data.get("remarks") or "").strip()
        if not remarks:
            return err("VALIDATION", "remarks are required (what was checked, e.g. original seen / document ref).")
        ready = hp.candidate_readiness(v.candidate)[v.id_type]
        if v.id_type != "EXPERIENCE" and not ready["ready"]:
            return err("NOT_READY", f"{ready['missing']} is missing.", 409)
        if v.id_type in ("AADHAAR", "PAN", "EDUCATION") and not ready["has_document"]:
            return err("DOCUMENT_REQUIRED", "Upload the document before verifying it manually.", 409)
        if v.status == "Failed" and v.id_type in ("AADHAAR", "PAN"):
            return err("INVALID_STATE", "The number failed validation. Correct it and initiate again.", 409)
        v.status, v.method = "Verified", ("Manual" if v.method != "OTP" else v.method)
        v.remarks, v.verified_by, v.verified_at, v.updated_by = remarks, self.actor(), timezone.now(), self.actor()
        v.save()
        return ok("VERIFICATION_VERIFIED", "Marked as verified.", ser_verification(v),
                  summary=hp.verification_summary(v.candidate))

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        v = self._get(pk)
        if v is None:
            return _nf("Verification")
        remarks = (request.data.get("remarks") or "").strip()
        if not remarks:
            return err("VALIDATION", "remarks are required.")
        v.status, v.remarks, v.verified_by, v.verified_at = "Failed", remarks, self.actor(), timezone.now()
        v.updated_by = self.actor()
        v.save()
        return ok("VERIFICATION_FAILED", "Marked as failed.", ser_verification(v),
                  summary=hp.verification_summary(v.candidate))


# ============================================================
# MAKER / CHECKER on candidate creation
# ============================================================
class CandidateApprovalViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"approve": "approve", "reject": "approve", "resubmit": "edit"}

    def _get(self, pk):
        return CandidateApproval.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("candidate").first()

    def list(self, request):
        qs = CandidateApproval.objects.filter(company=self.company(), is_active=True).select_related("candidate")
        if request.query_params.get("status"):
            qs = qs.filter(status__iexact=request.query_params["status"])
        return ok("CANDIDATE_APPROVALS", "Candidate creation approvals.", [ser_approval(a) for a in qs],
                  can_decide=hp.is_m_level(request.user))

    def retrieve(self, request, pk=None):
        a = self._get(pk)
        return ok("CANDIDATE_APPROVAL", "Approval.", ser_approval(a)) if a else _nf("Approval")

    def _decide(self, request, pk, status):
        denied = _need_m_level(self)
        if denied:
            return denied
        a = self._get(pk)
        if a is None:
            return _nf("Approval")
        if a.status != "Pending":
            return err("INVALID_STATE", f"This request is already {a.status}.", 409)
        me = self.actor()
        if a.maker and a.maker == me and not getattr(settings, "HIRING_ALLOW_SELF_APPROVAL", False):
            return err("SELF_APPROVAL", "Maker and checker must be different people.", 403)
        remarks = (request.data.get("remarks") or "").strip()
        if status == "Rejected" and not remarks:
            return err("VALIDATION", "remarks are required when rejecting.")
        a.status, a.checker, a.remarks, a.decided_at, a.updated_by = status, me, remarks or None, timezone.now(), me
        a.save()
        StageHistory.objects.create(company=a.company, candidate=a.candidate, from_stage=a.candidate.candidate_status,
                                    to_stage=(a.candidate.candidate_status or "APPLIED"),
                                    note=f"Candidate creation {status.lower()} by checker" + (f": {remarks}" if remarks else ""),
                                    changed_by=me)
        if status == "Approved":
            _tick_checklist(a.candidate, "Checker", me)
        return ok(f"CANDIDATE_{status.upper()}", f"Candidate creation {status.lower()}.", ser_approval(a))

    @action(detail=True, methods=["post"])
    def approve(self, request, pk=None):
        return self._decide(request, pk, "Approved")

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        return self._decide(request, pk, "Rejected")

    @action(detail=True, methods=["post"])
    def resubmit(self, request, pk=None):
        a = self._get(pk)
        if a is None:
            return _nf("Approval")
        if a.status != "Rejected":
            return err("INVALID_STATE", "Only a rejected request can be re-submitted.", 409)
        a.status, a.maker, a.checker, a.decided_at, a.updated_by = "Pending", self.actor(), None, None, self.actor()
        a.save()
        return ok("CANDIDATE_RESUBMITTED", "Re-submitted for approval.", ser_approval(a))


# ============================================================
# HIKE POLICY approvals + CHRO dashboard notice
# ============================================================
class HikeApprovalViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"approve": "approve", "reject": "approve", "notices": "view"}

    def _get(self, pk):
        return HikeApproval.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("candidate", "offer").first()

    def list(self, request):
        qs = HikeApproval.objects.filter(company=self.company(), is_active=True).select_related("candidate", "offer")
        if request.query_params.get("status"):
            qs = qs.filter(status__iexact=request.query_params["status"])
        return ok("HIKE_APPROVALS", "Hike policy approvals.", [ser_hike(h) for h in qs],
                  limit_percent=float(hp.hike_limit_percent()), can_decide=hp.is_m_level(request.user))

    @action(detail=False, methods=["get"])
    def notices(self, request):
        """CHRO dashboard: every pending policy violation as a ready-to-show notice."""
        qs = HikeApproval.objects.filter(company=self.company(), is_active=True, status="Pending") \
            .select_related("candidate", "offer")
        rows = [ser_hike(h) for h in qs]
        return ok("HIKE_NOTICES", "Pending policy violations.", rows, pending=len(rows))

    def _decide(self, request, pk, status):
        denied = _need_m_level(self)
        if denied:
            return denied
        h = self._get(pk)
        if h is None:
            return _nf("Hike approval")
        if h.status != "Pending":
            return err("INVALID_STATE", f"Already {h.status}.", 409)
        remarks = (request.data.get("remarks") or "").strip()
        if not remarks:
            return err("VALIDATION", "remarks are required for a policy exception decision.")
        me = self.actor()
        if h.requested_by and h.requested_by == me and not getattr(settings, "HIRING_ALLOW_SELF_APPROVAL", False):
            return err("SELF_APPROVAL", "The person who raised the offer cannot approve its hike exception.", 403)
        h.status, h.decided_by, h.decided_at, h.remarks, h.updated_by = status, me, timezone.now(), remarks, me
        h.save()
        return ok(f"HIKE_{status.upper()}", f"Hike exception {status.lower()}.", ser_hike(h))

    @action(detail=True, methods=["post"])
    def approve(self, request, pk=None):
        return self._decide(request, pk, "Approved")

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        return self._decide(request, pk, "Rejected")


# ============================================================
# SHAREABLE DOCUMENT UPLOAD LINK
# ============================================================
class UploadLinkViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"revoke": "edit"}

    def list(self, request):
        if not recruitment_allows(request.user, "edit"):
            return err("FORBIDDEN", "Upload links can only be viewed by users who can edit recruitment.", 403)
        c = _cand(self, request.query_params.get("candidate"))
        if c is None:
            return err("VALIDATION", "?candidate=<id or candidate_id> is required.")
        return ok("UPLOAD_LINKS", "Upload links.", [ser_link(l, request) for l in
                                                    DocumentUploadLink.objects.filter(candidate=c, is_active=True)])

    @transaction.atomic
    def create(self, request):
        d = request.data
        c = _cand(self, d.get("candidate"))
        if c is None:
            return _nf()
        types = d.get("document_types") or [i.doc_type for i in HiringChecklistItem.objects.filter(
            candidate=c, category="Documentation", is_done=False, is_active=True).exclude(doc_type__isnull=True)]
        types = [t.upper() for t in (types if isinstance(types, list) else str(types).split(",")) if t]
        types = [t for t in types if t in DOC_TYPES] or ["AADHAAR", "PAN", "EDUCATION", "BANK"]
        bad = [t for t in (d.get("document_types") or []) if str(t).upper() not in DOC_TYPES]
        if bad:
            return err("VALIDATION", f"Unknown document type(s): {', '.join(map(str, bad))}.")
        try:
            days = min(max(int(d.get("expires_in_days") or 7), 1), 30)
            uses = min(max(int(d.get("max_uses") or 20), 1), 100)
        except (TypeError, ValueError):
            return err("VALIDATION", "expires_in_days / max_uses must be numbers.")
        link = DocumentUploadLink.objects.create(
            company=self.company(), candidate=c, token=secrets.token_urlsafe(32), document_types=types,
            expires_at=timezone.now() + timedelta(days=days), max_uses=uses,
            created_by=self.actor(), updated_by=self.actor())
        mailed = False
        to = (d.get("send_to") or (c.email if to_bool(d.get("send_email")) else None))
        if to:
            try:
                from django.core.mail import send_mail
                page = str(getattr(settings, "SITE_BASE_URL", "") or "").rstrip("/") + ser_link(link, request)["frontend_path"]
                send_mail("Please upload your joining documents",
                          f"Hello {c.name},\n\nPlease upload the following documents: {', '.join(types)}.\n"
                          f"Link (valid {days} days): {page}\n\nHR Team",
                          getattr(settings, "DEFAULT_FROM_EMAIL", None), [to], fail_silently=False)
                link.sent_to, mailed = to, True
                link.save(update_fields=["sent_to", "updated_at"])
            except Exception:
                logger.exception("upload link email failed")
        return ok("UPLOAD_LINK_CREATED", "Upload link created.", ser_link(link, request), status=201,
                  email_sent=mailed)

    @action(detail=True, methods=["post"])
    def revoke(self, request, pk=None):
        l = DocumentUploadLink.objects.filter(company=self.company(), pk=pk, is_active=True).first()
        if l is None:
            return _nf("Link")
        l.revoked, l.updated_by = True, self.actor()
        l.save()
        return ok("UPLOAD_LINK_REVOKED", "Link revoked.", ser_link(l, request))


class PublicUploadThrottle(SimpleRateThrottle):
    rate = "30/min"
    scope = "hiring_public_upload"

    def get_cache_key(self, request, view):
        return f"throttle_{self.scope}_{self.get_ident(request)}"


class PublicUploadView(APIView):
    """GET/POST /hiring-plus/public/upload/<token>/ - no login, token only."""
    authentication_classes = []
    permission_classes = [AllowAny]
    throttle_classes = [PublicUploadThrottle]

    def _link(self, token):
        l = DocumentUploadLink.objects.filter(token=token, is_active=True).select_related("candidate", "company").first()
        if l is None:
            return None, err("INVALID_LINK", "This link is not valid.", 404)
        if l.revoked or l.expires_at < timezone.now() or l.use_count >= l.max_uses:
            return None, err("LINK_EXPIRED", "This link has expired. Please ask HR for a new one.", 410)
        return l, None

    def get(self, request, token):
        l, e = self._link(token)
        if e:
            return e
        uploaded = set(EmployeeDocument.objects.filter(employee=l.candidate, is_active=True)
                       .values_list("document_type", flat=True))
        co = getattr(l.company, "Registered_Company_Name", None) or str(l.company)
        return ok("UPLOAD_LINK", "Upload your documents.", {
            "candidate_name": (l.candidate.name or "").split(" ")[0], "company": co, "expires_at": l.expires_at,
            "documents": [{"code": t, "label": DOC_TYPES.get(t, t), "uploaded": t in uploaded}
                          for t in l.document_types],
            "allowed_types": sorted(ALLOWED_EXT), "max_mb": MAX_FILE // (1024 * 1024)})

    @transaction.atomic
    def post(self, request, token):
        l, e = self._link(token)
        if e:
            return e
        dtype = (request.data.get("document_type") or "").upper()
        if dtype not in l.document_types:
            return err("VALIDATION", "This document type is not requested on this link.")
        f = request.FILES.get("file")
        if f is None:
            return err("VALIDATION", "file is required.")
        if os.path.splitext(f.name)[1].lower() not in ALLOWED_EXT:
            return err("VALIDATION", "Only PDF, JPG or PNG files are accepted.")
        if f.size > MAX_FILE:
            return err("VALIDATION", "File too large (max 10 MB).")
        c, actor = l.candidate, f"candidate-link:{l.pk}"
        doc = EmployeeDocument.objects.create(
            company=l.company, employee=c, document_type=dtype, document_name=f"{c.name} {DOC_TYPES.get(dtype, dtype)}",
            file=f, created_by=actor, updated_by=actor)
        DocumentReview.objects.create(document=doc, status="Pending")
        l.use_count, l.last_used_at = l.use_count + 1, timezone.now()
        l.save(update_fields=["use_count", "last_used_at", "updated_at"])
        HiringChecklistItem.objects.filter(candidate=c, doc_type=dtype, is_done=False).update(
            is_done=True, done_by=actor, done_at=timezone.now())
        if (c.candidate_status or "").upper() == "OFFER_ACCEPTED":
            set_stage(c, "DOCS_PENDING", actor, "Documents uploaded via link")
        return ok("DOCUMENT_UPLOADED", "Document received. Thank you.", {"document_type": dtype}, status=201)


# ============================================================
# REQUISITION role map (HCM / reporting manager / performance reviewer)
# ============================================================
class RequisitionRolesView(RecruitmentAuthMixin, APIView):
    """GET / PATCH /hiring-plus/requisitions/<id>/roles/"""

    def _req(self, pk):
        return JobRequisition.objects.filter(company=self.company(), is_active=True).filter(
            pk=pk if str(pk).isdigit() else -1).first()

    def get(self, request, pk):
        r = self._req(pk)
        if r is None:
            return _nf("Requisition")
        return ok("REQUISITION_ROLES", "Post-hire roles.", hp.requisition_extra(r)["roles"])

    def patch(self, request, pk):
        r = self._req(pk)
        if r is None:
            return _nf("Requisition")
        company, rm = self.company(), RequisitionRoles.objects.filter(requisition=r).first()
        if rm is None:
            rm = RequisitionRoles(company=company, requisition=r, created_by=self.actor())
        try:
            for f in ("hcm", "reporting_manager", "performance_reviewer"):
                if f in request.data:
                    emp = employee_by_code(company, request.data.get(f))
                    if emp is not None and not emp.is_active:
                        raise ValueError(f"{f}: employee must be active.")
                    setattr(rm, f, emp)
        except ValueError as e:
            return err("VALIDATION", str(e))
        rm.updated_by = self.actor()
        rm.save()
        r.refresh_from_db()
        return ok("REQUISITION_ROLES_UPDATED", "Updated.", hp.requisition_extra(r)["roles"])

    put = patch


class HiringPlusMetaView(RecruitmentAuthMixin, APIView):
    def get(self, request):
        return ok("HIRING_PLUS_META", "Hiring plus settings.", {
            "notice_period_options": hp.notice_period_options(),
            "hike_limit_percent": float(hp.hike_limit_percent()),
            "verification_types": hp.VERIFY_TYPES,
            "document_types": [{"code": k, "label": v} for k, v in DOC_TYPES.items()],
            "m_level_role_codes": sorted(hp.m_level_role_codes()),
            "can_decide": hp.is_m_level(request.user),
            "aadhaar_provider": str(getattr(settings, "HIRING_AADHAAR_PROVIDER", "manual")).lower(),
            "require_id_verification": bool(getattr(settings, "HIRING_REQUIRE_ID_VERIFICATION", False)),
            "onboarding_resources": [c for _, c in hp.ONBOARDING_RESOURCES],
        })


# ============================================================
# DIAGNOSTICS: use these first when an API returns 404 / 401 / 403
# ============================================================
class HealthView(APIView):
    """GET /hiring-plus/health/  (no login) - is the new code loaded and are the tables migrated?"""
    authentication_classes = []
    permission_classes = [AllowAny]

    def get(self, request):
        try:
            tables = hp.table_health()
        except Exception:
            logger.exception("table_health failed")
            tables = {}
        missing = [t for t, ok_ in tables.items() if not ok_]
        return ok("HIRING_PLUS_HEALTH", "Hiring Plus module is loaded." if not missing
                  else "Hiring Plus code is loaded but migrations are missing - run: python manage.py migrate",
                  {"module": "hiring-plus", "version": hp.HIRING_PLUS_VERSION, "tables_ready": not missing,
                   "missing_tables": missing})


class WhoAmIView(APIView):
    """GET /hiring-plus/whoami/ - what does this token resolve to (Admin / HR / Employee, which company)?"""
    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = []

    def get(self, request):
        u = request.user
        actor = resolve_actor_role(u)
        if actor is None:
            return err("UNAUTHENTICATED", "Send header  Authorization: Bearer <access token>  taken from "
                       "POST /company/auth/login/ (Admin) or POST /employee/auth/login/ (HR / Employee). "
                       "SuperAdmin platform logins are not company users and cannot call these APIs.", 401)
        from .common import resolve_company_for_user
        company = resolve_company_for_user(u)
        role = None if actor == "admin" else _role_is_usable(u)
        return ok("WHOAMI", "Token is valid.", {
            "login_type": "company_admin" if actor == "admin" else "employee",
            "actor": actor,                                   # admin | hr | employee
            "company": {"company_id": getattr(company, "company_id", None),
                        "name": getattr(company, "Registered_Company_Name", None) or str(company)},
            "employee": None if actor == "admin" else {"employee_code": u.employee_code, "name": u.name,
                                                       "role_code": getattr(role, "role_code", None)},
            "recruitment_access": {a: recruitment_allows(u, a) for a in ("view", "create", "edit", "approve", "delete")},
            "m_level_checker": hp.is_m_level(u),
            "note": "Data is isolated per company (B2B): ids from another company return 404.",
        })
