# ============================================================
# 1 Dashboard | 2 Job Requisitions | 3 Job Descriptions
# ============================================================
from datetime import timedelta

from django.db import transaction
from django.db.models import Count, Q
from django.http import HttpResponse
from django.utils import timezone
from rest_framework.views import APIView
from rest_framework.viewsets import ViewSet
from rest_framework.decorators import action

from Employee.models import Department

from .common import (
    RecruitmentAuthMixin, ok, err, to_decimal, to_bool, to_list, lpa,
    next_seq, employee_by_code, emp_brief, candidates_qs, stage_label,hiring_manager_qs, hiring_manager_by_code,
)
from .models import (
    STAGES, JobRequisition, JobDescription, CandidateProfile,
    InterviewRound, Offer, DocumentReview, BGVCase,
)


# ------------------------------------------------------------
# 1. DASHBOARD  GET /api/recruitment/dashboard/
# ------------------------------------------------------------
class RecruitmentDashboardView(RecruitmentAuthMixin, APIView):

    def get(self, request):
        company = self.company()
        cands = candidates_qs(company)
        today = timezone.localdate()
        week_end = today + timedelta(days=7)

        counts = {code: 0 for code, _ in STAGES}
        for row in cands.values("candidate_status").annotate(n=Count("id")):
            code = (row["candidate_status"] or "APPLIED").upper()
            counts[code] = counts.get(code, 0) + row["n"]

        total = cands.count()
        active_pipeline = total - counts["REJECTED"] - counts["JOINED"]
        reqs = JobRequisition.objects.filter(company=company, is_active=True)
        open_positions = sum(
            max(r.vacancies - r.selections.filter(status__in=["Selected", "Offer Generated"]).count(), 0)
            for r in reqs.filter(approval_status="Approved")
        )
        rounds = InterviewRound.objects.filter(company=company, is_active=True)
        offers = Offer.objects.filter(company=company)

        kpis = {
            "open_positions": open_positions,
            "total_candidates": total,
            "active_pipeline": active_pipeline,
            "new_applications": counts["APPLIED"],
            "shortlisted": counts["SHORTLISTED"],
            "interviews_today": rounds.filter(scheduled_at__date=today, status="Scheduled").count(),
            "interviews_this_week": rounds.filter(scheduled_at__date__gte=today,
                                                  scheduled_at__date__lte=week_end,
                                                  status="Scheduled").count(),
            "feedback_pending": rounds.filter(feedback_status="Pending",
                                              scheduled_at__lt=timezone.now()).exclude(
                                                  status="Cancelled").count(),
            "selected_candidates": counts["SELECTED"],
            "offers_sent": offers.filter(status="Sent").count(),
            "offers_accepted": offers.filter(status="Accepted").count(),
            "documents_pending": DocumentReview.objects.filter(
                document__company=company, status="Pending").values("document__employee").distinct().count(),
            "bgv_pending": BGVCase.objects.filter(company=company).exclude(
                status__in=["Verified", "Failed"]).count(),
            "ready_to_join": counts["READY_TO_JOIN"],
            "joined": counts["JOINED"],
        }
        funnel = [{"stage": code, "label": label, "count": counts[code],
                   "percent": round(counts[code] * 100 / total) if total else 0}
                  for code, label in STAGES]
        return ok("RECRUITMENT_DASHBOARD", "Recruitment dashboard.",
                  {"kpis": kpis, "funnel": funnel, "total_candidates": total,
                   **__import__("Recruitment.hiring_plus", fromlist=["x"]).dashboard_notices(company)})   # ADDITIVE: CHRO notices


# ------------------------------------------------------------
# 2. JOB REQUISITIONS  /api/recruitment/requisitions/
# ------------------------------------------------------------
def serialize_requisition(r, request=None):
    return {
        "id": r.id,
        "requisition_id": r.requisition_id,
        "position_title": r.position_title,
        "department": r.department.name if r.department_id else r.department_name,
        "department_id": r.department_id,
        "work_mode": r.work_mode,
        "location": r.location,
        "vacancies": r.vacancies,
        "open_vacancies": max(r.vacancies - r.selections.filter(
            status__in=["Selected", "Offer Generated"]).count(), 0),
        "budget_min_lpa": lpa(r.budget_min_lpa),
        "budget_max_lpa": lpa(r.budget_max_lpa),
        "hiring_manager": emp_brief(r.hiring_manager, request),
        "priority": r.priority,
        "approval_status": r.approval_status,
        "approved_by": r.approved_by,
        "approved_at": r.approved_at,
        "rejection_reason": r.rejection_reason,
        "has_job_description": hasattr(r, "job_description"),
        "candidates_count": r.candidates.count(),
        "created_at": r.created_at,
    }

