# ============================================================
# Overtime Claims tab ("Pre-Approved Overtime Payout Register")     /api/timesheet/overtime-claims/
# ============================================================
from decimal import Decimal

from django.db import transaction
from django.db.models import Sum
from django.utils import timezone
from rest_framework.decorators import action

from .common import (OvertimeClaim, TimesheetCrud, approved_ot_hours, calc_pay, claim_rate, claim_row, emp_by_code, employees_qs, err,
                     get_setting, inr, ok, parse_month_year, resolve_approver, to_decimal, to_bool, TimesheetEntry, money)


def open_claim(co, emp, month, year, exclude_pk=None):
    qs = OvertimeClaim.objects.filter(company=co, employee=emp, month=month, year=year, is_active=True).exclude(status__in=["Rejected", "Cancelled"])
    return qs.exclude(pk=exclude_pk).first() if exclude_pk else qs.first()


def reprice(c):
    c.calculated_pay = calc_pay(c.approved_hours, c.hourly_rate, c.multiplier)


class ClaimViewSet(TimesheetCrud):
    """
    CRUD   /api/timesheet/overtime-claims/    ?status= ?month= ?year= ?employee=<code> ?search=
    POST   /api/timesheet/overtime-claims/    {employee_code, month, year, approved_hours?, hourly_rate?, multiplier?, approving_manager_code?, status?: Pending|Approved, remarks?}
    POST   /api/timesheet/overtime-claims/generate/         {month, year, employee_codes?, auto_approve?}   build claims from approved timesheets
    POST   /api/timesheet/overtime-claims/<id>/approve|reject|refresh|pass-to-payroll/
    POST   /api/timesheet/overtime-claims/pass-to-payroll/  {ids:[..]} or {month, year}
    GET    /api/timesheet/overtime-claims/payroll-feed/     ?month=&year=       approved claims ready for payroll
    GET    /api/timesheet/overtime-claims/summary/          ?month=&year=
    """
    model = OvertimeClaim
    code = "OT_CLAIM"
    select = ("employee", "employee__department")
    search_fields = ("employee__name", "employee__employee_code")
    permission_action_map = {"approve": "approve", "reject": "approve", "refresh": "edit", "pass_to_payroll": "approve",
                             "bulk_pass_to_payroll": "approve", "generate": "create", "payroll_feed": "view", "summary": "view"}

    def build(self, c):
        return claim_row(c, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("month"):
            qs = qs.filter(month=int(p["month"]))
        if p.get("year"):
            qs = qs.filter(year=int(p["year"]))
        return qs

    def list(self, request):
        try:
            return super().list(request)
        except ValueError as ex:
            return err("VALIDATION", str(ex))

    def apply(self, c, d, creating):
        co, st = self.company(), get_setting(self.company())
        if creating:
            c.employee = emp_by_code(co, d.get("employee_code"))
            c.month, c.year = parse_month_year(d, default_today=False)
            if open_claim(co, c.employee, c.month, c.year):
                raise ValueError("An active overtime claim already exists for this employee and month.")
            c.source = "Manual" if d.get("approved_hours") not in (None, "") else "Auto"
            c.approver_code = d.get("approving_manager_code") or resolve_approver(co, c.employee)
            c.hourly_rate, c.multiplier = claim_rate(c.employee), st.overtime_multiplier
            want = d.get("status") or "Pending"
            if want not in ("Pending", "Approved"):
                raise ValueError("status must be Pending or Approved when creating.")
            c.status = want
            if want == "Approved":
                c.decided_by, c.decided_at = self.actor(), timezone.now()
        else:
            if c.status in ("Passed to Payroll", "Cancelled"):
                raise ValueError(f"A claim that is {c.status} cannot be edited.")
            if "approving_manager_code" in d:
                c.approver_code = d["approving_manager_code"] or None
        if "approved_hours" in d and d["approved_hours"] not in (None, ""):
            h = to_decimal(d["approved_hours"])
            if h <= 0:
                raise ValueError("approved_hours must be greater than 0.")
            c.approved_hours = h
        elif creating:
            c.approved_hours = approved_ot_hours(co, c.employee, c.month, c.year)
            if c.approved_hours <= 0:
                raise ValueError("No approved overtime hours in approved timesheets for that month. Pass approved_hours to enter them manually.")
        if "hourly_rate" in d:
            r = to_decimal(d["hourly_rate"])
            if r is None or r < 0:
                raise ValueError("hourly_rate must be 0 or more.")
            c.hourly_rate = r
        if "multiplier" in d:
            m = to_decimal(d["multiplier"])
            if m is None or m <= 0:
                raise ValueError("multiplier must be greater than 0.")
            c.multiplier = m
        for k in ("remarks",):
            if k in d:
                setattr(c, k, d[k])
        reprice(c)

    def destroy(self, request, pk=None):
        c = self.scope().filter(pk=pk, is_active=True).first()
        if c and c.status == "Passed to Payroll":
            return err("LOCKED", "A claim already passed to payroll cannot be deleted.", 409)
        return super().destroy(request, pk)

    # ---- workflow ----
    def _get(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    def _decide(self, request, pk, approve):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Only Pending claims can be decided (this one is {c.status}).", 409)
        remarks = request.data.get("remarks")
        if not approve and not (remarks or "").strip():
            return err("VALIDATION", "remarks are required when rejecting.")
        c.status = "Approved" if approve else "Rejected"
        c.decided_by, c.decided_at, c.decision_remarks, c.updated_by = self.actor(), timezone.now(), remarks, self.actor()
        c.save()
        return ok("OT_CLAIM_APPROVED" if approve else "OT_CLAIM_REJECTED", "Claim approved." if approve else "Claim rejected.", claim_row(c, request))

    @action(detail=True, methods=["post"], url_path="approve")
    def approve(self, request, pk=None):
        return self._decide(request, pk, True)

    @action(detail=True, methods=["post"], url_path="reject")
    def reject(self, request, pk=None):
        return self._decide(request, pk, False)

    @action(detail=True, methods=["post"], url_path="refresh")
    def refresh(self, request, pk=None):
        """Re-pull approved overtime hours + current hourly rate for a Pending/Approved claim."""
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if c.status not in ("Pending", "Approved"):
            return err("INVALID_STATE", f"A claim that is {c.status} cannot be refreshed.", 409)
        h = approved_ot_hours(c.company, c.employee, c.month, c.year)
        if h <= 0:
            return err("VALIDATION", "No approved overtime hours in approved timesheets for that month.")
        c.approved_hours, c.hourly_rate, c.updated_by = h, claim_rate(c.employee), self.actor()
        reprice(c)
        c.save()
        return ok("OT_CLAIM_REFRESHED", "Claim recalculated from approved timesheets.", claim_row(c, request))

    def _pass(self, qs):
        n = 0
        for c in qs.filter(status="Approved"):
            c.status, c.passed_to_payroll_at, c.updated_by = "Passed to Payroll", timezone.now(), self.actor()
            c.save()
            n += 1
        return n

    @action(detail=True, methods=["post"], url_path="pass-to-payroll")
    def pass_to_payroll(self, request, pk=None):
        c = self._get(pk)
        if c is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if c.status != "Approved":
            return err("INVALID_STATE", f"Only Approved claims can be passed to payroll (this one is {c.status}).", 409)
        self._pass(self.scope().filter(pk=c.pk))
        c.refresh_from_db()
        return ok("OT_PASSED_TO_PAYROLL", "Claim passed to payroll.", claim_row(c, request))

    @action(detail=False, methods=["post"], url_path="pass-to-payroll")
    def bulk_pass_to_payroll(self, request):
        d = request.data
        qs = self.scope().filter(is_active=True)
        try:
            if d.get("ids"):
                qs = qs.filter(pk__in=d["ids"])
            else:
                m, y = parse_month_year(d, default_today=False)
                qs = qs.filter(month=m, year=y)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        with transaction.atomic():
            n = self._pass(qs)
        return ok("OT_PASSED_TO_PAYROLL", f"{n} claim(s) passed to payroll.", {"passed": n})

    @action(detail=False, methods=["post"], url_path="generate")
    def generate(self, request):
        co, d, st = self.company(), request.data, get_setting(self.company())
        try:
            month, year = parse_month_year(d)
            emps = employees_qs(co).filter(is_active=True)
            if d.get("employee_codes"):
                emps = emps.filter(employee_code__in=d["employee_codes"])
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        auto = to_bool(d.get("auto_approve"))
        made, skipped = [], []
        with transaction.atomic():
            for emp in emps:
                h = approved_ot_hours(co, emp, month, year)
                if h <= 0:
                    continue
                if open_claim(co, emp, month, year):
                    skipped.append({"employee_code": emp.employee_code, "reason": "claim already exists"})
                    continue
                c = OvertimeClaim(company=co, employee=emp, month=month, year=year, approved_hours=h, hourly_rate=claim_rate(emp),
                                  multiplier=st.overtime_multiplier, approver_code=resolve_approver(co, emp), source="Auto",
                                  created_by=self.actor(), updated_by=self.actor(), status="Approved" if auto else "Pending")
                if auto:
                    c.decided_by, c.decided_at = self.actor(), timezone.now()
                reprice(c)
                c.save()
                made.append(claim_row(c, request))
        return ok("OT_CLAIMS_GENERATED", f"{len(made)} claim(s) generated.", {"created": made, "skipped": skipped}, 201 if made else 200)

    @action(detail=False, methods=["get"], url_path="payroll-feed")
    def payroll_feed(self, request):
        try:
            month, year = parse_month_year(request.query_params)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        qs = self.scope().filter(is_active=True, month=month, year=year, status__in=["Approved", "Passed to Payroll"] if to_bool(request.query_params.get("include_passed")) else ["Approved"])
        rows = [{"employee_code": c.employee.employee_code, "employee_name": c.employee.name, "month": c.month, "year": c.year,
                 "overtime_hours": float(c.approved_hours), "hourly_rate": float(c.hourly_rate), "overtime_pay": float(c.calculated_pay),
                 "claim_id": c.id, "status": c.status} for c in qs]
        total = qs.aggregate(h=Sum("approved_hours"), p=Sum("calculated_pay"))
        return ok("OT_PAYROLL_FEED", "Overtime ready for payroll.", rows,
                  totals={"claims": len(rows), "overtime_hours": float(total["h"] or 0), "overtime_pay": float(total["p"] or 0), "overtime_pay_label": inr(total["p"] or 0)})

    @action(detail=False, methods=["get"], url_path="summary")
    def summary(self, request):
        try:
            month, year = parse_month_year(request.query_params)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        qs = self.scope().filter(is_active=True, month=month, year=year)
        by = {}
        for s, _ in OvertimeClaim.STATUS:
            a = qs.filter(status=s).aggregate(n=Sum("approved_hours"), p=Sum("calculated_pay"))
            by[s] = {"claims": qs.filter(status=s).count(), "hours": float(a["n"] or 0), "pay": float(a["p"] or 0)}
        return ok("OT_SUMMARY", "Overtime claims summary.", {"month": month, "year": year, "by_status": by})
