# ============================================================
# ADDITIVE: 30-60-90 Day Review - DYNAMIC engine.
# Everything shown / validated comes from the company's own configuration rows
# (ReviewSettings, ReviewTemplate(+Criterion), ReviewOption).  DEFAULTS below is ONLY the first-time seed.
# Pure helpers (no HTTP). Used by views_review*.py
# ============================================================
from collections import OrderedDict
from datetime import timedelta
from decimal import ROUND_HALF_UP, Decimal

from django.db import IntegrityError, transaction
from django.utils import timezone

from .models import (ReviewCriterion, ReviewMilestone, ReviewOption, ReviewSettings, ReviewTemplate,
                     ReviewTemplateCriterion)

MAX_MILESTONES, MAX_CRITERIA, MAX_LINES, MAX_LINE_LEN, MAX_DAY = 6, 15, 20, 500, 730
LABEL_KEYS = ("target_date", "reviewer", "status", "strengths", "improvements", "remarks", "outcome")
HEADER_KEYS = ("criterion", "score", "notes")
FALLBACK_LABELS = {"target_date": "Target Assessment Date", "reviewer": "Assessed By", "status": "Completion Status",
                   "strengths": "Key Strengths", "improvements": "Areas for Improvement / Next Goals",
                   "remarks": "Manager & HR Remarks", "outcome": "Probation & Employment Outcome"}
FALLBACK_HEADERS = {"criterion": "Evaluation Parameter", "score": "Score", "notes": "Observations & Notes"}

# ---------------------------------------------------------------- first-time seed ONLY
DEFAULTS = {
    "settings": {"due_soon_days": 7, "window_days": 120, "score_min": 1, "score_max": 5, "score_step": 0.5},
    "statuses": [   # code, label, counts_as_completed, milestone_days ([] = all), system
        ("PENDING", "Pending", False, [], True), ("IN_PROGRESS", "In Progress", False, [], True),
        ("COMPLETED", "Completed", True, [], False), ("COMPETENT_STRONG", "Competent & Strong", True, [], False),
        ("CONFIRMED", "Confirmed", True, [90], False), ("NEEDS_IMPROVEMENT", "Needs Improvement", True, [], False)],
    "outcomes": [
        ("RECOMMENDED_CONFIRMATION", "Recommended for Full Confirmation", [90]),
        ("EXTEND_PROBATION", "Extend Probation", [90]),
        ("NOT_RECOMMENDED", "Not Recommended for Confirmation", [90])],
    "milestones": {
        30: {"title": "Performance of the Employee", "tab_label": "Performance of the Employee",
             "subtitle": "Initial Role Adaptation, Deliverables & Working Cadence",
             "section_title": "Performance Criteria Breakdown",
             "table_headers": {"criterion": "Evaluation Parameter", "score": "Score", "notes": "Observations & Notes"},
             "labels": {"target_date": "Target Assessment Date", "reviewer": "Assessed By", "status": "Completion Status",
                        "strengths": "Key Performance Strengths (Day 30)", "improvements": "Action Items for Days 31-60",
                        "remarks": "Manager & HR Performance Remarks (30 Days)"},
             "default_reviewer_title": "HR Operations & Line Manager",
             "criteria": ["Role Clarity & Expectation Alignment", "Initial Task Deliverables & Velocity",
                          "Punctuality, Attendance & Work Cadence", "Team Communication & Cultural Fit",
                          "Onboarding & Compliance Training"]},
        60: {"title": "Technical Strong", "tab_label": "Technical Strong",
             "subtitle": "Technical Competency, Depth of Knowledge & Autonomy",
             "section_title": "Technical Depth & Engineering Criteria",
             "table_headers": {"criterion": "Technical Competency Area", "score": "Score",
                               "notes": "Technical Assessment Notes"},
             "labels": {"target_date": "Technical Evaluation Date", "reviewer": "Evaluator / Lead",
                        "status": "Technical Status", "strengths": "Key Technical Strengths (60 Days)",
                        "improvements": "Upskilling & Advanced Domain Areas",
                        "remarks": "Technical Lead & Engineering Evaluation Remarks (60 Days)"},
             "default_reviewer_title": "Technical Lead & Engineering Manager",
             "criteria": ["Technical Stack Mastery & Tool Competency", "Code / Work Quality & Best Practices",
                          "Complex Problem Solving & Troubleshooting", "Task Autonomy & Execution Speed",
                          "Technical Reviews & Collaboration"]},
        90: {"title": "Overall Flow", "tab_label": "Overall Flow",
             "subtitle": "End-to-End Workflow Mastery, Cross-Functional Impact & Final Confirmation",
             "section_title": "Overall Flow & Workflow Mastery Parameters",
             "table_headers": {"criterion": "Workflow & Impact Criterion", "score": "Score",
                               "notes": "Integration & Flow Analysis"},
             "labels": {"target_date": "Final Assessment Date", "reviewer": "Reviewed by",
                        "status": "Completion Status", "strengths": "Overall Flow & Collaboration Highlights",
                        "improvements": "Next Growth Phase (Post-Confirmation)",
                        "remarks": "Department Head & HR Final Executive Assessment (90 Days)",
                        "outcome": "Probation & Employment Outcome"},
             "default_reviewer_title": "Head of Department & HR Director",
             "criteria": ["End-to-End Workflow Mastery & Delivery", "Cross-Functional Collaboration & Synergy",
                          "Ownership, Accountability & Initiative", "Company Values & Cultural Stewardship",
                          "Long-Term Impact & Growth Trajectory"]},
    },
}


