# ============================================================
# 3. ONBOARDING   /api/people/onboarding/
# ============================================================
from django.db import transaction
from django.db.models import Q
from django.utils import timezone
from rest_framework.decorators import action

from Employee.models import EmployeeDT

from .common import (CrudBase, emp_brief, emp_by_code, err, get_extra, iso, ok, to_bool, to_date, to_int,
                     employees_qs)
from .models import OnboardingRecord, OnboardingTask

DEFAULT_TASKS = [
    ("Offer & joining documents collected", "Documents"), ("Employee code & email created", "IT"),
    ("IT kit (laptop / access) dispatched", "IT"), ("HR induction completed", "HR"),
    ("Buddy introduction", "Culture"), ("Policy acknowledgement signed", "Compliance"),
    ("Payroll & bank details submitted", "Payroll"), ("30-day check-in review", "HR"),
]


def progress_of(rec):
    tasks = list(rec.tasks.filter(is_active=True))
    if not tasks:
        return rec.progress_override or 0
    return round(sum(1 for t in tasks if t.is_done) * 100 / len(tasks))


def start_onboarding(company, emp, buddy=None, actor=None, tasks=True, target_days=14):
    rec, created = OnboardingRecord.objects.get_or_create(
        employee=emp, defaults={"company": company, "buddy": buddy, "created_by": actor, "updated_by": actor,
                                "started_on": emp.Date_of_Joining or timezone.localdate(),
                                "target_days": target_days})
    if created and tasks:
        for i, (title, cat) in enumerate(DEFAULT_TASKS, 1):
            OnboardingTask.objects.create(record=rec, title=title, category=cat, sort_order=i,
                                          created_by=actor, updated_by=actor)
    return rec, created


def task_row(t):
    return {"id": t.id, "title": t.title, "category": t.category, "due_date": iso(t.due_date),
            "is_done": t.is_done, "done_at": iso(t.done_at), "done_by": t.done_by, "sort_order": t.sort_order}


