# ============================================================
# ADDITIVE: 30-60-90 Day Review API (Profile360 -> "30-60-90 Review" tab) - fully dynamic per company
# ------------------------------------------------------------
# Mounted at /api/people/review-306090/   (People/review_urls.py)
# Auth: Company Admin, or HR employee whose role has the Employees checkboxes
#       (GET = view, POST assess/reset = edit).  Everything is company scoped.
#
#   GET  meta/                       the company's live configuration (milestones, statuses, outcomes, scale)
#   GET  /                           HR dashboard: who is due / overdue (?q ?department ?milestone ?state ?window)
#   GET  <employee_code>/            full review: header summary + 30 / 60 / 90 milestones (?milestone=30|60|90)
#   POST <employee_code>/assess/     create / update ONE milestone (the "Assess Milestone" modal)
#   POST <employee_code>/reset/      {milestone_day} - clear an assessment back to Pending
# ============================================================
from datetime import timedelta
from decimal import Decimal

from django.db import transaction
from django.db.models import Q
from django.utils import timezone
from rest_framework import status as http
from rest_framework.decorators import action
from rest_framework.viewsets import ViewSet

from . import review_engine as en
from .common import (PeopleAuthMixin, dept_name, emp_brief, emp_by_code, employees_qs, err, iso, log_history, ok,
                     paginate, to_date, to_int)
from .models import ReviewCriterion, ReviewMilestone

MAX_WINDOW = 400             # dashboard window default comes from the company's ReviewSettings


def saved_for(company, emp):
    return (ReviewMilestone.objects.filter(company=company, employee=emp, is_active=True)
            .prefetch_related("criteria"))


def review_payload(request, company, emp, only_day=None, cfg=None):
    cfg = cfg or en.Config(company)
    rows, summary = en.build_review(cfg, emp, saved_for(company, emp))
    if only_day:
        rows = [r for r in rows if r["milestone_day"] == only_day]
    return {"employee": {**emp_brief(emp, request), "joining_date": iso(emp.Date_of_Joining)},
            "tabs": en.tabs(cfg), "summary": summary, "milestones": rows}


