# ============================================================
# 4 Candidates | 5 13-Column Pipeline (Kanban)
# ============================================================
from decimal import Decimal

from django.conf import settings
from django.db import transaction
from django.db.models import Q
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 CandidateCompensation, EmployeeDT, EmployeeDocument

from .common import (
    RecruitmentAuthMixin, ok, err, to_decimal, to_date, to_list, lpa, candidates_qs,
    emp_brief, employee_by_code, get_profile, set_stage, stage_label,
)
from .models import (
    STAGES, STAGE_CODES, JobRequisition, CandidateProfile, InterviewRound,InterviewFeedback, StageHistory,
)
from . import hiring_plus as hp   # ADDITIVE: hiring plus hooks

LAKH = Decimal("100000")

# ---- 8-step form: step 1 personal + step 2 address (EmployeeDT columns) ----
PERSONAL_MAP = {              # api key -> EmployeeDT column
    "date_of_birth": "Date_of_Birth", "gender": "Gender", "blood_group": "Blood_Group",
    "marital_status": "Marital_Status", "personal_email": "Personal_Email",
    "alternate_phone_number": "Alternate_Phone_Number", "current_address": "Current_Address",
    "permanent_address": "Permanent_Address", "house_type": "House_Type",
    "aadhaar_number": "aadhaar_number", "pan_number": "pan_number",
}
# step 7: documents uploaded with the application (EmployeeDT file columns)
FILE_FIELDS = ["profile_image", "resume", "aadhaar_id_proof", "pan_card",
               "address_proof", "passport_photo", "educational_certificates"]
MAX_FILE = 10 * 1024 * 1024

EDU_TEXT = ["highest_qualification", "degree_course", "specialization_branch", "university_board",
            "college_institute", "percentage_cgpa", "key_certifications"]
EXP_TEXT = ["company_name", "designation", "department", "reason_for_leaving", "reporting_manager",
            "reporting_role", "core_responsibilities"]


def _json_list(v, label):
    import json
    if v in (None, ""):
        return None
    if isinstance(v, str):
        try:
            v = json.loads(v)
        except ValueError:
            raise ValueError(f"{label} must be a JSON list.")
    if not isinstance(v, list) or any(not isinstance(i, dict) for i in v):
        raise ValueError(f"{label} must be a list of objects.")
    return v


def apply_personal(c, d, files):
    for key, col in PERSONAL_MAP.items():
        if key in d:
            val = d.get(key)
            setattr(c, col, to_date(val) if key == "date_of_birth" else (val if val != "" else None))
    if "same_as_current_address" in d:
        c.same_as_current_address = str(d.get("same_as_current_address")).lower() in ("1", "true", "yes")
        if c.same_as_current_address:
            c.Permanent_Address = c.Current_Address
    for f in FILE_FIELDS:
        up = files.get(f) if files else None
        if up is not None:
            if up.size > MAX_FILE:
                raise ValueError(f"{f}: file too large (max 10 MB).")
            setattr(c, f, up)


def apply_education(row_obj, d):
    for f in EDU_TEXT:
        if f in d:
            setattr(row_obj, f, d.get(f) or None)
    if "passing_year" in d:
        try:
            row_obj.passing_year = int(d["passing_year"]) if d.get("passing_year") not in (None, "") else None
        except (TypeError, ValueError):
            raise ValueError("passing_year must be a year, e.g. 2019.")


def apply_experience(row_obj, d):
    for f in EXP_TEXT:
        if f in d:
            setattr(row_obj, f, d.get(f) or None)
    for f in ("start_date", "end_date"):
        if f in d:
            setattr(row_obj, f, to_date(d.get(f)))
    if "previous_ctc" in d:
        row_obj.previous_ctc = to_decimal(d.get("previous_ctc"))
    if row_obj.start_date and row_obj.end_date and row_obj.end_date < row_obj.start_date:
        raise ValueError("end_date cannot be before start_date.")


def serialize_education(e, request=None):
    return {"id": e.id, "candidate": e.employee_id,
            **{f: getattr(e, f) for f in EDU_TEXT}, "passing_year": e.passing_year,
            "degree_certificate": (request.build_absolute_uri(e.degree_certificate.url)
                                   if request and e.degree_certificate else None)}


