# ============================================================
# 9. CONFIRMATION (probation reviews)   /api/people/confirmation/
# ============================================================
import calendar
import re
from datetime import timedelta
from decimal import Decimal

from django.db import transaction
from django.utils import timezone
from rest_framework.decorators import action

from .common import (CrudBase, emp_brief, emp_by_code, employees_qs, ensure_extra, err, iso, log_history, ok,
                     to_bool, to_date, to_decimal)
from .letters import issue_letter
from .models import ConfirmationReview
from .views_letters import letter_row


def assessment_label(r):
    if r is None:
        return "Not Assessed"
    r = float(r)
    return ("Exceeds Expectations" if r >= 4.5 else "Meets Expectations" if r >= 3.5
            else "Needs Improvement" if r >= 2.5 else "Below Expectations")


def _add_months(d, n):
    m = d.month - 1 + n
    y, m = d.year + m // 12, m % 12 + 1
    return d.replace(year=y, month=m, day=min(d.day, calendar.monthrange(y, m)[1]))


def probation_due(emp, extra):
    """extra.probation_due_date, else DOJ + Probation_Period ('3 months' / '90 days' / '6')."""
    if extra and extra.probation_due_date:
        return extra.probation_due_date
    doj, txt = emp.Date_of_Joining, (emp.Probation_Period or "").lower()
    m = re.search(r"(\d+)", txt)
    if not doj or not m:
        return None
    n = int(m.group(1))
    return doj + timedelta(days=n) if "day" in txt else _add_months(doj, n)


def sync_probationers(company, actor):
    """Idempotent: make sure every probationer has an open (Pending) review row."""
    made = 0
    for e in employees_qs(company).filter(is_active=True):
        x = ensure_extra(e)
        if x.lifecycle_status not in ("Probation", "Extended"):
            continue
        if ConfirmationReview.objects.filter(employee=e, is_active=True, status="Pending").exists():
            continue
        ConfirmationReview.objects.create(company=company, employee=e, probation_due_date=probation_due(e, x),
                                          created_by=actor, updated_by=actor)
        made += 1
    return made