class ReviewViewSet(PeopleAuthMixin, ViewSet):
    permission_action_map = {"assess": "edit", "reset": "edit"}
    lookup_value_regex = "[^/]+"

    # ------------------------------------------------------------ meta
    @action(detail=False, methods=["get"])
    def meta(self, request):
        return ok("REVIEW_META", "Review configuration (milestones, statuses, outcomes, scale).",
                  en.meta_payload(en.Config(self.company())))

    # ------------------------------------------------------------ dashboard
    def list(self, request):
        company, today = self.company(), timezone.localdate()
        cfg = en.Config(company)
        p = request.query_params
        try:
            window = max(1, min(to_int(p.get("window"), cfg.settings.window_days), MAX_WINDOW))
            only_day = to_int(p.get("milestone"))
        except ValueError as e:
            return err("VALIDATION", str(e))
        if only_day not in (None, *cfg.days):
            return err("VALIDATION", "milestone must be one of " + ", ".join(str(d) for d in cfg.days) + ".")
        state = (p.get("state") or "").strip().lower()
        if state and state not in ("overdue", "due_soon", "upcoming", "completed"):
            return err("VALIDATION", "state must be overdue, due_soon, upcoming or completed.")

        reviewed_ids = ReviewMilestone.objects.filter(company=company, is_active=True).values("employee_id")
        qs = (employees_qs(company).filter(is_active=True)
              .filter(Q(Date_of_Joining__gte=today - timedelta(days=window)) | Q(id__in=reviewed_ids))
              .select_related("department"))
        q = (p.get("q") or "").strip()
        if q:
            qs = qs.filter(Q(name__icontains=q) | Q(employee_code__icontains=q) | Q(email__icontains=q))
        dep = (p.get("department") or "").strip()
        if dep:
            qs = qs.filter(Q(department__name__iexact=dep) | Q(Department__iexact=dep))
        qs = qs.order_by("-Date_of_Joining", "-id")

        emps = list(qs)
        by_emp = {}
        for m in (ReviewMilestone.objects.filter(company=company, is_active=True, employee__in=emps)
                  .prefetch_related("criteria")):
            by_emp.setdefault(m.employee_id, {})[m.milestone_day] = m

        counts = {"employees": 0, "overdue": 0, "due_soon": 0, "upcoming": 0, "all_completed": 0,
                  "assessed_by_day": {str(d): 0 for d in cfg.days}}
        ratings, rows = [], []
        for e in emps:
            saved = by_emp.get(e.id, {})
            ms = [en.milestone_row(cfg, e, d, saved.get(d), today, include_criteria=False) for d in cfg.days]
            summ = en.summary_for(cfg, ms)
            pending = [m for m in ms if not m["is_assessed"]]
            worst = ("overdue" if any(m["due_state"] == "overdue" for m in pending)
                     else "due_soon" if any(m["due_state"] == "due_soon" for m in pending)
                     else "upcoming" if pending else "completed")
            counts["employees"] += 1
            counts["all_completed" if worst == "completed" else worst] += 1
            for m in ms:
                if m["is_assessed"]:
                    counts["assessed_by_day"][str(m["milestone_day"])] += 1
            if summ["overall_rating"] is not None:
                ratings.append(summ["overall_rating"])
            # filters
            if only_day and ms[cfg.days.index(only_day)]["is_assessed"]:
                continue
            if state and worst != state:          # same rule as the counts: the employee's most urgent state
                continue
            rows.append({"employee": emp_brief(e, request), "department": dept_name(e),
                         "joining_date": iso(e.Date_of_Joining),
                         "days_since_joining": (today - e.Date_of_Joining).days if e.Date_of_Joining else None,
                         "state": worst, "summary": summ,
                         "milestones": [{k: m[k] for k in ("milestone_day", "tab_label", "status", "status_label",
                                                           "rating", "target_date", "due_state", "days_left")}
                                        for m in ms]})
        counts["average_rating"] = float(en.average(ratings)) if ratings else None
        page, pg = paginate(request, rows, lambda r: r)
        return ok("REVIEW_DASHBOARD", "30-60-90 review dashboard.", page, meta=pg, counts=counts)

    # ------------------------------------------------------------ one employee
    def retrieve(self, request, pk=None):
        cfg = en.Config(self.company())
        try:
            emp = emp_by_code(self.company(), pk)
            day = to_int(request.query_params.get("milestone"))
        except ValueError as e:
            return err("NOT_FOUND", str(e), http.HTTP_404_NOT_FOUND)
        if day not in (None, *cfg.days):
            return err("VALIDATION", "milestone must be one of " + ", ".join(str(d) for d in cfg.days) + ".")
        return ok("REVIEW_360", "Milestone review.", review_payload(request, self.company(), emp, day, cfg))

    # ------------------------------------------------------------ assess (create / update)
    @action(detail=True, methods=["post"])
    def assess(self, request, pk=None):
        company = self.company()
        try:
            emp = emp_by_code(company, pk)
        except ValueError as e:
            return err("NOT_FOUND", str(e), http.HTTP_404_NOT_FOUND)
        d = request.data
        cfg = en.Config(company)
        try:
            day = to_int(d.get("milestone_day") if d.get("milestone_day") is not None else d.get("day"))
            if day not in cfg.days:
                raise ValueError("milestone_day must be one of " + ", ".join(str(x) for x in cfg.days) + ".")
            existing = (ReviewMilestone.objects.filter(company=company, employee=emp, milestone_day=day).first())
            tpl = cfg.tpl(day)

            criteria = en.parse_criteria(cfg, d.get("criteria"))
            strengths = en.parse_lines(d.get("strengths"), "strengths")
            improvements = en.parse_lines(d.get("improvements"), "improvements")
            score = en.parse_score(cfg, d.get("score") if "score" in d else d.get("rating"), "score")
            status = en.norm_status(cfg, d.get("status"), day)
            outcome = en.norm_outcome(cfg, d.get("outcome"), day) if "outcome" in d else None
            target = to_date(d.get("target_date")) if "target_date" in d else None
            completed = to_date(d.get("completed_date")) if "completed_date" in d else None

            if status is None:
                status = existing.status if existing else None
            scored_from_criteria = en.average([c["score"] for c in criteria]) if criteria else None
            final_score = (score if score is not None else scored_from_criteria
                           if scored_from_criteria is not None else (existing.score if existing else None))
            if status is None:
                status = (cfg.default_done_status(day) or "IN_PROGRESS") if final_score is not None else "IN_PROGRESS"
            if cfg.is_done(status) and final_score is None:
                raise ValueError("A completed assessment needs a milestone score or scored criteria.")
            doj = emp.Date_of_Joining
            if completed and doj and completed < doj:
                raise ValueError("completed_date cannot be before the joining date.")
            if cfg.is_done(status):
                completed = completed or (existing.completed_date if existing and existing.completed_date
                                          else timezone.localdate())
            reviewer_name = (str(d["reviewer_name"]).strip()[:150] if "reviewer_name" in d
                             else (existing.reviewer_name if existing and existing.reviewer_name else self.actor()))
            reviewer_title = (str(d["reviewer_title"]).strip()[:150] if "reviewer_title" in d
                              else (existing.reviewer_title if existing and existing.reviewer_title
                                    else tpl["default_reviewer_title"]))
            remarks = str(d["remarks"]).strip() if d.get("remarks") is not None else None
        except ValueError as e:
            return err("VALIDATION", str(e))

        actor = self.actor()
        with transaction.atomic():
            m = existing or ReviewMilestone(company=company, employee=emp, milestone_day=day, created_by=actor)
            m.status, m.score = status, final_score
            m.reviewer_name, m.reviewer_title = reviewer_name, reviewer_title
            m.target_date = target or m.target_date or en.target_for(emp, day)
            m.completed_date = completed if completed is not None else m.completed_date
            if strengths is not None:
                m.strengths = strengths
            if improvements is not None:
                m.improvements = improvements
            if remarks is not None:
                m.remarks = remarks
            if outcome is not None:
                m.outcome = outcome
            m.is_active, m.updated_by = True, actor
            m.save()
            if criteria is not None:
                m.criteria.all().delete()
                ReviewCriterion.objects.bulk_create([
                    ReviewCriterion(milestone=m, position=i, name=c["name"], score=c["score"], note=c["note"],
                                    created_by=actor, updated_by=actor) for i, c in enumerate(criteria, 1)])
            log_history(company, emp, "NOTE", f"{day}-day review {'completed' if cfg.is_done(status) else 'saved'}"
                        + (f" ({m.score}/5)" if m.score is not None else ""),
                        description=(m.remarks or "")[:500] or None, when=m.completed_date,
                        meta={"kind": "review_306090", "milestone_day": day, "status": status,
                              "score": float(m.score) if m.score is not None else None, "outcome": m.outcome},
                        actor=actor)
        return ok("REVIEW_SAVED", f"{day}-day review saved.", review_payload(request, company, emp, None, cfg),
                  status=http.HTTP_200_OK if existing else http.HTTP_201_CREATED)

    # ------------------------------------------------------------ reset
    @action(detail=True, methods=["post"])
    def reset(self, request, pk=None):
        company = self.company()
        cfg = en.Config(company)
        try:
            emp = emp_by_code(company, pk)
            day = to_int(request.data.get("milestone_day"))
        except ValueError as e:
            return err("NOT_FOUND", str(e), http.HTTP_404_NOT_FOUND)
        if day not in cfg.days:
            return err("VALIDATION", "milestone_day must be one of " + ", ".join(str(x) for x in cfg.days) + ".")
        m = ReviewMilestone.objects.filter(company=company, employee=emp, milestone_day=day).first()
        if m is None:
            return err("NOT_FOUND", f"No {day}-day assessment to reset.", http.HTTP_404_NOT_FOUND)
        with transaction.atomic():
            m.delete()
            log_history(company, emp, "NOTE", f"{day}-day review reset to Pending",
                        meta={"kind": "review_306090", "milestone_day": day, "action": "reset"}, actor=self.actor())
        return ok("REVIEW_RESET", f"{day}-day review reset to Pending.", review_payload(request, company, emp, None, cfg))