def serialize_experience(x, request=None):
    return {"id": x.id, "candidate": x.employee_id,
            **{f: getattr(x, f) for f in EXP_TEXT},
            "start_date": x.start_date, "end_date": x.end_date,
            "previous_ctc": float(x.previous_ctc) if x.previous_ctc is not None else None,
            "relieving_proof": (request.build_absolute_uri(x.experience_reliving_proof.url)
                                if request and x.experience_reliving_proof else None)}


def save_nested(c, education, experience, actor):
    """Replace-less append of education / experience rows sent with the candidate form."""
    from Employee.models import CandidateEducation, CandidateExperience
    for row in education or []:
        e = CandidateEducation(employee=c, created_by=actor, updated_by=actor)
        apply_education(e, row)
        e.save()
    for row in experience or []:
        x = CandidateExperience(employee=c, created_by=actor, updated_by=actor)
        apply_experience(x, row)
        x.save()

STATUS_TEXT = {
    "APPLIED": "New Application Received",
    "SCREENING": "Screening Evaluation Pending",
    "SHORTLISTED": "Shortlisted for Technical Round 1",
    "INTERVIEW": "Interview In Progress",
    "FEEDBACK_PENDING": "Interviewer Feedback Pending",
    "SELECTED": "Selected - Offer Generation Pending",
    "OFFER_SENT": "Offer Released - Pending Candidate Decision",
    "OFFER_ACCEPTED": "Offer Accepted - Uploading Documents",
    "DOCS_PENDING": "Document Verification In Progress",
    "BGV": "Background Verification In Progress",
    "READY_TO_JOIN": "Ready for 1-Click Onboarding",
    "JOINED": "Onboarded & Joined",
    "REJECTED": "Rejected",
}


def _comp(c):
    try:
        return c.compensation_package
    except CandidateCompensation.DoesNotExist:
        return None


def _lpa_of(annual):
    return float(annual / LAKH) if annual is not None else None

# ---- Feedback gate: Feedback Pending -> Selection / other stages ----
FEEDBACK_PENDING_MSG = ("Feedback not submitted. Please submit the interview feedback before moving the candidate "
                        "forward in the interview pipeline.")
SELECTABLE_RECOMMENDATIONS = ("Hire", "Strong Hire")


def _active_rounds(c):
    return InterviewRound.objects.filter(candidate=c, is_active=True).exclude(status="Cancelled")


def feedback_status_of(c):
    """None (no interview round), 'Pending' (a round still needs its scorecard) or 'Feedback Done'."""
    rounds = _active_rounds(c)
    if not rounds.exists():
        return None
    if rounds.filter(feedback_status="Pending").exists():
        return "Pending"
    return "Feedback Done"


def feedback_result_of(c):
    """Latest saved scorecard recommendation for the candidate, or None."""
    fb = (InterviewFeedback.objects.filter(interview__in=_active_rounds(c), is_active=True)
          .order_by("-created_at").first())
    return fb.recommendation if fb else None


def feedback_gate_error(c, target_stage):
    """Error message if the candidate may not leave FEEDBACK_PENDING for target_stage, else None."""
    if (c.candidate_status or "").upper() != "FEEDBACK_PENDING" or target_stage == "REJECTED":
        return None
    if feedback_status_of(c) != "Feedback Done":
        return FEEDBACK_PENDING_MSG
    if target_stage == "SELECTED":
        recs = InterviewFeedback.objects.filter(interview__in=_active_rounds(c), is_active=True) \
            .values_list("recommendation", flat=True)
        if any(r not in SELECTABLE_RECOMMENDATIONS for r in recs):
            return ("The saved scorecard result does not allow Selection. Only a Hire result can move "
                    "the candidate forward; reject the candidate for a No Hire result.")
    return None