def _seed_template(company, day, t, actor="system"):
    obj, created = ReviewTemplate.objects.get_or_create(
        company=company, milestone_day=day,
        defaults=dict(title=t["title"], tab_label=t["tab_label"], subtitle=t["subtitle"],
                      section_title=t["section_title"], table_headers=t["table_headers"], labels=t["labels"],
                      default_reviewer_title=t["default_reviewer_title"], created_by=actor, updated_by=actor))
    if created:
        ReviewTemplateCriterion.objects.bulk_create([
            ReviewTemplateCriterion(template=obj, position=i, name=n, created_by=actor, updated_by=actor)
            for i, n in enumerate(t["criteria"], 1)])
    return obj, created


def seed_defaults(company, actor="system"):
    """Create any missing default rows (never overwrites edits). Used for first access and 'reset defaults'."""
    for day, t in DEFAULTS["milestones"].items():
        obj, created = _seed_template(company, day, t, actor)
        if not created and not obj.is_active:
            obj.is_active = True
            obj.save(update_fields=["is_active", "updated_at"])
    for i, (code, label, done, days, system) in enumerate(DEFAULTS["statuses"], 1):
        ReviewOption.objects.get_or_create(company=company, kind="STATUS", code=code, defaults=dict(
            label=label, counts_as_completed=done, milestone_days=days, position=i, is_system=system,
            created_by=actor, updated_by=actor))
    for i, (code, label, days) in enumerate(DEFAULTS["outcomes"], 1):
        ReviewOption.objects.get_or_create(company=company, kind="OUTCOME", code=code, defaults=dict(
            label=label, milestone_days=days, position=i, created_by=actor, updated_by=actor))
    ReviewOption.objects.filter(company=company, kind="STATUS", code__in=("PENDING", "IN_PROGRESS")) \
        .update(is_active=True, is_system=True, counts_as_completed=False)


def ensure_defaults(company):
    """Lazy, idempotent first-time seed. After this the DB rows are the source of truth."""
    try:
        s, _ = ReviewSettings.objects.get_or_create(company=company, defaults=DEFAULTS["settings"])
    except IntegrityError:                       # two requests seeding at once
        s = ReviewSettings.objects.get(company=company)
    if s.seeded:
        return s
    with transaction.atomic():
        s = ReviewSettings.objects.select_for_update().get(pk=s.pk)
        if not s.seeded:
            seed_defaults(company)
            s.seeded = True
            s.save(update_fields=["seeded", "updated_at"])
    return s


# ---------------------------------------------------------------- company configuration
def _norm(v):
    return str(v).strip().lower().replace("-", "_").replace(" ", "_")