_serialize_requisition_base = serialize_requisition


def serialize_requisition(r, request=None):          # ADDITIVE: wraps the original, adds the post-hire role map
    from . import hiring_plus as hp
    out = _serialize_requisition_base(r, request)
    out.update(hp.requisition_extra(r))
    return out


class HiringManagerPickerView(RecruitmentAuthMixin, APIView):
    """GET /api/recruitment/hiring-managers/ - only employees with the HR Manager role."""

    def get(self, request):
        qs = hiring_manager_qs(self.company())
        s = request.query_params.get("search")
        if s:
            qs = qs.filter(Q(name__icontains=s) | Q(employee_code__icontains=s))
        rows = []
        for e in qs.order_by("name")[:200]:
            row = emp_brief(e, request)
            role = e.account.role
            row["role_code"], row["role_name"] = role.role_code, role.role_name
            rows.append(row)
        return ok("HIRING_MANAGER_PICKER", "Eligible hiring managers.", rows)

class JobRequisitionViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"approve": "approve", "reject": "approve", "submit": "create",
                             "duplicate": "create", "close": "edit"}

    def _get(self, pk):
        return JobRequisition.objects.filter(company=self.company(), pk=pk, is_active=True).first()

    def _apply(self, r, data):
        company = self.company()
        for f in ("position_title", "work_mode", "location", "priority"):
            if f in data and data.get(f) not in (None, ""):
                setattr(r, f, data.get(f))
        if "vacancies" in data:
            r.vacancies = max(int(data.get("vacancies") or 1), 1)
        if "budget_min_lpa" in data:
            r.budget_min_lpa = to_decimal(data.get("budget_min_lpa"))
        if "budget_max_lpa" in data:
            r.budget_max_lpa = to_decimal(data.get("budget_max_lpa"))
        if r.budget_min_lpa and r.budget_max_lpa and r.budget_min_lpa > r.budget_max_lpa:
            raise ValueError("budget_min_lpa cannot be greater than budget_max_lpa.")
        if data.get("department_id"):
            dep = Department.objects.filter(company=company, id=data.get("department_id")).first()
            if dep is None:
                raise ValueError("Department not found in your company.")
            r.department, r.department_name = dep, dep.name
        elif "department" in data:
            name = (data.get("department") or "").strip()
            r.department_name = name
            match = Department.objects.filter(company=company, name__iexact=name).first() if name else None
            if match:
                r.department = match
        if "hiring_manager" in data:               # employee_code, must hold the HR Manager role
            code = data.get("hiring_manager")
            current = r.hiring_manager.employee_code if r.hiring_manager_id else None
            if not (code and current and str(code).strip() == current):
                r.hiring_manager = hiring_manager_by_code(company, code)

    def list(self, request):
        qs = JobRequisition.objects.filter(company=self.company(), is_active=True)
        p = request.query_params
        if p.get("approval_status"):
            qs = qs.filter(approval_status__iexact=p["approval_status"])
        if p.get("priority"):
            qs = qs.filter(priority__iexact=p["priority"])
        if p.get("hiring_manager"):
            qs = qs.filter(hiring_manager__employee_code=p["hiring_manager"])
        if p.get("search"):
            s = p["search"]
            qs = qs.filter(Q(position_title__icontains=s) | Q(requisition_id__icontains=s)
                           | Q(department_name__icontains=s))
        if p.get("without_jd") not in (None, ""):          # picker for "Create New JD via Requisition"
            qs = qs.filter(job_description__isnull=to_bool(p["without_jd"]))
        if p.get("hiring_manager_me") and hasattr(request.user, "employee_code"):
            qs = qs.filter(hiring_manager=request.user)
        return ok("REQUISITION_LIST", "Requisitions.",
                  [serialize_requisition(r, request) for r in qs.select_related("hiring_manager", "department")])

    @transaction.atomic
    def create(self, request):
        d = request.data
        if not d.get("position_title"):
            return err("VALIDATION", "position_title is required.")
        company = self.company()
        year = timezone.localdate().year
        r = JobRequisition(company=company, created_by=self.actor(), updated_by=self.actor(),
                           requisition_id=next_seq(JobRequisition, company, "requisition_id", f"REQ-{year}-"))
        try:
            self._apply(r, d)
        except ValueError as e:
            return err("VALIDATION", str(e))
        r.approval_status = "Submitted" if to_bool(d.get("submit")) else "Draft"
        r.save()
        try:
            from . import hiring_plus as hp
            hp.apply_requisition_roles(company, r, d, self.actor())     # ADDITIVE: HCM / reporting mgr / reviewer
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        jd_data = d.get("job_description")
        if isinstance(jd_data, str) and jd_data.strip():
            import json
            try:
                jd_data = json.loads(jd_data)
            except ValueError:
                transaction.set_rollback(True)
                return err("VALIDATION", "job_description must be a JSON object.")
        jd = None
        if isinstance(jd_data, dict):                       # Requisition + JD in ONE call
            jd = JobDescription(company=company, requisition=r, created_by=self.actor(), updated_by=self.actor(),
                                jd_code=next_seq(JobDescription, company, "jd_code", "JD-"))
            try:
                JobDescriptionViewSet._apply(self, jd, jd_data)
            except ValueError as e:
                transaction.set_rollback(True)
                return err("VALIDATION", str(e))
            jd.save()
        out = serialize_requisition(r, request)
        if jd is not None:
            out["job_description"] = serialize_jd(jd, request)
        return ok("REQUISITION_CREATED", "Requisition created.", out, status=201)

    def retrieve(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        return ok("REQUISITION_DETAIL", "Requisition.", serialize_requisition(r, request))

    def _update(self, request, pk):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        if r.approval_status == "Closed":
            return err("CLOSED", "A closed requisition cannot be edited.")
        try:
            self._apply(r, request.data)
        except ValueError as e:
            return err("VALIDATION", str(e))
        r.updated_by = self.actor()
        r.save()
        try:
            from . import hiring_plus as hp
            hp.apply_requisition_roles(self.company(), r, request.data, self.actor())   # ADDITIVE
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("REQUISITION_UPDATED", "Requisition updated.", serialize_requisition(r, request))

    def update(self, request, pk=None):
        return self._update(request, pk)

    def partial_update(self, request, pk=None):
        return self._update(request, pk)

    def destroy(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        if r.candidates.exists():
            return err("IN_USE", "Requisition has candidates. Close it instead of deleting.")
        r.is_active = False            # soft delete
        r.save(update_fields=["is_active", "updated_at"])
        return ok("REQUISITION_DELETED", "Requisition deleted.")

    @action(detail=True, methods=["post"])
    def submit(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        if r.approval_status not in ("Draft", "Rejected"):
            return err("INVALID_STATE", f"Cannot submit a {r.approval_status} requisition.")
        r.approval_status, r.updated_by = "Submitted", self.actor()
        r.save()
        return ok("REQUISITION_SUBMITTED", "Submitted for approval.", serialize_requisition(r, request))

    @action(detail=True, methods=["post"])
    def approve(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        if r.approval_status != "Submitted":
            return err("INVALID_STATE", "Only Submitted requisitions can be approved.")
        r.approval_status, r.approved_by = "Approved", self.actor()
        r.approved_at, r.rejection_reason, r.updated_by = timezone.now(), None, self.actor()
        r.save()
        return ok("REQUISITION_APPROVED", "Requisition approved.", serialize_requisition(r, request))

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        if r.approval_status != "Submitted":
            return err("INVALID_STATE", "Only Submitted requisitions can be rejected.")
        r.approval_status, r.updated_by = "Rejected", self.actor()
        r.rejection_reason = request.data.get("reason")
        r.save()
        return ok("REQUISITION_REJECTED", "Requisition rejected.", serialize_requisition(r, request))

    @action(detail=True, methods=["post"])
    def duplicate(self, request, pk=None):
        src = self._get(pk)
        if src is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        company = self.company()
        year = timezone.localdate().year
        r = JobRequisition.objects.create(
            company=company, created_by=self.actor(), updated_by=self.actor(),
            requisition_id=next_seq(JobRequisition, company, "requisition_id", f"REQ-{year}-"),
            position_title=src.position_title, department=src.department,
            department_name=src.department_name, work_mode=src.work_mode, location=src.location,
            vacancies=src.vacancies, budget_min_lpa=src.budget_min_lpa,
            budget_max_lpa=src.budget_max_lpa, hiring_manager=src.hiring_manager,
            priority=src.priority, approval_status="Draft")
        return ok("REQUISITION_DUPLICATED", "Requisition duplicated as Draft.",
                  serialize_requisition(r, request), status=201)

    @action(detail=True, methods=["post"])
    def close(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        r.approval_status, r.closed_at, r.updated_by = "Closed", timezone.now(), self.actor()
        r.save()
        jd = getattr(r, "job_description", None)
        if jd and jd.is_published:
            jd.is_published = False
            jd.save(update_fields=["is_published", "updated_at"])
        return ok("REQUISITION_CLOSED", "Requisition closed.", serialize_requisition(r, request))


# ------------------------------------------------------------
# 3. JOB DESCRIPTIONS  /api/recruitment/job-descriptions/
# ------------------------------------------------------------
def serialize_jd(jd, request=None):
    r = jd.requisition
    return {
        "id": jd.id,
        "jd_code": jd.jd_code,
        "requisition": r.requisition_id,
        "requisition_pk": r.id,
        "position_title": r.position_title,
        "department": r.department.name if r.department_id else r.department_name,
        "location_mode": " ".join(x for x in [r.location, f"({r.work_mode})" if r.work_mode else ""] if x),
        "experience_min_years": float(jd.experience_min_years) if jd.experience_min_years is not None else None,
        "experience_max_years": float(jd.experience_max_years) if jd.experience_max_years is not None else None,
        "budget_min_lpa": lpa(r.budget_min_lpa),
        "budget_max_lpa": lpa(r.budget_max_lpa),
        "hiring_manager": emp_brief(r.hiring_manager, request),
        "required_skills": jd.required_skills,
        "responsibilities": jd.responsibilities,
        "qualifications": jd.qualifications,
        "is_published": jd.is_published,
        "visibility": "Published to Careers" if jd.is_published else "Draft / Unlisted",
        "published_at": jd.published_at,
    }


def jd_text(jd):
    r = jd.requisition
    lines = [f"{r.position_title} ({jd.jd_code})",
             f"Department: {r.department.name if r.department_id else r.department_name or '-'}",
             f"Location: {r.location or '-'} | Mode: {r.work_mode or '-'}",
             f"Experience: {jd.experience_min_years or '-'} - {jd.experience_max_years or '-'} years",
             f"Skills: {', '.join(jd.required_skills or [])}",
             "", "Responsibilities:", jd.responsibilities or "-"]
    if jd.qualifications:
        lines += ["", "Qualifications:", jd.qualifications]
    return "\n".join(lines)


class JobDescriptionViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"publish": "edit", "unpublish": "edit", "copy": "view", "pdf": "view"}

    def _get(self, pk):
        return JobDescription.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("requisition", "requisition__hiring_manager", "requisition__department").first()

    def _apply(self, jd, d):
        if "experience_min_years" in d:
            jd.experience_min_years = to_decimal(d.get("experience_min_years"))
        if "experience_max_years" in d:
            jd.experience_max_years = to_decimal(d.get("experience_max_years"))
        if "required_skills" in d:
            jd.required_skills = to_list(d.get("required_skills"))
        for f in ("responsibilities", "qualifications"):
            if f in d:
                setattr(jd, f, d.get(f))

    def list(self, request):
        qs = JobDescription.objects.filter(company=self.company(), is_active=True) \
            .select_related("requisition", "requisition__hiring_manager", "requisition__department")
        if request.query_params.get("published") not in (None, ""):
            qs = qs.filter(is_published=to_bool(request.query_params["published"]))
        return ok("JD_LIST", "Job descriptions.", [serialize_jd(j, request) for j in qs])

    @transaction.atomic
    def create(self, request):
        """Create a JD via a requisition (requisition = REQ code or id)."""
        d = request.data
        ref = d.get("requisition") or d.get("requisition_id")
        if not ref:
            return err("VALIDATION", "requisition is required.")
        company = self.company()
        r = JobRequisition.objects.filter(company=company, is_active=True).filter(
            Q(requisition_id=str(ref)) | Q(pk=int(ref) if str(ref).isdigit() else -1)).first()
        if r is None:
            return err("NOT_FOUND", "Requisition not found.", 404)
        if hasattr(r, "job_description"):
            return err("DUPLICATE", "This requisition already has a Job Description.")
        jd = JobDescription(company=company, requisition=r, created_by=self.actor(), updated_by=self.actor(),
                            jd_code=next_seq(JobDescription, company, "jd_code", "JD-"))
        try:
            self._apply(jd, d)
        except ValueError as e:
            return err("VALIDATION", str(e))
        jd.save()
        return ok("JD_CREATED", "Job description created.", serialize_jd(jd, request), status=201)

    def retrieve(self, request, pk=None):
        jd = self._get(pk)
        if jd is None:
            return err("NOT_FOUND", "Job description not found.", 404)
        return ok("JD_DETAIL", "Job description.", serialize_jd(jd, request))

    def _update(self, request, pk):
        jd = self._get(pk)
        if jd is None:
            return err("NOT_FOUND", "Job description not found.", 404)
        try:
            self._apply(jd, request.data)
        except ValueError as e:
            return err("VALIDATION", str(e))
        jd.updated_by = self.actor()
        jd.save()
        return ok("JD_UPDATED", "Job description updated.", serialize_jd(jd, request))

    def update(self, request, pk=None):
        return self._update(request, pk)

    def partial_update(self, request, pk=None):
        return self._update(request, pk)

    def destroy(self, request, pk=None):
        jd = self._get(pk)
        if jd is None:
            return err("NOT_FOUND", "Job description not found.", 404)
        jd.is_active = False
        jd.is_published = False
        jd.save(update_fields=["is_active", "is_published", "updated_at"])
        return ok("JD_DELETED", "Job description deleted.")

    @action(detail=True, methods=["post"])
    def publish(self, request, pk=None):
        jd = self._get(pk)
        if jd is None:
            return err("NOT_FOUND", "Job description not found.", 404)
        if jd.requisition.approval_status != "Approved":
            return err("NOT_APPROVED", "Only JDs of Approved requisitions can be published.")
        jd.is_published, jd.published_at, jd.updated_by = True, timezone.now(), self.actor()
        jd.save()
        return ok("JD_PUBLISHED", "Published to careers page.", serialize_jd(jd, request))

    @action(detail=True, methods=["post"])
    def unpublish(self, request, pk=None):
        jd = self._get(pk)
        if jd is None:
            return err("NOT_FOUND", "Job description not found.", 404)
        jd.is_published, jd.updated_by = False, self.actor()
        jd.save()
        return ok("JD_UNPUBLISHED", "Unpublished.", serialize_jd(jd, request))

    @action(detail=True, methods=["get"])
    def copy(self, request, pk=None):
        jd = self._get(pk)
        if jd is None:
            return err("NOT_FOUND", "Job description not found.", 404)
        return ok("JD_COPY", "JD text.", {"text": jd_text(jd)})

    @action(detail=True, methods=["get"])
    def pdf(self, request, pk=None):
        jd = self._get(pk)
        if jd is None:
            return err("NOT_FOUND", "Job description not found.", 404)
        from .pdf import simple_pdf
        content = simple_pdf(jd.requisition.position_title, jd_text(jd))
        resp = HttpResponse(content, content_type="application/pdf")
        resp["Content-Disposition"] = f'attachment; filename="{jd.jd_code}.pdf"'
        return resp


# ------------------------------------------------------------
# META  GET /api/recruitment/meta/   (dropdown values for the UI)
# ------------------------------------------------------------
class RecruitmentMetaView(RecruitmentAuthMixin, APIView):

    def get(self, request):
        from Employee.models import EmployeeDocument
        from .models import InterviewFeedback
        from .views_post import REQUIRED_DOC_TYPES
        return ok("RECRUITMENT_META", "Recruitment dropdown values.", {
            "stages": [{"code": c, "label": l} for c, l in STAGES],
            "priorities": [p for p, _ in JobRequisition.PRIORITY],
            "requisition_status": [s for s, _ in JobRequisition.APPROVAL],
            "work_modes": ["On-site", "Hybrid", "Remote"],
            "interview_status": [s for s, _ in InterviewRound.STATUS],
            "recommendations": [r for r, _ in InterviewFeedback.RECO],
            "score_fields": InterviewFeedback.SCORE_FIELDS,
            "offer_status": [s for s, _ in Offer.STATUS],
            "document_types": [{"code": c, "label": l} for c, l in EmployeeDocument.DOCUMENT_TYPE_CHOICES],
            "required_document_types": REQUIRED_DOC_TYPES,
            "bgv_status": [s for s, _ in BGVCase.STATUS],
        })

