# ============================================================
# GET / full CRUD for the remaining models:
#   StageHistory (read-only audit log), CandidateProfile, DocumentReview
# + API index  GET /api/recruitment/
# ============================================================
from django.db import transaction
from django.utils import timezone
from rest_framework.views import APIView
from rest_framework.viewsets import ViewSet

from Employee.models import EmployeeDocument

from .common import (
    RecruitmentAuthMixin, ok, err, to_date, to_decimal, emp_brief, candidates_qs,
    candidate_by_ref, candidate_brief, employee_by_code, get_profile, lpa,
)
from .models import CandidateProfile, DocumentReview, JobRequisition, StageHistory
from .views_candidates import serialize_candidate
from .views_post import advance_after_docs, serialize_doc


# ------------------------------------------------------------
# StageHistory  /api/recruitment/stage-history/   (audit log: GET only)
# ------------------------------------------------------------
def serialize_history(h, request=None):
    return {"id": h.id, "candidate": candidate_brief(h.candidate, request),
            "from_stage": h.from_stage, "to_stage": h.to_stage, "note": h.note,
            "changed_by": h.changed_by, "changed_at": h.changed_at}


class StageHistoryViewSet(RecruitmentAuthMixin, ViewSet):
    """Read-only on purpose: an audit trail must not be edited or deleted."""
    permission_action = "view"

    def _qs(self):
        return StageHistory.objects.filter(company=self.company(), is_active=True).select_related("candidate")

    def list(self, request):
        qs, p = self._qs(), request.query_params
        try:
            if p.get("candidate"):
                c = candidate_by_ref(self.company(), p["candidate"])
                qs = qs.filter(candidate=c) if c else qs.none()
            if p.get("to_stage"):
                qs = qs.filter(to_stage__iexact=p["to_stage"])
            if p.get("from_stage"):
                qs = qs.filter(from_stage__iexact=p["from_stage"])
            if p.get("changed_by"):
                qs = qs.filter(changed_by__icontains=p["changed_by"])
            if p.get("date_from"):
                qs = qs.filter(changed_at__date__gte=to_date(p["date_from"]))
            if p.get("date_to"):
                qs = qs.filter(changed_at__date__lte=to_date(p["date_to"]))
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("STAGE_HISTORY_LIST", "Stage history.", [serialize_history(h, request) for h in qs[:500]])

    def retrieve(self, request, pk=None):
        h = self._qs().filter(pk=pk).first()
        if h is None:
            return err("NOT_FOUND", "History entry not found.", 404)
        return ok("STAGE_HISTORY_DETAIL", "Stage history entry.", serialize_history(h, request))

    # POST aliases make no sense for a read-only log
    update_post = None
    delete_post = None


# ------------------------------------------------------------
# CandidateProfile  /api/recruitment/candidate-profiles/
# ------------------------------------------------------------
def serialize_profile(p, request=None):
    return {
        "id": p.id, "candidate": candidate_brief(p.candidate, request),
        "requisition": p.requisition.requisition_id if p.requisition_id else None,
        "current_company": p.current_company,
        "total_experience_years": float(p.total_experience_years) if p.total_experience_years is not None else None,
        "notice_period_days": p.notice_period_days, "priority": p.priority,
        "recruiter": emp_brief(p.recruiter, request), "rejection_reason": p.rejection_reason,
        "stage_changed_at": p.stage_changed_at, "created_at": p.created_at, "updated_at": p.updated_at,
    }