class ConfirmationViewSet(CrudBase):
    """
    GET  /api/people/confirmation/                      ?status=Pending (default) | all ; ?search=
    POST /api/people/confirmation/                      open a review manually {employee_code, probation_due_date?}
    POST /api/people/confirmation/<id>/assess/          {manager_rating, manager_remarks?, recommendation?}
    POST /api/people/confirmation/<id>/confirm/         "Confirm & Issue Letter"  {confirmation_date?, issue_letter?=true}
    POST /api/people/confirmation/<id>/extend/          {extended_until, remarks?}
    POST /api/people/confirmation/<id>/terminate/       {remarks?}  (then start Exit from the 360 profile)
    """
    model = ConfirmationReview
    code = "CONFIRMATION"
    select = ("employee", "employee__department", "employee__people_profile")
    search_fields = ("employee__name", "employee__employee_code")

    def build(self, c):
        rating = float(c.manager_rating) if c.manager_rating is not None else None
        return {"id": c.id, "employee": emp_brief(c.employee), "joining_date": iso(c.employee.Date_of_Joining),
                "probation_due_date": iso(c.probation_due_date), "manager_rating": rating,
                "manager_assessment": f"{assessment_label(c.manager_rating)} ({rating}/5)" if rating is not None else "Not Assessed",
                "assessment_label": assessment_label(c.manager_rating), "manager_remarks": c.manager_remarks,
                "recommendation": c.recommendation, "status": c.status, "extended_until": iso(c.extended_until),
                "decided_by": c.decided_by, "decided_on": iso(c.decided_on), "letter_id": c.letter_id,
                "overdue": bool(c.status == "Pending" and c.probation_due_date and c.probation_due_date < timezone.localdate())}

    def list(self, request):
        sync_probationers(self.company(), self.actor())
        p = request.query_params
        qs = self.scope().filter(is_active=True)
        st = p.get("status", "Pending")
        if st != "all":
            qs = qs.filter(status=st)
        q = (p.get("search") or "").strip()
        if q:
            from django.db.models import Q
            qs = qs.filter(Q(employee__name__icontains=q) | Q(employee__employee_code__icontains=q))
        rows = [self.build(c) for c in qs]
        under = self.scope().filter(is_active=True, status="Pending").count()
        return ok("CONFIRMATION_LIST", "Probation assessment & confirmation reviews.", rows,
                  summary={"under_probation": under, "label": f"{under} Under Probation"})

    def apply(self, c, d, creating):
        if c.status != "Pending":
            raise ValueError(f"Review is already {c.status.lower()}.")
        if creating:
            e = emp_by_code(self.company(), d.get("employee_code"))
            if ConfirmationReview.objects.filter(employee=e, is_active=True, status="Pending").exists():
                raise ValueError("A pending review already exists for this employee.")
            c.employee = e
            c.probation_due_date = to_date(d.get("probation_due_date")) or probation_due(e, ensure_extra(e))
        elif "probation_due_date" in d:
            c.probation_due_date = to_date(d["probation_due_date"])
        self._assessment(c, d)

    @staticmethod
    def _assessment(c, d):
        if "manager_rating" in d:
            r = to_decimal(d["manager_rating"])
            if r is not None and not (0 <= r <= 5):
                raise ValueError("manager_rating must be between 0 and 5.")
            c.manager_rating = r
            if r is not None and not d.get("recommendation") and not c.recommendation:
                c.recommendation = "Confirm Permanent" if r >= 3.5 else ("Extend Probation" if r >= 2.5 else "Terminate")
        if "manager_remarks" in d:
            c.manager_remarks = d["manager_remarks"]
        if "recommendation" in d:
            if d["recommendation"] and d["recommendation"] not in dict(ConfirmationReview.RECO):
                raise ValueError(f"Invalid recommendation. Allowed: {', '.join(dict(ConfirmationReview.RECO))}")
            c.recommendation = d["recommendation"] or None

    def _c(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    @action(detail=True, methods=["post"])
    def assess(self, request, pk=None):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Review not found.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Review is already {c.status.lower()}.", 409)
        try:
            self._assessment(c, request.data)
        except ValueError as e:
            return err("VALIDATION", str(e))
        c.updated_by = self.actor()
        c.save()
        return ok("CONFIRMATION_ASSESSED", "Assessment saved.", self.build(c))

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def confirm(self, request, pk=None):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Review not found.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Review is already {c.status.lower()}.", 409)
        d = request.data
        try:
            self._assessment(c, d)
            when = to_date(d.get("confirmation_date")) or timezone.localdate()
        except ValueError as e:
            return err("VALIDATION", str(e))
        e = c.employee
        x = ensure_extra(e)
        x.lifecycle_status, x.confirmation_date, x.updated_by = "Confirmed", when, self.actor()
        x.save()
        if not e.Employee_Type:
            e.Employee_Type = "Full-Time Permanent"
            e.save()
        c.status, c.decided_by, c.decided_on, c.recommendation = "Confirmed", self.actor(), when, c.recommendation or "Confirm Permanent"
        c.updated_by = self.actor()
        c.save()
        log_history(c.company, e, "CONFIRMATION", "Confirmed as permanent employee",
                    f"Probation review: {assessment_label(c.manager_rating)}", when, {"review_id": c.id}, self.actor())
        letter = None
        if to_bool(d.get("issue_letter"), True):
            l = issue_letter(c.company, e, "CONFIRMATION", self.actor(), {"confirmation_date": when})
            c.letter = l
            c.save()
            letter = letter_row(l, request)
        return ok("CONFIRMED", "Employee confirmed.", {**self.build(c), "letter": letter})

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def extend(self, request, pk=None):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Review not found.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Review is already {c.status.lower()}.", 409)
        try:
            until = to_date(request.data.get("extended_until"))
            self._assessment(c, request.data)
        except ValueError as e:
            return err("VALIDATION", str(e))
        if not until or (c.probation_due_date and until <= c.probation_due_date):
            return err("VALIDATION", "extended_until must be a date after the current probation due date.")
        e = c.employee
        x = ensure_extra(e)
        x.lifecycle_status, x.probation_due_date, x.updated_by = "Extended", until, self.actor()
        x.save()
        c.status, c.extended_until, c.recommendation = "Extended", until, "Extend Probation"
        c.decided_by, c.decided_on, c.updated_by = self.actor(), timezone.localdate(), self.actor()
        c.save()
        ConfirmationReview.objects.create(company=c.company, employee=e, probation_due_date=until,
                                          created_by=self.actor(), updated_by=self.actor())
        log_history(c.company, e, "PROBATION_EXTENDED", f"Probation extended till {until}",
                    request.data.get("remarks"), actor=self.actor())
        return ok("PROBATION_EXTENDED", "Probation extended; a new review is queued.", self.build(c))

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def terminate(self, request, pk=None):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Review not found.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Review is already {c.status.lower()}.", 409)
        c.status, c.recommendation = "Terminated", "Terminate"
        c.decided_by, c.decided_on, c.updated_by = self.actor(), timezone.localdate(), self.actor()
        if request.data.get("remarks"):
            c.manager_remarks = request.data["remarks"]
        c.save()
        log_history(c.company, c.employee, "NOTE", "Probation not cleared - termination recommended",
                    request.data.get("remarks"), actor=self.actor())
        return ok("PROBATION_TERMINATED", "Marked as terminated. Start the exit process from the employee 360 profile.",
                  self.build(c))
