# ============================================================
# 9 Selection | 10 Offer Management
# ============================================================
import logging
from datetime import timedelta
from decimal import Decimal

from django.db import transaction
from django.http import HttpResponse
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

from .common import (
    RecruitmentAuthMixin, ok, err, to_decimal, to_date, lpa, emp_brief, candidates_qs,
    candidate_brief, employee_by_code, next_seq, set_stage, get_profile,
)
from .models import CandidateSelection, Offer, JobRequisition
from . import hiring_plus as hp   # ADDITIVE: hike policy

LAKH = Decimal("100000")
logger = logging.getLogger(__name__)


def serialize_selection(s, request=None):
    c = s.candidate
    prof = get_profile(c, create=False)
    req = s.requisition or (prof.requisition if prof else None)
    return {
        "id": s.id,
        "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)),
        "approved_ctc_lpa": lpa(s.approved_ctc_lpa),
        "joining_date": s.joining_date,
        "reporting_manager": emp_brief(s.reporting_manager, request),
        "status": s.status,
        "remarks": s.remarks,
        "decided_by": s.decided_by,
        "decided_at": s.decided_at,
    }


class SelectionViewSet(RecruitmentAuthMixin, ViewSet):
    """
    GET   /api/recruitment/selection/                list finalists
    POST  /api/recruitment/selection/                select a candidate
    PATCH /api/recruitment/selection/<id>/           edit CTC / joining date / manager
    POST  /api/recruitment/selection/<id>/generate-offer/
    POST  /api/recruitment/selection/<id>/reject/
    """
    permission_action_map = {"generate_offer": "approve", "reject": "approve"}

    def _get(self, pk):
        return CandidateSelection.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("candidate", "requisition", "reporting_manager").first()

    def _apply(self, s, d):
        if "approved_ctc_lpa" in d:
            s.approved_ctc_lpa = to_decimal(d.get("approved_ctc_lpa"))
        if "joining_date" in d:
            s.joining_date = to_date(d.get("joining_date"))
        if "reporting_manager" in d:
            s.reporting_manager = employee_by_code(s.company, d.get("reporting_manager"))
        if "remarks" in d:
            s.remarks = d.get("remarks")

    def list(self, request):
        qs = CandidateSelection.objects.filter(company=self.company(), is_active=True) \
            .select_related("candidate", "requisition", "reporting_manager")
        if request.query_params.get("status"):
            qs = qs.filter(status__iexact=request.query_params["status"])
        return ok("SELECTION_LIST", "Final selection & offer rollout pipeline.",
                  [serialize_selection(s, request) for s in qs.order_by("-created_at")])

    @transaction.atomic
    def create(self, request):
        d = request.data
        company = self.company()
        ref = d.get("candidate")
        c = candidates_qs(company).filter(pk=ref if str(ref).isdigit() else -1).first()
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        stage = (c.candidate_status or "").upper()
        if stage in ("REJECTED", "JOINED", "OFFER_SENT", "OFFER_ACCEPTED"):
            return err("INVALID_STATE", f"A candidate in {stage} stage cannot be (re)selected.")
        if not c.interview_rounds.filter(feedback_status="Submitted").exists() \
                and str(d.get("skip_feedback_check")).lower() not in ("1", "true"):
            return err("NO_FEEDBACK", "No interview feedback yet. Submit feedback first "
                                      "(or send skip_feedback_check=true).")
        prof = get_profile(c, company)
        s, _ = CandidateSelection.objects.get_or_create(
            candidate=c, defaults={"company": company, "created_by": self.actor()})
        s.requisition, s.status, s.is_active = prof.requisition, "Selected", True
        s.decided_by, s.decided_at, s.updated_by = self.actor(), timezone.now(), self.actor()
        try:
            self._apply(s, d)
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        s.save()
        set_stage(c, "SELECTED", self.actor(), "Final selection")
        return ok("CANDIDATE_SELECTED", "Candidate selected.", serialize_selection(s, request), status=201)

    def retrieve(self, request, pk=None):
        s = self._get(pk)
        if s is None:
            return err("NOT_FOUND", "Selection not found.", 404)
        return ok("SELECTION_DETAIL", "Selection.", serialize_selection(s, request))

    def partial_update(self, request, pk=None):
        s = self._get(pk)
        if s is None:
            return err("NOT_FOUND", "Selection not found.", 404)
        try:
            self._apply(s, request.data)
        except ValueError as e:
            return err("VALIDATION", str(e))
        s.updated_by = self.actor()
        s.save()
        return ok("SELECTION_UPDATED", "Selection updated.", serialize_selection(s, request))

    update = partial_update

    @transaction.atomic
    def destroy(self, request, pk=None):
        s = self._get(pk)
        if s is None:
            return err("NOT_FOUND", "Selection not found.", 404)
        if s.status == "Offer Generated" and Offer.objects.filter(
                candidate=s.candidate, status__in=["Sent", "Accepted"]).exists():
            return err("IN_USE", "An offer is already sent / accepted. Withdraw it first.")
        s.is_active = False
        s.save(update_fields=["is_active", "updated_at"])
        if (s.candidate.candidate_status or "").upper() == "SELECTED":
            set_stage(s.candidate, "INTERVIEW", self.actor(), "Selection removed")
        return ok("SELECTION_DELETED", "Selection removed.")

    @action(detail=True, methods=["post"], url_path="generate-offer")
    def generate_offer(self, request, pk=None):
        s = self._get(pk)
        if s is None:
            return err("NOT_FOUND", "Selection not found.", 404)
        if s.status != "Selected":
            return err("INVALID_STATE", f"Selection is already {s.status}.")
        if not s.approved_ctc_lpa:
            return err("VALIDATION", "approved_ctc_lpa is required before generating an offer.")
        offer = create_offer(s.company, s.candidate, s.approved_ctc_lpa, s.joining_date,
                             request.data.get("valid_until"), request.data.get("designation"),
                             self.actor(), selection=s)
        return ok("OFFER_GENERATED", "Offer generated (Draft).", serialize_offer(offer, request), status=201)

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        s = self._get(pk)
        if s is None:
            return err("NOT_FOUND", "Selection not found.", 404)
        if s.status != "Selected":
            return err("INVALID_STATE", f"Selection is already {s.status}.")
        s.status, s.remarks, s.updated_by = "Rejected", request.data.get("reason") or s.remarks, self.actor()
        s.save()
        set_stage(s.candidate, "REJECTED", self.actor(), request.data.get("reason") or "Rejected at selection")
        prof = get_profile(s.candidate)
        prof.rejection_reason = request.data.get("reason")
        prof.save(update_fields=["rejection_reason", "updated_at"])
        return ok("SELECTION_REJECTED", "Candidate rejected.", serialize_selection(s, request))