class Config:
    """The company's live review configuration (loaded fresh for each request)."""

    def __init__(self, company):
        self.company = company
        ensure_defaults(company)
        self.settings = ReviewSettings.objects.get(company=company)       # fresh row => proper Decimal values
        self.smin, self.smax = q1(self.settings.score_min), q1(self.settings.score_max)
        self.templates = OrderedDict()
        for t in (ReviewTemplate.objects.filter(company=company, is_active=True)
                  .prefetch_related("criteria").order_by("milestone_day")):
            self.templates[t.milestone_day] = self._tpl_dict(t)
        self.days = tuple(self.templates)
        opts = list(ReviewOption.objects.filter(company=company).order_by("position", "id"))
        self.all_options = {(o.kind, o.code): o for o in opts}
        self.statuses = OrderedDict((o.code, o) for o in opts if o.kind == "STATUS" and o.is_active)
        self.outcomes = OrderedDict((o.code, o) for o in opts if o.kind == "OUTCOME" and o.is_active)
        self.outcome_days = {d for d in self.days if any(self.applies(o, d) for o in self.outcomes.values())}

    @staticmethod
    def _tpl_dict(t):
        return {"id": t.id, "day": t.milestone_day, "key": f"day_{t.milestone_day}", "title": t.title,
                "tab_label": t.tab_label or t.title, "subtitle": t.subtitle, "section_title": t.section_title,
                "table_headers": {**FALLBACK_HEADERS, **(t.table_headers or {})},
                "labels": {**FALLBACK_LABELS, **(t.labels or {})},
                "default_reviewer_title": t.default_reviewer_title,
                "criteria": [c.name for c in t.criteria.all() if c.is_active]}

    @staticmethod
    def applies(opt, day):
        return not opt.milestone_days or day in opt.milestone_days

    def tpl(self, day):
        return self.templates[day]

    def status_label(self, code):
        o = self.all_options.get(("STATUS", code))
        return o.label if o else code

    def outcome_label(self, code):
        o = self.all_options.get(("OUTCOME", code))
        return o.label if o else (code or "")

    def is_done(self, code):
        o = self.all_options.get(("STATUS", code))
        return bool(o and o.counts_as_completed)

    def default_done_status(self, day):
        for o in self.statuses.values():
            if o.counts_as_completed and self.applies(o, day):
                return o.code
        return None

    def score_options(self):
        step = Decimal(str(self.settings.score_step)) or Decimal("0.5")
        out, x = [], self.smin
        while x <= self.smax and len(out) < 200:
            out.append(float(x))
            x += step
        return out


# ---------------------------------------------------------------- parsing / validation
def q1(value):
    return Decimal(str(value)).quantize(Decimal("0.1"), rounding=ROUND_HALF_UP)


def parse_score(cfg, value, label="Score"):
    """None/'' -> None, else a Decimal inside the company's score scale (one decimal)."""
    if value in (None, ""):
        return None
    try:
        d = q1(value)
    except Exception:
        raise ValueError(f"{label} must be a number between {cfg.smin} and {cfg.smax}.")
    if d < cfg.smin or d > cfg.smax:
        raise ValueError(f"{label} must be between {cfg.smin} and {cfg.smax}.")
    return d


def parse_lines(value, label):
    if value is None:
        return None
    if isinstance(value, str):
        items = value.splitlines()
    elif isinstance(value, (list, tuple)):
        items = [str(x) for x in value if x is not None]
    else:
        raise ValueError(f"{label} must be a list or text with one item per line.")
    items = [x.strip() for x in items if x and x.strip()]
    if len(items) > MAX_LINES:
        raise ValueError(f"{label}: at most {MAX_LINES} items.")
    if any(len(x) > MAX_LINE_LEN for x in items):
        raise ValueError(f"{label}: each item can be at most {MAX_LINE_LEN} characters.")
    return items


