# ============================================================
# ADDITIVE: 30-60-90 Day Review - CONFIGURATION API (everything is editable, nothing hard-coded)
# ------------------------------------------------------------
# Mounted at /api/people/review-306090-config/   (People/review_urls.py)
# Read  = Employees "view" right.   Write = Company Admin or Employees "manage" right.
#
#   GET  /                                  whole configuration (same payload as review-306090/meta/)
#   POST settings/                          {due_soon_days, window_days, score_min, score_max, score_step}
#   POST milestones/                        add a milestone (any day 1-730, up to 6)
#   POST milestones/<day>/update/           edit titles / labels / table headers / reviewer title / criteria
#   POST milestones/<day>/delete/           remove (soft-hides it when assessments already exist)
#   POST options/                           add a status or final-outcome option
#   POST options/<id>/update/               rename / re-scope / reorder an option
#   POST options/<id>/delete/               remove (soft-hides it when already used)
#   POST reset-defaults/                    restore any missing standard 30/60/90 rows (never overwrites edits)
# ============================================================
import re
from decimal import Decimal, InvalidOperation

from django.db import transaction
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, err, ok, to_bool
from .models import (ReviewCriterion, ReviewMilestone, ReviewOption, ReviewTemplate, ReviewTemplateCriterion)

TEXT_LIMITS = {"title": 150, "tab_label": 150, "subtitle": 250, "section_title": 150, "default_reviewer_title": 150}


def _dec(v, label):
    try:
        return Decimal(str(v))
    except (InvalidOperation, ValueError):
        raise ValueError(f"{label} must be a number.")


def _day(v, label="milestone_day"):
    try:
        d = int(v)
    except (TypeError, ValueError):
        raise ValueError(f"{label} must be a whole number of days (1-{en.MAX_DAY}).")
    if d < 1 or d > en.MAX_DAY:
        raise ValueError(f"{label} must be between 1 and {en.MAX_DAY}.")
    return d


def _days_list(v):
    if v in (None, ""):
        return []
    if not isinstance(v, (list, tuple)):
        raise ValueError("milestone_days must be a list of day numbers (empty = every milestone).")
    return sorted({_day(x, "milestone_days[]") for x in v})


def _dict_of(v, allowed, label):
    if not isinstance(v, dict):
        raise ValueError(f"{label} must be an object.")
    bad = [k for k in v if k not in allowed]
    if bad:
        raise ValueError(f"{label}: unknown key(s) {', '.join(bad)}. Allowed: {', '.join(allowed)}.")
    out = {}
    for k, val in v.items():
        val = str(val or "").strip()
        if len(val) > 150:
            raise ValueError(f"{label}.{k} is too long (max 150).")
        out[k] = val
    return out


def _criteria_names(v):
    if not isinstance(v, (list, tuple)):
        raise ValueError("criteria must be a list of names.")
    if len(v) > en.MAX_CRITERIA:
        raise ValueError(f"At most {en.MAX_CRITERIA} criteria.")
    names, seen = [], set()
    for x in v:
        n = str((x.get("name") if isinstance(x, dict) else x) or "").strip()
        if not n:
            raise ValueError("Criterion names cannot be empty.")
        if len(n) > 200:
            raise ValueError("Criterion name is too long (max 200).")
        if n.lower() in seen:
            raise ValueError(f"Duplicate criterion '{n}'.")
        seen.add(n.lower())
        names.append(n)
    return names


def _code_from(label, maxlen):
    return (re.sub(r"[^A-Z0-9]+", "_", label.upper()).strip("_") or "OPTION")[:maxlen]