def serialize_candidate(c, request=None, detail=False):
    prof = get_profile(c, create=False)
    comp = _comp(c)
    stage = (c.candidate_status or "APPLIED").upper()
    nxt = (InterviewRound.objects.filter(candidate=c, status="Scheduled", scheduled_at__gte=timezone.now())
           .order_by("scheduled_at").first())
    data = {
        "id": c.id,
        "candidate_id": c.candidate_id,
        "employee_code": c.employee_code,
        "name": c.name,
        "email": c.email,
        "phone_number": c.phone_number,
        "profile_image": (request.build_absolute_uri(c.profile_image.url)
                          if request and c.profile_image else None),
        "applied_position": c.applied_position,
        "requisition": prof.requisition.requisition_id if prof and prof.requisition_id else None,
        "requisition_pk": prof.requisition_id if prof else None,
        "source": c.candidate_source,
        "recruiter": emp_brief(prof.recruiter, request) if prof and prof.recruiter_id else (
            {"name": c.recruiter_name} if c.recruiter_name else None),
        "current_company": prof.current_company if prof else None,
        "total_experience_years": float(prof.total_experience_years) if prof and prof.total_experience_years is not None else None,
        "notice_period_days": prof.notice_period_days if prof else None,
        "priority": prof.priority if prof else "Medium",
        "current_ctc_lpa": _lpa_of(comp.current_annual_ctc) if comp else None,
        "expected_ctc_lpa": _lpa_of(comp.expected_annual_ctc) if comp else None,
        "offered_ctc_lpa": _lpa_of(comp.offered_annual_ctc) if comp else None,
        "stage": stage,
        "stage_label": stage_label(stage),
        "status_text": STATUS_TEXT.get(stage, stage),
        "next_interview": nxt.scheduled_at if nxt else None,
        "rejection_reason": prof.rejection_reason if prof else None,
        "stage_changed_at": prof.stage_changed_at if prof else None,
        "applied_on": c.application_submitted_at or None,
        "can_convert": stage == "READY_TO_JOIN",
        "feedback_status": feedback_status_of(c),
        "feedback_result": feedback_result_of(c),
    }
    if detail:
        data["history"] = [
            {"from": h.from_stage, "to": h.to_stage, "note": h.note,
             "by": h.changed_by, "at": h.changed_at}
            for h in c.stage_history.all()[:50]]
        data["interviews"] = [
            {"interview_id": r.interview_id, "round": r.round_name, "scheduled_at": r.scheduled_at,
             "status": r.status, "feedback_status": r.feedback_status}
            for r in c.interview_rounds.filter(is_active=True)]
        data["documents_count"] = EmployeeDocument.objects.filter(employee=c).count()
        data["personal"] = {k: (str(getattr(c, col)) if k == "date_of_birth" and getattr(c, col) else getattr(c, col))
                            for k, col in PERSONAL_MAP.items()}
        data["personal"]["same_as_current_address"] = c.same_as_current_address
        data["education"] = [serialize_education(e, request) for e in c.educational_history.filter(is_active=True)]
        data["experience"] = [serialize_experience(x, request) for x in c.professional_experience.filter(is_active=True)]
        data["files"] = {f: (request.build_absolute_uri(getattr(c, f).url) if request and getattr(c, f) else None)
                         for f in FILE_FIELDS}
        data["full_profile_endpoint"] = f"/company/employees/detail/?id={c.id}"
    return hp.enrich_candidate(data, c, prof)      # ADDITIVE: new keys only


class CandidateViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"move": "edit", "reject": "edit", "history": "view"}

    def _get(self, pk):
        return candidates_qs(self.company()).filter(pk=pk).first()

    def _apply_profile(self, c, d):
        company = self.company()
        prof = get_profile(c, company)
        if d.get("requisition"):
            ref = str(d.get("requisition"))
            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
            c.applied_position = c.applied_position or r.position_title
        if "recruiter" in d:
            prof.recruiter = employee_by_code(company, d.get("recruiter"))
            if prof.recruiter:
                c.recruiter_name = prof.recruiter.name
        if "current_company" in d:
            prof.current_company = d.get("current_company")
        if "total_experience_years" in d:
            prof.total_experience_years = to_decimal(d.get("total_experience_years"))
        if "notice_period_days" in d and d.get("notice_period_days") not in (None, ""):
            prof.notice_period_days = int(d.get("notice_period_days"))
            c.Current_Notice_Period = f"{prof.notice_period_days} Days"
        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"]
        prof.updated_by = self.actor()
        prof.save()
        if any(k in d for k in ("current_ctc_lpa", "expected_ctc_lpa")):
            comp, _ = CandidateCompensation.objects.get_or_create(employee=c)
            if "current_ctc_lpa" in d:
                v = to_decimal(d.get("current_ctc_lpa"))
                comp.current_annual_ctc = v * LAKH if v is not None else None
            if "expected_ctc_lpa" in d:
                v = to_decimal(d.get("expected_ctc_lpa"))
                comp.expected_annual_ctc = v * LAKH if v is not None else None
            comp.save()

    def list(self, request):
        company = self.company()
        qs = candidates_qs(company).select_related("recruitment_profile", "recruitment_profile__requisition")
        p = request.query_params
        if p.get("stage"):
            qs = qs.filter(candidate_status__iexact=p["stage"])
        if p.get("requisition"):
            qs = qs.filter(recruitment_profile__requisition__requisition_id=p["requisition"])
        if p.get("recruiter"):
            qs = qs.filter(recruitment_profile__recruiter__employee_code=p["recruiter"])
        if p.get("priority"):
            qs = qs.filter(recruitment_profile__priority__iexact=p["priority"])
        if p.get("search"):
            s = p["search"]
            qs = qs.filter(Q(name__icontains=s) | Q(email__icontains=s) | Q(phone_number__icontains=s)
                           | Q(candidate_id__icontains=s) | Q(applied_position__icontains=s))
        qs = qs.order_by("-id")
        data = [serialize_candidate(c, request) for c in qs]
        summary = {code: 0 for code, _ in STAGES}
        for c in data:
            summary[c["stage"]] = summary.get(c["stage"], 0) + 1
        return ok("CANDIDATE_LIST", "Candidate talent pool.", data, total=len(data), stage_summary=summary)

    @transaction.atomic
    def create(self, request):
        d = request.data
        name, email = (d.get("name") or "").strip(), (d.get("email") or "").strip().lower()
        if not name or not email:
            return err("VALIDATION", "name and email are required.")
        company = self.company()
        if EmployeeDT.objects.filter(company=company, email__iexact=email).exists():
            return err("DUPLICATE", "A candidate/employee with this email already exists.", 409)
        bad_np = hp.validate_notice_period(d)          # ADDITIVE: notice period 30 / 60 / 90
        if bad_np:
            return err("VALIDATION", bad_np)
        c = EmployeeDT(
            company=company, name=name, email=email,
            phone_number=d.get("phone_number") or d.get("phone"),
            applied_position=d.get("applied_position"),
            candidate_source=d.get("source") or d.get("candidate_source"),
            candidate_status="APPLIED",
            Employee_Status="Candidate",
            is_active=False,               # not an employee yet -> stays out of payroll/attendance
            application_submitted=True, application_submitted_at=timezone.now(),
            created_by=self.actor(), updated_by=self.actor(),
        )
        try:
            c.expected_joining_date = to_date(d.get("expected_joining_date"))
            apply_personal(c, d, request.FILES)
            education = _json_list(d.get("education"), "education")
            experience = _json_list(d.get("experience"), "experience")
            c.save()
            self._apply_profile(c, d)
            c.save()
            save_nested(c, education, experience, self.actor())
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        if request.FILES.get("resume"):
            EmployeeDocument.objects.create(
                company=company, employee=c, document_type="RESUME",
                document_name=f"{c.name} Resume", file=request.FILES["resume"], created_by=self.actor())
        StageHistory.objects.create(company=company, candidate=c, from_stage=None,
                                    to_stage="APPLIED", note="Candidate added", changed_by=self.actor())
        hp.sync_experience(c)                          # ADDITIVE: total experience from experience rows
        hp.on_candidate_created(c, self.actor())       # ADDITIVE: maker-checker record + hiring checklist
        return ok("CANDIDATE_CREATED", "Candidate added.", serialize_candidate(c, request, True), status=201)

    def retrieve(self, request, pk=None):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        return ok("CANDIDATE_DETAIL", "Candidate.", serialize_candidate(c, request, True))

    @transaction.atomic
    def partial_update(self, request, pk=None):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        d = request.data
        bad_np = hp.validate_notice_period(d)          # ADDITIVE: notice period 30 / 60 / 90
        if bad_np:
            return err("VALIDATION", bad_np)
        for f, col in (("name", "name"), ("phone_number", "phone_number"),
                       ("applied_position", "applied_position"), ("source", "candidate_source")):
            if d.get(f) not in (None, ""):
                setattr(c, col, d.get(f))
        if d.get("email"):
            em = d["email"].strip().lower()
            if EmployeeDT.objects.filter(company=c.company, email__iexact=em).exclude(pk=c.pk).exists():
                return err("DUPLICATE", "Email already used.", 409)
            c.email = em
        try:
            if "expected_joining_date" in d:
                c.expected_joining_date = to_date(d.get("expected_joining_date"))
            apply_personal(c, d, request.FILES)
            education = _json_list(d.get("education"), "education")
            experience = _json_list(d.get("experience"), "experience")
            self._apply_profile(c, d)
            c.updated_by = self.actor()
            c.save()
            save_nested(c, education, experience, self.actor())
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        c.updated_by = self.actor()
        c.save()
        hp.sync_experience(c)                          # ADDITIVE
        return ok("CANDIDATE_UPDATED", "Candidate updated.", serialize_candidate(c, request, True))

    update = partial_update

    @transaction.atomic
    def destroy(self, request, pk=None):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        if (c.candidate_status or "").upper() == "JOINED" or (c.Employee_Status or "") == "Activate":
            return err("IN_USE", "This person is already an employee. Candidate cannot be deleted.")
        from .models import Offer
        if Offer.objects.filter(candidate=c, status="Accepted").exists():
            return err("IN_USE", "Candidate has an accepted offer. Reject / withdraw the offer first.")
        c.delete()
        return ok("CANDIDATE_DELETED", "Candidate deleted.")

    @action(detail=True, methods=["post"])
    def move(self, request, pk=None):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        stage = (request.data.get("stage") or "").upper()
        if stage == "JOINED":
            return err("USE_CONVERT", "Use POST /api/recruitment/joining/<id>/convert/ to mark a candidate Joined.")
        gate = feedback_gate_error(c, stage)
        if gate:
            return err("FEEDBACK_REQUIRED", gate, 409)
        gate = hp.approval_gate_error(c, stage) if getattr(settings, "HIRING_REQUIRE_CANDIDATE_APPROVAL", True) else None
        if gate:                                       # ADDITIVE: maker-checker gate
            return err("APPROVAL_REQUIRED", gate, 409)
        gate = hp.verification_required_error(c) if stage == "READY_TO_JOIN" else None
        if gate:                                       # ADDITIVE: ID verification gate (off by default)
            return err("VERIFICATION_REQUIRED", gate, 409)
        try:
            set_stage(c, stage, self.actor(), request.data.get("note"))
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("CANDIDATE_MOVED", f"Moved to {stage_label(stage)}.", serialize_candidate(c, request))

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        if (c.candidate_status or "").upper() == "JOINED":
            return err("INVALID_STATE", "A joined candidate cannot be rejected.")
        set_stage(c, "REJECTED", self.actor(), request.data.get("reason"))
        prof = get_profile(c)
        prof.rejection_reason = request.data.get("reason")
        prof.save(update_fields=["rejection_reason", "updated_at"])
        return ok("CANDIDATE_REJECTED", "Candidate rejected.", serialize_candidate(c, request))

    @action(detail=True, methods=["get"])
    def history(self, request, pk=None):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        return ok("CANDIDATE_HISTORY", "Stage history.", [
            {"from": h.from_stage, "to": h.to_stage, "note": h.note, "by": h.changed_by, "at": h.changed_at}
            for h in c.stage_history.all()])