def parse_criteria(cfg, value):
    if value is None:
        return None
    if not isinstance(value, (list, tuple)):
        raise ValueError("criteria must be a list of {name, score, note}.")
    if len(value) > MAX_CRITERIA:
        raise ValueError(f"At most {MAX_CRITERIA} criteria.")
    out, seen = [], set()
    for i, row in enumerate(value, 1):
        if not isinstance(row, dict):
            raise ValueError(f"criteria[{i}] must be an object.")
        name = str(row.get("name") or row.get("criterion") or "").strip()
        if not name:
            raise ValueError(f"criteria[{i}].name is required.")
        if len(name) > 200:
            raise ValueError(f"criteria[{i}].name is too long (max 200).")
        if name.lower() in seen:
            raise ValueError(f"Duplicate criterion '{name}'.")
        seen.add(name.lower())
        note = str(row.get("note") if row.get("note") is not None else row.get("notes") or "").strip()
        out.append({"name": name, "score": parse_score(cfg, row.get("score"), f"criteria[{i}].score"), "note": note})
    return out


def norm_status(cfg, value, day):
    """Accept an option code or label; it must be active and allowed for this milestone."""
    if value in (None, ""):
        return None
    v = _norm(value)
    for o in cfg.statuses.values():
        if v in (_norm(o.code), _norm(o.label)):
            if not cfg.applies(o, day):
                raise ValueError(f"Status '{o.label}' is not available for the {day}-day milestone.")
            return o.code
    raise ValueError("Invalid status. Use one of: " + ", ".join(o.label for o in cfg.statuses.values()) + ".")


def norm_outcome(cfg, value, day):
    if value in (None, ""):
        return ""
    v = _norm(value)
    for o in cfg.outcomes.values():
        if v in (_norm(o.code), _norm(o.label)):
            if not cfg.applies(o, day):
                raise ValueError(f"Outcome '{o.label}' is not available for the {day}-day milestone.")
            return o.code
    raise ValueError("Invalid outcome. Use one of: " + ", ".join(o.label for o in cfg.outcomes.values()) + ".")


def average(scores):
    scores = [Decimal(str(s)) for s in scores if s is not None]
    return q1(sum(scores) / len(scores)) if scores else None


# ---------------------------------------------------------------- dates / state
def target_for(emp, day):
    doj = getattr(emp, "Date_of_Joining", None)
    return doj + timedelta(days=day) if doj else None


def due_state(cfg, target, assessed, today=None):
    if assessed:
        return "completed"
    if target is None:
        return "upcoming"
    left = (target - (today or timezone.localdate())).days
    return "overdue" if left < 0 else "due_soon" if left <= cfg.settings.due_soon_days else "upcoming"


def rating_label(cfg, score):
    """Band by % of the company's own scale (>=90% / 70% / 50%)."""
    if score is None:
        return "Not Assessed"
    pct = float(score) / float(cfg.smax) * 100
    return ("Exceeds Expectations" if pct >= 90 else "Meets Expectations" if pct >= 70
            else "Needs Improvement" if pct >= 50 else "Below Expectations")


# ---------------------------------------------------------------- row builders
def _f(v):
    return float(v) if v is not None else None


def _iso(v):
    return v.isoformat() if v else None


def milestone_row(cfg, emp, day, saved=None, today=None, include_criteria=True):
    t = cfg.tpl(day)
    today = today or timezone.localdate()
    status = saved.status if saved else "PENDING"
    assessed = bool(saved and cfg.is_done(status))
    target = saved.target_date if saved and saved.target_date else target_for(emp, day)
    criteria = []
    if saved is not None:
        criteria = [{"id": c.id, "position": c.position, "name": c.name, "score": _f(c.score), "note": c.note}
                    for c in saved.criteria.all()]
    if not criteria:
        criteria = [{"id": None, "position": i, "name": n, "score": None, "note": ""}
                    for i, n in enumerate(t["criteria"], 1)]
    has_outcome = day in cfg.outcome_days
    row = {
        "id": saved.id if saved else None, "milestone_day": day, "key": t["key"], "tab_label": t["tab_label"],
        "heading": f"{day} Days - {t['title']}", "title": t["title"], "subtitle": t["subtitle"],
        "section_title": t["section_title"], "table_headers": t["table_headers"], "labels": t["labels"],
        "status": status, "status_label": cfg.status_label(status), "is_assessed": assessed,
        "due_state": due_state(cfg, target, assessed, today), "days_left": (target - today).days if target else None,
        "rating": _f(saved.score) if saved else None,
        "rating_label": rating_label(cfg, saved.score if saved else None),
        "target_date": _iso(target), "completed_date": _iso(saved.completed_date) if saved else None,
        "reviewer_name": saved.reviewer_name if saved else "",
        "reviewer_title": (saved.reviewer_title if saved and saved.reviewer_title else t["default_reviewer_title"]),
        "strengths": list(saved.strengths) if saved else [], "improvements": list(saved.improvements) if saved else [],
        "remarks": saved.remarks if saved else "", "has_outcome": has_outcome,
        "assess_button": f"Assess Day {day}" + (" & Confirm" if has_outcome else ""),
        "updated_at": _iso(saved.updated_at) if saved else None, "updated_by": saved.updated_by if saved else None,
    }
    if include_criteria:
        row["criteria"] = criteria
    if has_outcome:
        oc = saved.outcome if saved else ""
        row["outcome"], row["outcome_label"] = oc, cfg.outcome_label(oc)
    return row