# ------------------------------------------------------------
# 10. OFFERS
# ------------------------------------------------------------
def build_letter(offer):
    c, co = offer.candidate, offer.company
    cname = getattr(co, "Registered_Company_Name", None) or str(co)
    lines = [
        cname, "",
        f"OFFER OF EMPLOYMENT  (Ref: {offer.offer_id})",
        f"Date: {timezone.localdate():%d %b %Y}", "",
        f"Dear {c.name},", "",
        f"We are pleased to offer you the position of {offer.designation or c.applied_position or '-'} at {cname}.", "",
        f"Annual CTC: Rs. {offer.offered_ctc_lpa} LPA",
    ]
    if offer.target_joining_date:
        lines.append(f"Expected date of joining: {offer.target_joining_date:%d %b %Y}")
    if offer.valid_until:
        lines.append(f"This offer is valid until {offer.valid_until:%d %b %Y}.")
    lines += ["", "Please confirm your acceptance by replying to this offer.", "", "Regards,", "HR Team"]
    return "\n".join(lines)


def serialize_offer(o, request=None):
    return {
        "id": o.id,
        "offer_id": o.offer_id,
        "candidate": candidate_brief(o.candidate, request),
        "designation": o.designation or o.candidate.applied_position,
        "offered_ctc_lpa": lpa(o.offered_ctc_lpa),
        "target_joining_date": o.target_joining_date,
        "valid_until": o.valid_until,
        "status": o.status,
        "sent_at": o.sent_at,
        "responded_at": o.responded_at,
        "decline_reason": o.decline_reason,
        "hike": hp.hike_info(o.candidate, o.offered_ctc_lpa),     # ADDITIVE: last vs hike vs offered
    }