class ReviewConfigViewSet(PeopleAuthMixin, ViewSet):
    permission_action_map = {"list": "view", "update_settings": "manage", "milestone_create": "manage",
                             "milestone_update": "manage", "milestone_delete": "manage", "option_create": "manage",
                             "option_update": "manage", "option_delete": "manage", "reset_defaults": "manage"}

    def initial(self, request, *args, **kwargs):
        super().initial(request, *args, **kwargs)        # authentication + permission first
        en.ensure_defaults(self.company())                # then make sure this company's rows exist (idempotent)

    def _payload(self):
        return en.meta_payload(en.Config(self.company()))

    # ------------------------------------------------------------ read
    def list(self, request):
        return ok("REVIEW_CONFIG", "Review configuration.", self._payload())

    # ------------------------------------------------------------ settings
    @action(detail=False, methods=["post"], url_path="settings")
    def update_settings(self, request):
        company, d = self.company(), request.data
        cfg = en.Config(company)
        s = cfg.settings
        try:
            if "due_soon_days" in d:
                s.due_soon_days = _int_range(d["due_soon_days"], "due_soon_days", 0, 60)
            if "window_days" in d:
                s.window_days = _int_range(d["window_days"], "window_days", 1, 400)
            lo = _dec(d["score_min"], "score_min") if "score_min" in d else cfg.smin
            hi = _dec(d["score_max"], "score_max") if "score_max" in d else cfg.smax
            step = _dec(d["score_step"], "score_step") if "score_step" in d else Decimal(str(s.score_step))
            if lo < 0 or hi > 100 or hi <= lo:
                raise ValueError("score_max must be greater than score_min (range 0 - 100).")
            if step <= 0 or step > (hi - lo):
                raise ValueError("score_step must be positive and not larger than the score range.")
            if (lo, hi) != (cfg.smin, cfg.smax):
                bad = (ReviewMilestone.objects.filter(company=company, score__isnull=False)
                       .exclude(score__gte=lo, score__lte=hi).count()
                       + ReviewCriterion.objects.filter(milestone__company=company, score__isnull=False)
                       .exclude(score__gte=lo, score__lte=hi).count())
                if bad:
                    raise ValueError(f"{bad} saved score(s) fall outside {lo}-{hi}. Re-assess them first.")
            s.score_min, s.score_max, s.score_step = lo, hi, step
        except ValueError as e:
            return err("VALIDATION", str(e))
        s.updated_by = self.actor()
        s.save()
        return ok("REVIEW_SETTINGS_SAVED", "Settings saved.", self._payload())

    # ------------------------------------------------------------ milestones
    def _apply_template(self, t, d, creating):
        for f, mx in TEXT_LIMITS.items():
            if f in d:
                val = str(d[f] or "").strip()
                if len(val) > mx:
                    raise ValueError(f"{f} is too long (max {mx}).")
                setattr(t, f, val)
        if "table_headers" in d:
            t.table_headers = {**(t.table_headers or {}), **_dict_of(d["table_headers"], en.HEADER_KEYS, "table_headers")}
        if "labels" in d:
            t.labels = {**(t.labels or {}), **_dict_of(d["labels"], en.LABEL_KEYS, "labels")}
        if creating and not t.title:
            raise ValueError("title is required.")
        if "title" in d and not t.title:
            raise ValueError("title cannot be empty.")

    @action(detail=False, methods=["post"], url_path="milestones")
    def milestone_create(self, request):
        company, d, actor = self.company(), request.data, self.actor()
        try:
            day = _day(d.get("milestone_day"))
            names = _criteria_names(d["criteria"]) if "criteria" in d else []
            existing = ReviewTemplate.objects.filter(company=company, milestone_day=day).first()
            if existing and existing.is_active:
                raise ValueError(f"A {day}-day milestone already exists. Use update instead.")
            if ReviewTemplate.objects.filter(company=company, is_active=True).count() >= en.MAX_MILESTONES:
                raise ValueError(f"At most {en.MAX_MILESTONES} milestones.")
            t = existing or ReviewTemplate(company=company, milestone_day=day, created_by=actor)
            if existing:
                t.table_headers, t.labels = {}, {}
            self._apply_template(t, d, creating=True)
        except ValueError as e:
            return err("VALIDATION", str(e))
        with transaction.atomic():
            t.is_active, t.updated_by = True, actor
            t.save()
            t.criteria.all().delete()
            ReviewTemplateCriterion.objects.bulk_create([
                ReviewTemplateCriterion(template=t, position=i, name=n, created_by=actor, updated_by=actor)
                for i, n in enumerate(names, 1)])
        return ok("REVIEW_MILESTONE_CREATED", f"{day}-day milestone added.", self._payload(),
                  status=http.HTTP_201_CREATED)

    def _tpl(self, day):
        try:
            return ReviewTemplate.objects.filter(company=self.company(), milestone_day=int(day), is_active=True).first()
        except (TypeError, ValueError):
            return None

    @action(detail=False, methods=["post"], url_path=r"milestones/(?P<day>\d+)/update")
    def milestone_update(self, request, day=None):
        t, d, actor = self._tpl(day), request.data, self.actor()
        if t is None:
            return err("NOT_FOUND", f"No {day}-day milestone.", http.HTTP_404_NOT_FOUND)
        try:
            names = _criteria_names(d["criteria"]) if "criteria" in d else None
            self._apply_template(t, d, creating=False)
        except ValueError as e:
            return err("VALIDATION", str(e))
        with transaction.atomic():
            t.updated_by = actor
            t.save()
            if names is not None:          # saved assessments keep their own criteria rows (history is never rewritten)
                t.criteria.all().delete()
                ReviewTemplateCriterion.objects.bulk_create([
                    ReviewTemplateCriterion(template=t, position=i, name=n, created_by=actor, updated_by=actor)
                    for i, n in enumerate(names, 1)])
        return ok("REVIEW_MILESTONE_SAVED", f"{day}-day milestone saved.", self._payload())

    @action(detail=False, methods=["post"], url_path=r"milestones/(?P<day>\d+)/delete")
    def milestone_delete(self, request, day=None):
        t, company = self._tpl(day), self.company()
        if t is None:
            return err("NOT_FOUND", f"No {day}-day milestone.", http.HTTP_404_NOT_FOUND)
        if ReviewTemplate.objects.filter(company=company, is_active=True).count() <= 1:
            return err("VALIDATION", "At least one milestone must remain.")
        used = ReviewMilestone.objects.filter(company=company, milestone_day=t.milestone_day).exists()
        if used:
            t.is_active, t.updated_by = False, self.actor()
            t.save()
        else:
            t.delete()
        return ok("REVIEW_MILESTONE_REMOVED",
                  f"{day}-day milestone " + ("hidden (assessments exist; they are kept)." if used else "deleted."),
                  self._payload())

    # ------------------------------------------------------------ options (statuses / outcomes)
    def _option_fields(self, d, o, creating):
        kind = o.kind
        if "label" in d or creating:
            label = str(d.get("label") or "").strip()
            if not label or len(label) > 100:
                raise ValueError("label is required (max 100 characters).")
            o.label = label
        if "milestone_days" in d:
            o.milestone_days = _days_list(d["milestone_days"])
        elif creating and kind == "OUTCOME":
            o.milestone_days = []
        if "position" in d:
            o.position = _int_range(d["position"], "position", 0, 999)
        if kind == "STATUS" and "counts_as_completed" in d:
            if o.is_system:
                raise ValueError(f"'{o.label}' is a system status; it never counts as completed.")
            o.counts_as_completed = to_bool(d["counts_as_completed"])

    @action(detail=False, methods=["post"], url_path="options")
    def option_create(self, request):
        company, d, actor = self.company(), request.data, self.actor()
        try:
            kind = str(d.get("kind") or "").strip().upper()
            if kind not in ("STATUS", "OUTCOME"):
                raise ValueError("kind must be STATUS or OUTCOME.")
            o = ReviewOption(company=company, kind=kind, created_by=actor, updated_by=actor)
            self._option_fields(d, o, creating=True)
            code = _code_from(str(d.get("code") or o.label), 20 if kind == "STATUS" else 30)
            if ReviewOption.objects.filter(company=company, kind=kind, code=code).exists():
                raise ValueError(f"'{code}' already exists. Pick a different label/code.")
            if ReviewOption.objects.filter(company=company, kind=kind, label__iexact=o.label, is_active=True).exists():
                raise ValueError(f"'{o.label}' already exists.")
            o.code = code
            if "position" not in d:
                o.position = ReviewOption.objects.filter(company=company, kind=kind).count() + 1
        except ValueError as e:
            return err("VALIDATION", str(e))
        o.save()
        return ok("REVIEW_OPTION_CREATED", f"{o.label} added.", self._payload(), status=http.HTTP_201_CREATED)

    def _opt(self, pk):
        return (ReviewOption.objects.filter(company=self.company(), pk=int(pk), is_active=True).first()
                if str(pk).isdigit() else None)

    @action(detail=False, methods=["post"], url_path=r"options/(?P<pk>\d+)/update")
    def option_update(self, request, pk=None):
        o = self._opt(pk)
        if o is None:
            return err("NOT_FOUND", "Option not found.", http.HTTP_404_NOT_FOUND)
        try:
            if "label" in request.data and ReviewOption.objects.filter(
                    company=o.company, kind=o.kind, is_active=True, label__iexact=str(request.data["label"]).strip()
            ).exclude(pk=o.pk).exists():
                raise ValueError("Another option already uses that label.")
            self._option_fields(request.data, o, creating=False)
            if o.kind == "STATUS" and not o.counts_as_completed and not o.is_system:
                others = ReviewOption.objects.filter(company=o.company, kind="STATUS", is_active=True,
                                                     counts_as_completed=True).exclude(pk=o.pk)
                if not others.exists():
                    raise ValueError("At least one status must count as completed.")
        except ValueError as e:
            return err("VALIDATION", str(e))
        o.updated_by = self.actor()
        o.save()
        return ok("REVIEW_OPTION_SAVED", f"{o.label} saved.", self._payload())

    @action(detail=False, methods=["post"], url_path=r"options/(?P<pk>\d+)/delete")
    def option_delete(self, request, pk=None):
        o = self._opt(pk)
        if o is None:
            return err("NOT_FOUND", "Option not found.", http.HTTP_404_NOT_FOUND)
        if o.is_system:
            return err("VALIDATION", f"'{o.label}' is a system status and cannot be removed.")
        if o.kind == "STATUS" and o.counts_as_completed and not ReviewOption.objects.filter(
                company=o.company, kind="STATUS", is_active=True, counts_as_completed=True).exclude(pk=o.pk).exists():
            return err("VALIDATION", "At least one status must count as completed.")
        field = "status" if o.kind == "STATUS" else "outcome"
        used = ReviewMilestone.objects.filter(company=o.company, **{field: o.code}).exists()
        if used:
            o.is_active, o.updated_by = False, self.actor()
            o.save()
        else:
            o.delete()
        return ok("REVIEW_OPTION_REMOVED", f"{o.label} " + ("hidden (already used; old records keep it)." if used
                                                           else "deleted."), self._payload())

    # ------------------------------------------------------------ reset defaults
    @action(detail=False, methods=["post"], url_path="reset-defaults")
    def reset_defaults(self, request):
        en.Config(self.company())           # make sure the seed ran
        with transaction.atomic():
            en.seed_defaults(self.company(), self.actor())
        return ok("REVIEW_DEFAULTS_RESTORED", "Missing standard 30/60/90 rows restored (your edits are kept).",
                  self._payload())


def _int_range(v, label, lo, hi):
    try:
        n = int(v)
    except (TypeError, ValueError):
        raise ValueError(f"{label} must be a whole number.")
    if n < lo or n > hi:
        raise ValueError(f"{label} must be between {lo} and {hi}.")
    return n