class CandidateProfileViewSet(RecruitmentAuthMixin, ViewSet):

    def _qs(self):
        return CandidateProfile.objects.filter(company=self.company(), is_active=True) \
            .select_related("candidate", "requisition", "recruiter")

    def _apply(self, prof, d):
        company = self.company()
        if "requisition" in d:
            ref = str(d.get("requisition") or "")
            if ref:
                from django.db.models import Q
                r = JobRequisition.objects.filter(company=company, is_active=True).filter(
                    Q(requisition_id=ref) | Q(pk=int(ref) if ref.isdigit() else -1)).first()
                if r is None:
                    raise ValueError("Requisition not found.")
                prof.requisition = r
            else:
                prof.requisition = None
        if "recruiter" in d:
            prof.recruiter = employee_by_code(company, d.get("recruiter"))
        for f in ("current_company", "rejection_reason"):
            if f in d:
                setattr(prof, f, d.get(f))
        if "total_experience_years" in d:
            prof.total_experience_years = to_decimal(d.get("total_experience_years"))
        if "notice_period_days" in d:
            v = d.get("notice_period_days")
            prof.notice_period_days = int(v) if v not in (None, "") else None
        if d.get("priority"):
            if d["priority"] not in ("Low", "Medium", "High", "Urgent"):
                raise ValueError("priority must be Low / Medium / High / Urgent.")
            prof.priority = d["priority"]

    def list(self, request):
        qs, p = self._qs(), request.query_params
        if p.get("priority"):
            qs = qs.filter(priority__iexact=p["priority"])
        if p.get("requisition"):
            qs = qs.filter(requisition__requisition_id=p["requisition"])
        if p.get("recruiter"):
            qs = qs.filter(recruiter__employee_code=p["recruiter"])
        if p.get("candidate"):
            c = candidate_by_ref(self.company(), p["candidate"])
            qs = qs.filter(candidate=c) if c else qs.none()
        return ok("PROFILE_LIST", "Candidate recruitment profiles.", [serialize_profile(x, request) for x in qs])

    @transaction.atomic
    def create(self, request):
        c = candidate_by_ref(self.company(), request.data.get("candidate"))
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        if CandidateProfile.objects.filter(candidate=c).exists():
            return err("DUPLICATE", "This candidate already has a profile. Use PATCH.", 409)
        prof = CandidateProfile(company=self.company(), candidate=c, created_by=self.actor(), updated_by=self.actor())
        try:
            self._apply(prof, request.data)
        except ValueError as e:
            return err("VALIDATION", str(e))
        prof.save()
        return ok("PROFILE_CREATED", "Profile created.", serialize_profile(prof, request), status=201)

    def retrieve(self, request, pk=None):
        prof = self._qs().filter(pk=pk).first()
        if prof is None:
            return err("NOT_FOUND", "Profile not found.", 404)
        return ok("PROFILE_DETAIL", "Profile.", serialize_profile(prof, request))

    def partial_update(self, request, pk=None):
        prof = self._qs().filter(pk=pk).first()
        if prof is None:
            return err("NOT_FOUND", "Profile not found.", 404)
        try:
            self._apply(prof, request.data)
        except ValueError as e:
            return err("VALIDATION", str(e))
        prof.updated_by = self.actor()
        prof.save()
        return ok("PROFILE_UPDATED", "Profile updated.", serialize_profile(prof, request))

    update = partial_update

    def destroy(self, request, pk=None):
        prof = self._qs().filter(pk=pk).first()
        if prof is None:
            return err("NOT_FOUND", "Profile not found.", 404)
        prof.delete()       # extra recruitment data only; the candidate itself is untouched
        return ok("PROFILE_DELETED", "Profile deleted (candidate kept).")


# ------------------------------------------------------------
# DocumentReview  /api/recruitment/document-reviews/
# ------------------------------------------------------------
def serialize_review(rv, request=None):
    return {"id": rv.id, "status": rv.status, "remarks": rv.remarks, "reviewed_by": rv.reviewed_by,
            "reviewed_at": rv.reviewed_at, "document": serialize_doc(rv.document, request)}


class DocumentReviewViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {}

    def _qs(self):
        company = self.company()
        return DocumentReview.objects.filter(
            is_active=True, document__company=company, document__is_active=True,
            document__employee__in=candidates_qs(company)).select_related("document", "document__employee")

    def _set(self, rv, status, remarks):
        if status not in dict(DocumentReview.STATUS):
            raise ValueError("status must be Pending / Verified / Rejected.")
        if status == "Rejected" and not remarks:
            raise ValueError("remarks are required to reject a document.")
        doc = rv.document
        rv.status, rv.remarks = status, remarks
        rv.reviewed_by = self.actor() if status != "Pending" else None
        rv.reviewed_at = timezone.now() if status != "Pending" else None
        rv.updated_by = self.actor()
        rv.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.save()
        advance_after_docs(doc.employee, self.actor())

    def list(self, request):
        qs, p = self._qs(), request.query_params
        if p.get("status"):
            qs = qs.filter(status__iexact=p["status"])
        if p.get("candidate"):
            c = candidate_by_ref(self.company(), p["candidate"])
            qs = qs.filter(document__employee=c) if c else qs.none()
        return ok("REVIEW_LIST", "Document reviews.", [serialize_review(r, request) for r in qs.order_by("-id")])

    @transaction.atomic
    def create(self, request):
        d = request.data
        company = self.company()
        doc = EmployeeDocument.objects.filter(
            company=company, is_active=True, employee__in=candidates_qs(company),
            pk=d.get("document") if str(d.get("document")).isdigit() else -1).select_related("employee").first()
        if doc is None:
            return err("NOT_FOUND", "Document not found.", 404)
        if DocumentReview.objects.filter(document=doc).exists():
            return err("DUPLICATE", "This document already has a review. Use PATCH.", 409)
        rv = DocumentReview(document=doc, created_by=self.actor())
        try:
            self._set(rv, d.get("status") or "Pending", d.get("remarks"))
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        return ok("REVIEW_CREATED", "Review created.", serialize_review(rv, request), status=201)

    def retrieve(self, request, pk=None):
        rv = self._qs().filter(pk=pk).first()
        if rv is None:
            return err("NOT_FOUND", "Review not found.", 404)
        return ok("REVIEW_DETAIL", "Review.", serialize_review(rv, request))

    @transaction.atomic
    def partial_update(self, request, pk=None):
        rv = self._qs().filter(pk=pk).first()
        if rv is None:
            return err("NOT_FOUND", "Review not found.", 404)
        try:
            self._set(rv, request.data.get("status") or rv.status,
                      request.data.get("remarks") if "remarks" in request.data else rv.remarks)
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        return ok("REVIEW_UPDATED", "Review updated.", serialize_review(rv, request))

    update = partial_update

    @transaction.atomic
    def destroy(self, request, pk=None):
        rv = self._qs().filter(pk=pk).first()
        if rv is None:
            return err("NOT_FOUND", "Review not found.", 404)
        doc = rv.document
        rv.delete()                           # back to "Pending"
        doc.is_verified, doc.verified_by, doc.verified_at = False, None, None
        doc.save()
        advance_after_docs(doc.employee, self.actor())
        return ok("REVIEW_DELETED", "Review removed. Document is Pending again.")


# ------------------------------------------------------------
# API INDEX  GET /api/recruitment/
# ------------------------------------------------------------
RESOURCES = [
    ("requisitions", "JobRequisition"), ("job-descriptions", "JobDescription"),
    ("candidates", "EmployeeDT candidate"), ("candidate-profiles", "CandidateProfile"),
    ("candidate-education", "CandidateEducation"), ("candidate-experience", "CandidateExperience"),
    ("stage-history", "StageHistory (read-only)"), ("interviews", "InterviewRound"),
    ("feedback", "InterviewFeedback"), ("selection", "CandidateSelection"), ("offers", "Offer"),
    ("documents", "EmployeeDocument"), ("document-reviews", "DocumentReview"), ("bgv", "BGVCase"),
]


class RecruitmentIndexView(RecruitmentAuthMixin, APIView):
    permission_action = "view"

    def get(self, request):
        base = request.build_absolute_uri().split("?")[0].rstrip("/")
        rows = []
        for slug, model in RESOURCES:
            ro = slug == "stage-history"
            rows.append({
                "resource": slug, "model": model, "url": f"{base}/{slug}/",
                "list": f"GET {slug}/", "detail": f"GET {slug}/<id>/",
                "create": None if ro else f"POST {slug}/",
                "update": None if ro else [f"PATCH {slug}/<id>/", f"POST {slug}/<id>/update/"],
                "delete": None if ro else [f"DELETE {slug}/<id>/", f"POST {slug}/<id>/delete/"],
            })
        extra = ["dashboard/", "pipeline/", "pipeline/move/", "calendar/", "joining/", "meta/",
                 "interviewers/", "my-interviews/"]
        return ok("RECRUITMENT_INDEX", "Recruitment API index.", {"resources": rows, "other": extra})