# ------------------------------------------------------------
# 5. 13-COLUMN KANBAN  GET /api/recruitment/pipeline/
#    POST /api/recruitment/pipeline/move/  {candidate, stage}
# ------------------------------------------------------------
class PipelineView(RecruitmentAuthMixin, APIView):

    def get(self, request):
        company = self.company()
        qs = candidates_qs(company).select_related("recruitment_profile", "recruitment_profile__requisition")
        if request.query_params.get("requisition"):
            qs = qs.filter(recruitment_profile__requisition__requisition_id=request.query_params["requisition"])
        cols = {code: [] for code, _ in STAGES}
        for c in qs.order_by("-id"):
            card = serialize_candidate(c, request)
            cols.setdefault(card["stage"], []).append(card)
        columns = [{"stage": code, "label": label, "count": len(cols[code]), "cards": cols[code]}
                   for code, label in STAGES]
        return ok("PIPELINE", "13-stage pipeline.", {"columns": columns})


class PipelineMoveView(RecruitmentAuthMixin, APIView):
    permission_action = "edit"

    def post(self, request):
        ref = request.data.get("candidate") or request.data.get("candidate_id")
        c = candidates_qs(self.company()).filter(
            Q(pk=int(ref) if str(ref).isdigit() else -1) | Q(candidate_id=str(ref))).first()
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        stage = (request.data.get("stage") or "").upper()
        if stage == "JOINED":
            return err("USE_CONVERT", "Use the Joining Tracker convert action to mark Joined.")
        gate = feedback_gate_error(c, stage)
        if gate:
            return err("FEEDBACK_REQUIRED", gate, 409)    
        gate = hp.approval_gate_error(c, stage) if getattr(settings, "HIRING_REQUIRE_CANDIDATE_APPROVAL", True) else None
        if gate:                                       # ADDITIVE: maker-checker gate
            return err("APPROVAL_REQUIRED", gate, 409)
        gate = hp.verification_required_error(c) if stage == "READY_TO_JOIN" else None
        if gate:                                       # ADDITIVE: ID verification gate (off by default)
            return err("VERIFICATION_REQUIRED", gate, 409)
        try:
            set_stage(c, stage, self.actor(), request.data.get("note") or "Moved on Kanban")
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("PIPELINE_MOVED", f"Moved to {stage_label(stage)}.", serialize_candidate(c, request))