def summary_for(cfg, rows):
    rated = [r["rating"] for r in rows if r["is_assessed"] and r["rating"] is not None]
    avg = average(rated)
    done = sum(1 for r in rows if r["is_assessed"])
    nxt = next((r for r in rows if not r["is_assessed"]), None)
    final = next((r for r in reversed(rows) if r.get("has_outcome")), None) or {}
    total = len(rows) or 1
    return {
        "overall_rating": _f(avg),
        "overall_percent": int(round(float(avg) / float(cfg.smax) * 100)) if avg is not None else None,
        "overall_label": rating_label(cfg, avg), "score_max": float(cfg.smax),
        "milestones_completed": done, "milestones_total": len(rows),
        "progress_percent": int(round(done / total * 100)),
        "next_milestone": ({"milestone_day": nxt["milestone_day"], "target_date": nxt["target_date"],
                            "due_state": nxt["due_state"], "days_left": nxt["days_left"]} if nxt else None),
        "probation_outcome": final.get("outcome", ""), "probation_outcome_label": final.get("outcome_label", ""),
        "timeline": [{"milestone_day": r["milestone_day"], "tab_label": r["tab_label"], "rating": r["rating"],
                      "status": r["status"], "status_label": r["status_label"], "due_state": r["due_state"],
                      "target_date": r["target_date"]} for r in rows],
    }


def tabs(cfg):
    n = len(cfg.days)
    return ([{"value": "all", "label": f"All {n} Milestones ({'-'.join(str(d) for d in cfg.days)})"}]
            + [{"value": str(d), "day": d, "label": cfg.tpl(d)["tab_label"]} for d in cfg.days])


def option_dict(o):
    return {"id": o.id, "value": o.code, "label": o.label, "counts_as_completed": o.counts_as_completed,
            "milestone_days": list(o.milestone_days or []), "position": o.position, "is_system": o.is_system,
            "is_active": o.is_active}


def meta_payload(cfg):
    s = cfg.settings
    return {
        "tabs": tabs(cfg), "days": list(cfg.days), "score_options": cfg.score_options(),
        "score_min": float(cfg.smin), "score_max": float(cfg.smax),
        "settings": {"due_soon_days": s.due_soon_days, "window_days": s.window_days,
                     "score_min": float(cfg.smin), "score_max": float(cfg.smax), "score_step": float(s.score_step)},
        "statuses": [option_dict(o) for o in cfg.statuses.values()],
        "outcomes": [option_dict(o) for o in cfg.outcomes.values()],
        "milestones": {str(d): cfg.tpl(d) for d in cfg.days},
        "milestone_list": [cfg.tpl(d) for d in cfg.days],
        "limits": {"max_milestones": MAX_MILESTONES, "max_criteria": MAX_CRITERIA, "max_lines": MAX_LINES,
                   "max_line_length": MAX_LINE_LEN, "max_day": MAX_DAY},
    }


def build_review(cfg, emp, saved_qs=None, today=None, include_criteria=True):
    today = today or timezone.localdate()
    if saved_qs is None:
        saved_qs = ReviewMilestone.objects.filter(employee=emp, is_active=True).prefetch_related("criteria")
    saved = {m.milestone_day: m for m in saved_qs}
    rows = [milestone_row(cfg, emp, d, saved.get(d), today, include_criteria) for d in cfg.days]
    return rows, summary_for(cfg, rows)