class OnboardingViewSet(CrudBase):
    """
    GET  /api/people/onboarding/                 tracker + KPI cards
    POST /api/people/onboarding/                 start onboarding  {employee_code, buddy?, target_days?}
    GET  /api/people/onboarding/<id>/            detail with tasks   (Review button)
    POST /api/people/onboarding/<id>/update/     status / buddy / it_kit_dispatched / notes / target_days
    POST /api/people/onboarding/<id>/delete/
    POST /api/people/onboarding/<id>/tasks/                  add task
    POST /api/people/onboarding/<id>/tasks/<task_id>/toggle/ done / undone
    POST /api/people/onboarding/<id>/tasks/<task_id>/delete/
    POST /api/people/onboarding/<id>/complete/
    POST /api/people/onboarding/trigger-checkins/            "Trigger Check-ins"
    """
    model = OnboardingRecord
    code = "ONBOARDING"
    select = ("employee", "employee__department", "buddy")
    search_fields = ("employee__name", "employee__employee_code", "employee__Designation")

    def build(self, r):
        e = r.employee
        pct = progress_of(r)
        days = (timezone.localdate() - r.started_on).days
        return {"id": r.id, "employee": emp_brief(e), "joining_date": iso(e.Date_of_Joining),
                "started_on": iso(r.started_on), "target_days": r.target_days, "days_elapsed": days,
                "progress_percent": pct, "status": r.status, "it_kit_dispatched": r.it_kit_dispatched,
                "buddy": emp_brief(r.buddy), "last_checkin_at": iso(r.last_checkin_at),
                "completed_on": iso(r.completed_on), "notes": r.notes}

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("buddy"):
            qs = qs.filter(buddy__employee_code=p["buddy"])
        return qs

    def list(self, request):
        base = self.scope().filter(is_active=True)
        qs = self.filter(base, request.query_params)
        rows = [self.build(r) for r in qs]
        active = [r for r in rows if r["status"] != "Completed"]
        avg = round(sum(r["progress_percent"] for r in rows) / len(rows)) if rows else 0
        kits = [r for r in rows if r["it_kit_dispatched"]]
        with_buddy = [r for r in rows if r["buddy"]]
        summary = {
            "active_onboardings": len(active),
            "on_schedule": all(r["status"] == "On Track" for r in active) if active else True,
            "avg_task_completion": avg, "target_completion": 90, "target_days": 14,
            "it_kits_dispatched_percent": round(len(kits) * 100 / len(rows)) if rows else 0,
            "buddy_assigned": f"{len(with_buddy)}/{len(rows)}",
        }
        return ok("ONBOARDING_LIST", "Onboarding tracker.", {"summary": summary, "rows": rows})

    @transaction.atomic
    def create(self, request):
        d, company = request.data, self.company()
        try:
            emp = emp_by_code(company, d.get("employee_code"))
            old = OnboardingRecord.objects.filter(employee=emp).first()
            if old is not None and old.is_active:
                return err("EXISTS", "Onboarding is already started for this employee.", 409)
            buddy = emp_by_code(company, d.get("buddy"), required=False)
            if old is not None:                      # previously deleted -> restart cleanly
                old.tasks.all().delete()
                old.delete()
            rec, _ = start_onboarding(company, emp, buddy, self.actor(), to_bool(d.get("with_default_tasks"), True),
                                      to_int(d.get("target_days"), 14))
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("ONBOARDING_CREATED", "Onboarding started.", self.build(rec), 201)

    def retrieve(self, request, pk=None):
        r = self.scope().filter(pk=pk).first()
        if r is None:
            return err("NOT_FOUND", "Onboarding record not found.", 404)
        data = self.build(r)
        data["tasks"] = [task_row(t) for t in r.tasks.filter(is_active=True)]
        return ok("ONBOARDING_DETAIL", "Onboarding detail.", data)

    def apply(self, r, d, creating):
        company = self.company()
        if "status" in d:
            if d["status"] not in dict(OnboardingRecord.STATUS):
                raise ValueError(f"Invalid status. Allowed: {', '.join(dict(OnboardingRecord.STATUS))}")
            r.status = d["status"]
        if "buddy" in d:
            r.buddy = emp_by_code(company, d.get("buddy"), required=False)
        if "it_kit_dispatched" in d:
            r.it_kit_dispatched = to_bool(d["it_kit_dispatched"])
        if "notes" in d:
            r.notes = d["notes"]
        if "target_days" in d:
            r.target_days = to_int(d["target_days"], 14)
        if "progress_override" in d:
            r.progress_override = to_int(d["progress_override"])

    def _rec(self, pk):
        return self.scope().filter(pk=pk).first()

    @action(detail=True, methods=["post"], url_path="tasks")
    def add_task(self, request, pk=None):
        r = self._rec(pk)
        if r is None:
            return err("NOT_FOUND", "Onboarding record not found.", 404)
        title = (request.data.get("title") or "").strip()
        if not title:
            return err("VALIDATION", "title is required.")
        try:
            due = to_date(request.data.get("due_date"))
        except ValueError as e:
            return err("VALIDATION", str(e))
        n = r.tasks.count() + 1
        t = OnboardingTask.objects.create(record=r, title=title, category=request.data.get("category"),
                                          due_date=due, sort_order=n, created_by=self.actor(),
                                          updated_by=self.actor())
        return ok("TASK_CREATED", "Task added.", {"task": task_row(t), "progress_percent": progress_of(r)}, 201)

    @action(detail=True, methods=["post"], url_path=r"tasks/(?P<task_id>\d+)/toggle")
    def toggle_task(self, request, pk=None, task_id=None):
        r = self._rec(pk)
        t = r.tasks.filter(pk=task_id, is_active=True).first() if r else None
        if t is None:
            return err("NOT_FOUND", "Task not found.", 404)
        done = to_bool(request.data.get("is_done"), not t.is_done)
        t.is_done, t.done_at = done, (timezone.now() if done else None)
        t.done_by, t.updated_by = (self.actor() if done else None), self.actor()
        t.save()
        return ok("TASK_UPDATED", "Task updated.", {"task": task_row(t), "progress_percent": progress_of(r)})

    @action(detail=True, methods=["post"], url_path=r"tasks/(?P<task_id>\d+)/delete")
    def delete_task(self, request, pk=None, task_id=None):
        r = self._rec(pk)
        t = r.tasks.filter(pk=task_id, is_active=True).first() if r else None
        if t is None:
            return err("NOT_FOUND", "Task not found.", 404)
        t.is_active, t.updated_by = False, self.actor()
        t.save()
        return ok("TASK_DELETED", "Task removed.", {"progress_percent": progress_of(r)})

    @action(detail=True, methods=["post"])
    def complete(self, request, pk=None):
        r = self._rec(pk)
        if r is None:
            return err("NOT_FOUND", "Onboarding record not found.", 404)
        r.tasks.filter(is_active=True, is_done=False).update(is_done=True, done_at=timezone.now(),
                                                              done_by=self.actor())
        r.status, r.completed_on, r.updated_by = "Completed", timezone.localdate(), self.actor()
        r.save()
        return ok("ONBOARDING_COMPLETED", "Onboarding completed.", self.build(r))

    @action(detail=False, methods=["post"], url_path="trigger-checkins")
    def trigger_checkins(self, request):
        """Marks a check-in on every active onboarding (and flags slow ones). Hook a mailer here if needed."""
        n, flagged = 0, 0
        for r in self.scope().filter(is_active=True).exclude(status="Completed"):
            r.last_checkin_at, r.updated_by = timezone.now(), self.actor()
            if (timezone.localdate() - r.started_on).days > r.target_days and progress_of(r) < 90:
                r.status, flagged = "Delayed", flagged + 1
            r.save()
            n += 1
        return ok("CHECKINS_TRIGGERED", f"Check-ins triggered for {n} onboarding(s).", {"count": n, "flagged": flagged})