# ------------------------------------------------------------
# 4. CANDIDATE FORM STEPS - full CRUD
#    /api/recruitment/candidate-education/    (?candidate=<id>)
#    /api/recruitment/candidate-experience/   (?candidate=<id>)
# ------------------------------------------------------------
class _CandidateChildViewSet(RecruitmentAuthMixin, ViewSet):
    model = None
    apply_fn = None
    ser_fn = None
    label = ""
    file_fields = ()

    def _qs(self):
        company = self.company()
        return self.model.objects.filter(employee__company=company, is_active=True,
                                         employee__in=candidates_qs(company))

    def _cand(self, ref):
        from .common import candidate_by_ref
        return candidate_by_ref(self.company(), ref)

    def list(self, request):
        qs = self._qs()
        if request.query_params.get("candidate"):
            c = self._cand(request.query_params["candidate"])
            qs = qs.filter(employee=c) if c else qs.none()
        return ok(f"{self.label}_LIST", f"{self.label.title()} records.",
                  [type(self).ser_fn(r, request) for r in qs.order_by("-id")])

    @transaction.atomic
    def create(self, request):
        c = self._cand(request.data.get("candidate"))
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        obj = self.model(employee=c, created_by=self.actor(), updated_by=self.actor())
        try:
            type(self).apply_fn(obj, request.data)
            if request.FILES:
                for fname, up in request.FILES.items():
                    if fname in self.file_fields:
                        setattr(obj, fname, up)
            obj.save()
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        return ok(f"{self.label}_CREATED", "Saved.", type(self).ser_fn(obj, request), status=201)

    def retrieve(self, request, pk=None):
        obj = self._qs().filter(pk=pk).first()
        if obj is None:
            return err("NOT_FOUND", "Record not found.", 404)
        return ok(f"{self.label}_DETAIL", "Record.", type(self).ser_fn(obj, request))

    def partial_update(self, request, pk=None):
        obj = self._qs().filter(pk=pk).first()
        if obj is None:
            return err("NOT_FOUND", "Record not found.", 404)
        try:
            type(self).apply_fn(obj, request.data)
            for fname, up in request.FILES.items():
                if fname in self.file_fields:
                    setattr(obj, fname, up)
        except ValueError as e:
            return err("VALIDATION", str(e))
        obj.updated_by = self.actor()
        obj.save()
        return ok(f"{self.label}_UPDATED", "Updated.", type(self).ser_fn(obj, request))

    update = partial_update

    def destroy(self, request, pk=None):
        obj = self._qs().filter(pk=pk).first()
        if obj is None:
            return err("NOT_FOUND", "Record not found.", 404)
        obj.is_active = False
        obj.updated_by = self.actor()
        obj.save()
        return ok(f"{self.label}_DELETED", "Deleted.")


class CandidateEducationViewSet(_CandidateChildViewSet):
    from Employee.models import CandidateEducation as model
    apply_fn = staticmethod(apply_education)
    ser_fn = staticmethod(serialize_education)
    label = "EDUCATION"
    file_fields = ("degree_certificate",)


class CandidateExperienceViewSet(_CandidateChildViewSet):
    from Employee.models import CandidateExperience as model
    apply_fn = staticmethod(apply_experience)
    ser_fn = staticmethod(serialize_experience)
    label = "EXPERIENCE"
    file_fields = ("experience_reliving_proof",)

