# ============================================================
# 11 Candidate Documents | 12 Background Verification | 13 Joining Tracker
# (Joining Tracker converts a candidate into a real Employee)
# ============================================================
from django.db import transaction
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.views import APIView
from rest_framework.viewsets import ViewSet

from Employee.models import (
    CandidateBGV, CandidateCompensation, EmployeeAccount, EmployeeDocument, EmployeeRole,
)

from .common import (
    RecruitmentAuthMixin, ok, err, to_date, to_decimal, to_list, candidates_qs, candidate_brief,
    emp_brief, set_stage, get_profile,
)
from .models import BGVCase, CandidateSelection, DocumentReview, Offer
from . import hiring_plus as hp   # ADDITIVE: onboarding trigger + post-hire roles

REQUIRED_DOC_TYPES = ["AADHAAR", "PAN", "EDUCATION", "BANK"]
POST_OFFER_STAGES = ["OFFER_ACCEPTED", "DOCS_PENDING", "BGV", "READY_TO_JOIN"]


# ------------------------------------------------------------
# document helpers
# ------------------------------------------------------------
def doc_status(doc):
    rev = getattr(doc, "review", None) if hasattr(doc, "review") else None
    try:
        rev = doc.review
    except DocumentReview.DoesNotExist:
        rev = None
    if rev:
        return rev.status
    return "Verified" if doc.is_verified else "Pending"


def serialize_doc(doc, request=None):
    try:
        rev = doc.review
    except DocumentReview.DoesNotExist:
        rev = None
    return {
        "id": doc.id,
        "candidate": candidate_brief(doc.employee, request),
        "document_name": doc.document_name,
        "document_type": doc.document_type,
        "type_label": doc.get_document_type_display(),
        "status": doc_status(doc),
        "remarks": rev.remarks if rev else doc.remarks,
        "verified_by": doc.verified_by,
        "verified_at": doc.verified_at,
        "file_url": request.build_absolute_uri(doc.file.url) if request and doc.file else None,
        "uploaded_at": doc.uploaded_at,
    }


def docs_summary(candidate):
    docs = list(EmployeeDocument.objects.filter(employee=candidate, is_active=True))
    by_type = {}
    for d in docs:
        by_type.setdefault(d.document_type, []).append(doc_status(d))
    verified_req = [t for t in REQUIRED_DOC_TYPES if "Verified" in by_type.get(t, [])]
    pending = sum(1 for d in docs if doc_status(d) == "Pending")
    rejected = sum(1 for d in docs if doc_status(d) == "Rejected")
    return {
        "required_types": REQUIRED_DOC_TYPES,
        "missing_types": [t for t in REQUIRED_DOC_TYPES if t not in by_type],
        "required_total": len(REQUIRED_DOC_TYPES),
        "required_verified": len(verified_req),
        "percent_verified": round(len(verified_req) * 100 / len(REQUIRED_DOC_TYPES)),
        "pending": pending,
        "rejected": rejected,
        "complete": len(verified_req) == len(REQUIRED_DOC_TYPES) and rejected == 0,
        "total": len(docs),
    }


def advance_after_docs(candidate, actor):
    stage = (candidate.candidate_status or "").upper()
    summ = docs_summary(candidate)
    if stage in ("OFFER_ACCEPTED", "DOCS_PENDING") and summ["complete"]:
        set_stage(candidate, "BGV", actor, "All required documents verified")
    elif stage in ("BGV", "READY_TO_JOIN") and not summ["complete"]:
        set_stage(candidate, "DOCS_PENDING", actor, "A document needs attention")


def advance_after_bgv(candidate, actor):
    stage = (candidate.candidate_status or "").upper()
    if stage == "BGV" and docs_summary(candidate)["complete"] and \
            BGVCase.objects.filter(candidate=candidate, status="Verified").exists():
        set_stage(candidate, "READY_TO_JOIN", actor, "Documents & BGV cleared")