@transaction.atomic
def create_offer(company, candidate, ctc_lpa, joining, valid_until, designation, actor, selection=None):
    year = timezone.localdate().year
    # only one live offer per candidate
    Offer.objects.filter(company=company, candidate=candidate, status__in=["Draft", "Sent"]) \
        .update(status="Withdrawn")
    offer = Offer.objects.create(
        company=company, candidate=candidate, offered_ctc_lpa=ctc_lpa, target_joining_date=joining,
        valid_until=to_date(valid_until) or (timezone.localdate() + timedelta(days=7)),
        designation=designation or candidate.applied_position,
        offer_id=next_seq(Offer, company, "offer_id", f"OFF-{year}-"),
        created_by=actor, updated_by=actor)
    offer.letter_text = build_letter(offer)
    offer.save(update_fields=["letter_text"])
    comp, _ = CandidateCompensation.objects.get_or_create(employee=candidate)
    comp.offered_annual_ctc = Decimal(ctc_lpa) * LAKH
    comp.save()
    if selection is not None:
        selection.status = "Offer Generated"
        selection.save(update_fields=["status", "updated_at"])
    hp.evaluate_offer_hike(offer, actor)                # ADDITIVE: raise management approval if hike > limit
    return offer


class OfferViewSet(RecruitmentAuthMixin, ViewSet):
    """
    GET  /api/recruitment/offers/
    POST /api/recruitment/offers/                 direct offer {candidate, offered_ctc_lpa, ...}
    GET  /api/recruitment/offers/<id>/preview/    letter text
    GET  /api/recruitment/offers/<id>/pdf/
    POST /api/recruitment/offers/<id>/send/       -> candidate stage OFFER_SENT
    POST /api/recruitment/offers/<id>/accept/     -> OFFER_ACCEPTED
    POST /api/recruitment/offers/<id>/decline/    -> REJECTED (candidate declined)
    POST /api/recruitment/offers/<id>/withdraw/
    """
    permission_action_map = {"preview": "view", "pdf": "view", "send": "edit", "accept": "edit",
                             "decline": "edit", "withdraw": "edit"}

    def _get(self, pk):
        return Offer.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("candidate").first()

    def list(self, request):
        qs = Offer.objects.filter(company=self.company(), is_active=True).select_related("candidate")
        today = timezone.localdate()
        qs.filter(status="Sent", valid_until__lt=today).update(status="Expired")   # auto-expire
        if request.query_params.get("status"):
            qs = qs.filter(status__iexact=request.query_params["status"])
        return ok("OFFER_LIST", "Offer management & acceptance desk.",
                  [serialize_offer(o, request) for o in qs.order_by("-created_at")])

    def create(self, request):
        d = request.data
        company = self.company()
        c = candidates_qs(company).filter(pk=d.get("candidate") if str(d.get("candidate")).isdigit() else -1).first()
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        if (c.candidate_status or "").upper() in ("REJECTED", "JOINED"):
            return err("INVALID_STATE", "Cannot create an offer for a Rejected / Joined candidate.")
        try:
            ctc = to_decimal(d.get("offered_ctc_lpa"))
            joining = to_date(d.get("target_joining_date"))
            if not ctc or ctc <= 0:
                raise ValueError("offered_ctc_lpa is required.")
            offer = create_offer(company, c, ctc, joining, d.get("valid_until"), d.get("designation"), self.actor())
        except ValueError as e:
            return err("VALIDATION", str(e))
        except Exception as e:
            # Unexpected failure: log the full traceback on the server and return the real reason as JSON,
            # instead of Django's HTML 500 page (which the frontend can only show as "status code 500").
            logger.exception("Offer create failed (candidate pk=%s, company=%s)", c.pk, company.pk)
            return err("OFFER_CREATE_FAILED", f"Offer could not be created: {type(e).__name__}: {e}", 500)
        return ok("OFFER_CREATED", "Offer created (Draft).", serialize_offer(offer, request), status=201)

    def retrieve(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        return ok("OFFER_DETAIL", "Offer.", serialize_offer(o, request))

    @transaction.atomic
    def partial_update(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        if o.status != "Draft":
            return err("INVALID_STATE", "Only Draft offers can be edited. Withdraw and create a new one.")
        d = request.data
        try:
            if "offered_ctc_lpa" in d:
                v = to_decimal(d.get("offered_ctc_lpa"))
                if not v or v <= 0:
                    raise ValueError("offered_ctc_lpa must be greater than 0.")
                o.offered_ctc_lpa = v
                comp, _ = CandidateCompensation.objects.get_or_create(employee=o.candidate)
                comp.offered_annual_ctc = v * LAKH
                comp.save()
            if "target_joining_date" in d:
                o.target_joining_date = to_date(d.get("target_joining_date"))
            if "valid_until" in d:
                o.valid_until = to_date(d.get("valid_until"))
        except ValueError as e:
            transaction.set_rollback(True)
            return err("VALIDATION", str(e))
        if "designation" in d:
            o.designation = d.get("designation")
        o.letter_text = d.get("letter_text") or build_letter(o)
        o.updated_by = self.actor()
        o.save()
        hp.evaluate_offer_hike(o, self.actor())         # ADDITIVE
        return ok("OFFER_UPDATED", "Offer updated.", serialize_offer(o, request))

    update = partial_update

    @transaction.atomic
    def destroy(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        if o.status in ("Sent", "Accepted"):
            return err("INVALID_STATE", f"A {o.status} offer cannot be deleted. Withdraw it first.")
        o.is_active = False
        o.save(update_fields=["is_active", "updated_at"])
        sel = CandidateSelection.objects.filter(candidate=o.candidate, status="Offer Generated").first()
        if sel and not Offer.objects.filter(candidate=o.candidate, is_active=True,
                                            status__in=["Draft", "Sent", "Accepted"]).exists():
            sel.status = "Selected"
            sel.save(update_fields=["status", "updated_at"])
        return ok("OFFER_DELETED", "Offer deleted.")

    @action(detail=True, methods=["get"])
    def preview(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        return ok("OFFER_PREVIEW", "Offer letter.", {"offer_id": o.offer_id, "letter": o.letter_text or build_letter(o)})

    @action(detail=True, methods=["get"])
    def pdf(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        from .pdf import simple_pdf
        resp = HttpResponse(simple_pdf("Offer Letter", o.letter_text or build_letter(o)),
                            content_type="application/pdf")
        resp["Content-Disposition"] = f'attachment; filename="{o.offer_id}.pdf"'
        return resp

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def send(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        if o.status != "Draft":
            return err("INVALID_STATE", f"Only Draft offers can be sent (this one is {o.status}).")
        gate = hp.hike_gate_error(o)                    # ADDITIVE: hike policy gate
        if gate:
            return err("HIKE_APPROVAL_REQUIRED", gate, 409)
        o.status, o.sent_at, o.updated_by = "Sent", timezone.now(), self.actor()
        o.save()
        set_stage(o.candidate, "OFFER_SENT", self.actor(), f"{o.offer_id} sent")
        mailed = False
        if o.candidate.email and str(request.data.get("send_email", "true")).lower() in ("1", "true"):
            try:
                from django.core.mail import send_mail
                from django.conf import settings
                send_mail(f"Offer of Employment - {o.offer_id}", o.letter_text or build_letter(o),
                          getattr(settings, "DEFAULT_FROM_EMAIL", None), [o.candidate.email], fail_silently=False)
                mailed = True
            except Exception:
                mailed = False
        return ok("OFFER_SENT", "Offer sent.", serialize_offer(o, request), email_sent=mailed)

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def accept(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        if o.status != "Sent":
            return err("INVALID_STATE", f"Only Sent offers can be accepted (this one is {o.status}).")
        if o.valid_until and o.valid_until < timezone.localdate():
            return err("EXPIRED", "Offer validity has passed.")
        o.status, o.responded_at, o.updated_by = "Accepted", timezone.now(), self.actor()
        o.save()
        c = o.candidate
        if o.target_joining_date:
            c.expected_joining_date = o.target_joining_date
            c.save(update_fields=["expected_joining_date"])
        set_stage(c, "OFFER_ACCEPTED", self.actor(), f"{o.offer_id} accepted")
        return ok("OFFER_ACCEPTED", "Offer accepted.", serialize_offer(o, request))

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def decline(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        if o.status != "Sent":
            return err("INVALID_STATE", f"Only Sent offers can be declined (this one is {o.status}).")
        o.status, o.responded_at, o.decline_reason = "Declined", timezone.now(), request.data.get("reason")
        o.updated_by = self.actor()
        o.save()
        set_stage(o.candidate, "REJECTED", self.actor(), "Offer declined by candidate")
        return ok("OFFER_DECLINED", "Offer declined.", serialize_offer(o, request))

    @action(detail=True, methods=["post"])
    def withdraw(self, request, pk=None):
        o = self._get(pk)
        if o is None:
            return err("NOT_FOUND", "Offer not found.", 404)
        if o.status not in ("Draft", "Sent"):
            return err("INVALID_STATE", f"A {o.status} offer cannot be withdrawn.")
        o.status, o.updated_by = "Withdrawn", self.actor()
        o.save()
        if (o.candidate.candidate_status or "").upper() == "OFFER_SENT":
            set_stage(o.candidate, "SELECTED", self.actor(), f"{o.offer_id} withdrawn")
        return ok("OFFER_WITHDRAWN", "Offer withdrawn.", serialize_offer(o, request))