class CandidateDocumentViewSet(RecruitmentAuthMixin, ViewSet):
    """
    GET  /api/recruitment/documents/?candidate=<id>&status=Pending
    POST /api/recruitment/documents/            multipart: candidate, document_type, document_name, file
    GET  /api/recruitment/documents/summary/?candidate=<id>
    POST /api/recruitment/documents/<id>/verify/
    POST /api/recruitment/documents/<id>/reject/     {reason}
    """
    permission_action_map = {"verify": "approve", "reject": "approve", "summary": "view"}

    def _get(self, pk):
        return EmployeeDocument.objects.filter(
            company=self.company(), pk=pk, is_active=True,
            employee__in=candidates_qs(self.company())).select_related("employee").first()

    def list(self, request):
        company = self.company()
        qs = EmployeeDocument.objects.filter(company=company, is_active=True,
                                             employee__in=candidates_qs(company)).select_related("employee")
        p = request.query_params
        if p.get("candidate"):
            qs = qs.filter(employee_id=p["candidate"])
        else:
            # desk view: candidates who already accepted an offer
            qs = qs.filter(employee__candidate_status__in=POST_OFFER_STAGES + ["JOINED"])
        if p.get("document_type"):
            qs = qs.filter(document_type=p["document_type"].upper())
        data = [serialize_doc(d, request) for d in qs.order_by("employee_id", "document_type")]
        if p.get("status"):
            data = [d for d in data if d["status"].lower() == p["status"].lower()]
        return ok("DOCUMENT_LIST", "Candidate document verification desk.", data)

    @transaction.atomic
    def create(self, request):
        company = self.company()
        d = request.data
        cand = candidates_qs(company).filter(pk=d.get("candidate") if str(d.get("candidate")).isdigit() else -1).first()
        if cand is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        dtype = (d.get("document_type") or "").upper()
        if dtype not in dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES):
            return err("VALIDATION", "document_type must be one of: " +
                       ", ".join(dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES)))
        f = request.FILES.get("file")
        if f is None:
            return err("VALIDATION", "file is required (multipart/form-data).")
        if f.size > 10 * 1024 * 1024:
            return err("VALIDATION", "File too large (max 10 MB).")
        doc = EmployeeDocument.objects.create(
            company=company, employee=cand, document_type=dtype,
            document_name=d.get("document_name") or f"{cand.name} {dtype.title()}",
            file=f, created_by=self.actor(), updated_by=self.actor())
        DocumentReview.objects.create(document=doc, status="Pending")
        if (cand.candidate_status or "").upper() == "OFFER_ACCEPTED":
            set_stage(cand, "DOCS_PENDING", self.actor(), "Documents uploaded")
        return ok("DOCUMENT_UPLOADED", "Document uploaded.", serialize_doc(doc, request), status=201)

    def retrieve(self, request, pk=None):
        doc = self._get(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        return ok("DOCUMENT_DETAIL", "Document.", serialize_doc(doc, request))

    @transaction.atomic
    def partial_update(self, request, pk=None):
        doc = self._get(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        d = request.data
        if d.get("document_type"):
            dtype = d["document_type"].upper()
            if dtype not in dict(EmployeeDocument.DOCUMENT_TYPE_CHOICES):
                return err("VALIDATION", "Invalid document_type.")
            doc.document_type = dtype
        if d.get("document_name"):
            doc.document_name = d["document_name"]
        try:
            if "expiry_date" in d:
                doc.expiry_date = to_date(d.get("expiry_date"))
        except ValueError as e:
            return err("VALIDATION", str(e))
        f = request.FILES.get("file")
        if f is not None:
            if f.size > 10 * 1024 * 1024:
                return err("VALIDATION", "File too large (max 10 MB).")
            doc.file = f
        if f is not None or d.get("document_type"):
            # a changed file / type must be verified again
            doc.is_verified, doc.verified_by, doc.verified_at = False, None, None
            rev, _ = DocumentReview.objects.get_or_create(document=doc)
            rev.status, rev.remarks, rev.reviewed_by, rev.reviewed_at = "Pending", None, None, None
            rev.save()
        doc.updated_by = self.actor()
        doc.save()
        advance_after_docs(doc.employee, self.actor())
        return ok("DOCUMENT_UPDATED", "Document updated.", serialize_doc(doc, request),
                  summary=docs_summary(doc.employee), stage=doc.employee.candidate_status)

    update = partial_update

    @transaction.atomic
    def destroy(self, request, pk=None):
        doc = self._get(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        cand = doc.employee
        doc.is_active = False
        doc.save(update_fields=["is_active", "updated_at"])
        advance_after_docs(cand, self.actor())
        return ok("DOCUMENT_DELETED", "Document deleted.", summary=docs_summary(cand),
                  stage=cand.candidate_status)

    @action(detail=False, methods=["get"])
    def summary(self, request):
        cand = candidates_qs(self.company()).filter(pk=request.query_params.get("candidate") or -1).first()
        if cand is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        return ok("DOCUMENT_SUMMARY", "Document verification summary.", docs_summary(cand))

    def _review(self, request, pk, status, reason=None):
        doc = self._get(pk)
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        if status == "Rejected" and not reason:
            return err("VALIDATION", "reason is required to reject a document.")
        rev, _ = DocumentReview.objects.get_or_create(document=doc)
        rev.status, rev.remarks, rev.reviewed_by, rev.reviewed_at = status, reason, self.actor(), timezone.now()
        rev.save()
        doc.is_verified = status == "Verified"
        doc.verified_by = self.actor() if status == "Verified" else None
        doc.verified_at = timezone.now() if status == "Verified" else None
        doc.remarks = reason if reason else doc.remarks
        doc.updated_by = self.actor()
        doc.save()
        advance_after_docs(doc.employee, self.actor())
        return ok("DOCUMENT_" + status.upper(), f"Document {status.lower()}.",
                  serialize_doc(doc, request), summary=docs_summary(doc.employee),
                  stage=doc.employee.candidate_status)

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def verify(self, request, pk=None):
        return self._review(request, pk, "Verified")

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def reject(self, request, pk=None):
        return self._review(request, pk, "Rejected", request.data.get("reason"))


# ------------------------------------------------------------
# 12. BACKGROUND VERIFICATION
# ------------------------------------------------------------
def serialize_bgv(b, request=None):
    return {
        "id": b.id,
        "candidate": candidate_brief(b.candidate, request),
        "agency": b.agency,
        "checks": b.checks,
        "checks_summary": f"{len(b.checks or [])} Check Modules ({', '.join(b.checks or [])})",
        "status": b.status,
        "result": b.result,
        "result_note": b.result_note,
        "report_url": request.build_absolute_uri(b.report.url) if request and b.report else None,
        "completed_at": b.completed_at,
        "created_at": b.created_at,
    }


def _sync_candidate_bgv(b, verified):
    """Keep the EXISTING CandidateBGV record in sync."""
    obj, _ = CandidateBGV.objects.get_or_create(employee=b.candidate)
    obj.assigned_verification_agency = b.agency
    obj.remarks = b.result_note
    if verified:
        for f in ("previous_employment_verification", "education_verification",
                  "address_verification", "identity_verification"):
            setattr(obj, f, "Verified")
        obj.verified_at = timezone.now()
    obj.save()


class BGVViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"mark_cleared": "approve", "mark_failed": "approve", "report": "view"}

    def _get(self, pk):
        return BGVCase.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("candidate").first()

    def list(self, request):
        qs = BGVCase.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("BGV_LIST", "Background verification & exception dashboard.",
                  [serialize_bgv(b, request) for b in qs.order_by("-created_at")])

    @transaction.atomic
    def create(self, request):
        d = request.data
        company = self.company()
        cand = candidates_qs(company).filter(pk=d.get("candidate") if str(d.get("candidate")).isdigit() else -1).first()
        if cand is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        if (cand.candidate_status or "").upper() not in POST_OFFER_STAGES:
            return err("INVALID_STATE", "BGV can start only after the candidate accepts the offer.")
        if BGVCase.objects.filter(candidate=cand).exists():
            return err("DUPLICATE", "A BGV case already exists for this candidate.", 409)
        checks = to_list(d.get("checks")) or ["National ID", "Edu", "Emp", "Criminal"]
        b = BGVCase.objects.create(company=company, candidate=cand, agency=d.get("agency"), checks=checks,
                                   status="In Progress", created_by=self.actor(), updated_by=self.actor())
        _sync_candidate_bgv(b, verified=False)
        advance_after_docs(cand, self.actor())
        return ok("BGV_INITIATED", "BGV initiated.", serialize_bgv(b, request), status=201)

    def retrieve(self, request, pk=None):
        b = self._get(pk)
        if b is None:
            return err("NOT_FOUND", "BGV case not found.", 404)
        return ok("BGV_DETAIL", "BGV case.", serialize_bgv(b, request))

    def partial_update(self, request, pk=None):
        b = self._get(pk)
        if b is None:
            return err("NOT_FOUND", "BGV case not found.", 404)
        if b.status in ("Verified", "Failed"):
            return err("INVALID_STATE", f"A {b.status} BGV case is closed.")
        d = request.data
        if "agency" in d:
            b.agency = d.get("agency")
        if "checks" in d:
            b.checks = to_list(d.get("checks"))
        if "result_note" in d:
            b.result_note = d.get("result_note")
        if request.FILES.get("report"):
            b.report = request.FILES["report"]
        b.updated_by = self.actor()
        b.save()
        _sync_candidate_bgv(b, verified=False)
        return ok("BGV_UPDATED", "BGV updated.", serialize_bgv(b, request))

    update = partial_update

    @transaction.atomic
    def destroy(self, request, pk=None):
        b = self._get(pk)
        if b is None:
            return err("NOT_FOUND", "BGV case not found.", 404)
        cand = b.candidate
        b.is_active = False
        b.save(update_fields=["is_active", "updated_at"])
        b.delete()          # unique per candidate -> free the slot so BGV can be re-initiated
        if (cand.candidate_status or "").upper() == "READY_TO_JOIN":
            set_stage(cand, "BGV", self.actor(), "BGV case deleted")
        return ok("BGV_DELETED", "BGV case deleted.")

    @action(detail=True, methods=["get"])
    def report(self, request, pk=None):
        b = self._get(pk)
        if b is None:
            return err("NOT_FOUND", "BGV case not found.", 404)
        return ok("BGV_REPORT", "BGV report.", serialize_bgv(b, request))

    @action(detail=True, methods=["post"], url_path="mark-cleared")
    @transaction.atomic
    def mark_cleared(self, request, pk=None):
        b = self._get(pk)
        if b is None:
            return err("NOT_FOUND", "BGV case not found.", 404)
        if b.status in ("Verified", "Failed"):
            return err("INVALID_STATE", f"BGV is already {b.status}.")
        b.status, b.result, b.completed_at = "Verified", "Clean", timezone.now()
        b.result_note = request.data.get("note") or b.result_note or "Clean - no adverse findings"
        b.updated_by = self.actor()
        b.save()
        _sync_candidate_bgv(b, verified=True)
        advance_after_bgv(b.candidate, self.actor())
        return ok("BGV_CLEARED", "BGV cleared.", serialize_bgv(b, request), stage=b.candidate.candidate_status)

    @action(detail=True, methods=["post"], url_path="mark-failed")
    @transaction.atomic
    def mark_failed(self, request, pk=None):
        b = self._get(pk)
        if b is None:
            return err("NOT_FOUND", "BGV case not found.", 404)
        if not request.data.get("note"):
            return err("VALIDATION", "note (adverse finding) is required.")
        if b.status in ("Verified", "Failed"):
            return err("INVALID_STATE", f"BGV is already {b.status}.")
        b.status, b.result, b.completed_at = "Failed", "Adverse", timezone.now()
        b.result_note, b.updated_by = request.data.get("note"), self.actor()
        b.save()
        _sync_candidate_bgv(b, verified=False)
        return ok("BGV_FAILED", "BGV marked as adverse. Review the candidate (reject or override).",
                  serialize_bgv(b, request))


# ------------------------------------------------------------
# 13. JOINING TRACKER  (+ candidate -> employee conversion)
# ------------------------------------------------------------
def joining_row(c, request=None):
    prof = get_profile(c, create=False)
    sel = CandidateSelection.objects.filter(candidate=c).select_related("requisition", "reporting_manager").first()
    offer = Offer.objects.filter(candidate=c, status="Accepted").order_by("-created_at").first()
    req = (sel.requisition if sel else None) or (prof.requisition if prof else None)
    bgv = BGVCase.objects.filter(candidate=c).first()
    summ = docs_summary(c)
    return {
        "candidate": candidate_brief(c, request),
        "position": req.position_title if req else c.applied_position,
        "department": (req.department.name if req and req.department_id else (req.department_name if req else None)),
        "target_joining_date": (offer.target_joining_date if offer else None) or
                               (sel.joining_date if sel else None) or c.expected_joining_date,
        "reporting_manager": emp_brief(sel.reporting_manager, request) if sel else None,
        "offer_id": offer.offer_id if offer else None,
        "documents": summ,
        "bgv_status": bgv.status if bgv else "Not Started",
        "preboarding_status": f"{summ['percent_verified']}% Preboarding Verified",
        "stage": (c.candidate_status or "").upper(),
        "ready": (c.candidate_status or "").upper() == "READY_TO_JOIN",
    }


@transaction.atomic
def convert_to_employee(company, c, d, actor):
    """Same effect as Employee/candidate_convert_views.py (kept untouched),
    plus pipeline bookkeeping. Returns (employee, account_created, role)."""
    if not c.email:
        raise ValueError("Email is required for login. Add an email first.")
    new_password = d.get("password")
    if not new_password and not c.password:
        raise ValueError("Password is required to create the login.")
    if new_password and len(str(new_password)) > 50:
        raise ValueError("Password must be 50 characters or fewer.")

    joining = to_date(d.get("date_of_joining"))
    sel = CandidateSelection.objects.filter(candidate=c).select_related("requisition").first()
    offer = Offer.objects.filter(candidate=c, status="Accepted").order_by("-created_at").first()
    req = sel.requisition if sel else None

    c.Employee_Status, c.is_active = "Activate", True
    c.Date_of_Joining = (joining or (offer.target_joining_date if offer else None)
                         or (sel.joining_date if sel else None) or c.Date_of_Joining
                         or timezone.localdate())
    if new_password:
        c.password = new_password
    if d.get("employee_type"):
        c.Employee_Type = d["employee_type"]
    c.Designation = d.get("designation") or c.Designation or (req.position_title if req else c.applied_position)
    if d.get("department"):
        c.Department = d["department"]
    elif req and not c.Department:
        c.Department = req.department.name if req.department_id else req.department_name
    if req and req.department_id and not c.department_id:
        c.department = req.department
    salary = to_decimal(d.get("basic_salary"))
    if salary is None:
        comp = CandidateCompensation.objects.filter(employee=c).first()
        salary = comp.basic_salary if comp else None
    if salary is not None:
        c.Basic_Salary = salary
    c.updated_by = actor
    c.save()

    role_code = (d.get("role_code") or "employee").strip()
    role, _ = EmployeeRole.objects.get_or_create(
        company=company, role_code=role_code,
        defaults={"role_name": role_code.replace("_", " ").title()})
    account, created = EmployeeAccount.objects.get_or_create(
        employee=c, defaults={"role": role, "is_login_enabled": True, "is_verified": True})
    if not created:
        account.role, account.is_login_enabled, account.is_verified = role, True, True
        account.failed_login_attempts = 0
        account.save()
    set_stage(c, "JOINED", actor, "Converted to employee")
    hp.on_converted(company, c, actor)      # ADDITIVE: onboarding tasks + HCM / reporting manager / reviewer
    try:                                    # ADDITIVE: credentials / joining e-mail through the COMPANY's own SMTP
        from People.mail_welcome import send_welcome
        c._welcome_email = send_welcome(company, c, role=role, actor=str(actor or "")[:150], password_changed=bool(new_password))
    except Exception as exc:  # noqa: BLE001 - never fail the conversion because of e-mail
        c._welcome_email = {"sent": False, "status": "FAILED", "message": f"{type(exc).__name__}: {exc}"[:300]}
    return c, created, role


class JoiningTrackerViewSet(RecruitmentAuthMixin, ViewSet):
    """
    GET  /api/recruitment/joining/                   ready + in-progress preboarding
    POST /api/recruitment/joining/<candidate>/convert/
    """
    permission_action_map = {"convert": "edit"}

    def list(self, request):
        qs = candidates_qs(self.company()).filter(candidate_status__in=POST_OFFER_STAGES)
        rows = [joining_row(c, request) for c in qs.order_by("expected_joining_date", "id")]
        ready = [r for r in rows if r["ready"]]
        return ok("JOINING_TRACKER", "Joining tracker & onboarding readiness.",
                  {"ready_count": len(ready), "ready": ready,
                   "in_progress": [r for r in rows if not r["ready"]]})

    def retrieve(self, request, pk=None):
        c = candidates_qs(self.company()).filter(pk=pk, candidate_status__in=POST_OFFER_STAGES + ["JOINED"]).first()
        if c is None:
            return err("NOT_FOUND", "Candidate is not in the joining process.", 404)
        return ok("JOINING_DETAIL", "Joining details.", joining_row(c, request))

    @transaction.atomic
    def partial_update(self, request, pk=None):
        """Change target joining date / reporting manager while preboarding."""
        c = candidates_qs(self.company()).filter(pk=pk, candidate_status__in=POST_OFFER_STAGES).first()
        if c is None:
            return err("NOT_FOUND", "Candidate is not in the joining process.", 404)
        d = request.data
        sel = CandidateSelection.objects.filter(candidate=c).first()
        try:
            if "target_joining_date" in d:
                dt = to_date(d.get("target_joining_date"))
                c.expected_joining_date = dt
                c.save(update_fields=["expected_joining_date"])
                if sel:
                    sel.joining_date = dt
                Offer.objects.filter(candidate=c, status="Accepted").update(target_joining_date=dt)
            if "reporting_manager" in d and sel:
                from .common import employee_by_code
                sel.reporting_manager = employee_by_code(c.company, d.get("reporting_manager"))
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        if sel:
            sel.updated_by = self.actor()
            sel.save()
        return ok("JOINING_UPDATED", "Joining details updated.", joining_row(c, request))

    update = partial_update

    @action(detail=True, methods=["post"])
    def convert(self, request, pk=None):
        company = self.company()
        c = candidates_qs(company).filter(pk=pk).first()
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        if (c.candidate_status or "").upper() == "JOINED":
            return err("ALREADY_JOINED", "Candidate is already converted to an employee.", 409)
        if (c.candidate_status or "").upper() != "READY_TO_JOIN":
            return err("NOT_READY", "Candidate is not Ready To Join (documents + BGV must be cleared).")
        gate = hp.verification_required_error(c)        # ADDITIVE (only when HIRING_REQUIRE_ID_VERIFICATION)
        if gate:
            return err("VERIFICATION_REQUIRED", gate, 409)
        try:
            emp, created, role = convert_to_employee(company, c, request.data, self.actor())
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("CANDIDATE_CONVERTED", "Candidate converted to employee. Login is ready.",
                  {"employee": emp_brief(emp, request), "employee_id": emp.id,
                   "login": {"email": emp.email, "role": role.role_name, "account_created": created},
                   "welcome_email": getattr(emp, "_welcome_email", None)})
                   
