# ============================================================
# Timesheets + Timesheet Approval (Admin / HR)     /api/timesheet/entries/  /api/timesheet/approvals/
# ============================================================
import csv

from django.db import transaction
from django.http import HttpResponse
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.views import APIView

from .common import (OvertimeClaim, TimesheetAuthMixin, TimesheetCrud, TimesheetEntry, apply_entry, cycle_label, emp_by_code, entry_row,
                     err, find_project, get_setting, ok, recalc_day_overtime, resolve_approver, to_date, to_int, week_bounds)


def payroll_locked(co, employee, day):
    """Overtime of that month already passed to payroll -> approved hours may no longer change."""
    return OvertimeClaim.objects.filter(company=co, employee=employee, month=day.month, year=day.year,
                                        is_active=True, status="Passed to Payroll").exists()


def submit_entry(e):
    e.status, e.submitted_at = "Submitted", timezone.now()
    e.approver_code = resolve_approver(e.company, e.employee)
    e.decided_by = e.decided_at = e.decision_remarks = None


def decide_entry(e, approve, actor, remarks=None):
    e.status = "Approved" if approve else "Rejected"
    e.decided_by, e.decided_at, e.decision_remarks, e.updated_by = actor, timezone.now(), remarks, actor
    e.save()
    recalc_day_overtime(e.company, e.employee, e.work_date)


def filter_entries(qs, p):
    if p.get("project"):
        qs = qs.filter(project_id=int(p["project"])) if str(p["project"]).isdigit() else qs.filter(project__code__iexact=p["project"])
    if p.get("date_from"):
        qs = qs.filter(work_date__gte=to_date(p["date_from"]))
    if p.get("date_to"):
        qs = qs.filter(work_date__lte=to_date(p["date_to"]))
    if p.get("week"):                                   # any date inside the week
        qs = qs.filter(week_start=week_bounds(to_date(p["week"]))[0])
    if p.get("month") and p.get("year"):
        qs = qs.filter(work_date__month=int(p["month"]), work_date__year=int(p["year"]))
    if p.get("billable") not in (None, ""):
        qs = qs.filter(is_billable=str(p["billable"]).lower() in ("1", "true", "yes"))
    if p.get("department"):
        qs = qs.filter(employee__department_id=int(p["department"])) if str(p["department"]).isdigit() else qs.filter(employee__Department__iexact=p["department"])
    if p.get("approver"):
        qs = qs.filter(approver_code=p["approver"])
    return qs


class EntryViewSet(TimesheetCrud):
    """
    CRUD   /api/timesheet/entries/     ?status= ?project=<id|code> ?employee=<code> ?date_from= ?date_to= ?week= ?month=&year= ?billable= ?department= ?search=
    POST   /api/timesheet/entries/     {employee_code, project, work_date, task_summary, hours, overtime_hours?, is_billable?, status?: Draft|Submitted|Approved}
    POST   /api/timesheet/entries/<id>/submit|approve|reject|reopen/        {remarks?}   (reject needs remarks)
    POST   /api/timesheet/entries/bulk-approve/     {ids:[..], remarks?}      POST /bulk-reject/ {ids, remarks}
    GET    /api/timesheet/entries/export/           -> CSV (same filters)   [Export CSV button]
    """
    model = TimesheetEntry
    code = "TIMESHEET"
    select = ("project", "employee", "employee__department")
    search_fields = ("task_summary", "employee__name", "employee__employee_code", "project__title", "project__code")
    permission_action_map = {"submit": "edit", "approve": "approve", "reject": "approve", "reopen": "approve",
                             "bulk_approve": "approve", "bulk_reject": "approve", "export": "view"}

    def build(self, e):
        return entry_row(e, self.request)

    def filter(self, qs, p):
        try:
            return filter_entries(super().filter(qs, p), p)
        except ValueError as ex:
            raise ValueError(str(ex))

    def list(self, request):
        try:
            return super().list(request)
        except ValueError as ex:
            return err("VALIDATION", str(ex))

    def apply(self, e, d, creating):
        co, st = self.company(), get_setting(self.company())
        e._old_date = e.work_date if not creating else None
        if creating:
            e.employee = emp_by_code(co, d.get("employee_code"))
        elif e.status == "Approved" and payroll_locked(co, e.employee, e.work_date):
            raise ValueError("Overtime for this month is already passed to payroll; this entry is locked.")
        apply_entry(co, e, d, creating, st, self_service=False)
        if creating:
            want = d.get("status") or "Submitted"
            if want not in ("Draft", "Submitted", "Approved"):
                raise ValueError("status must be Draft, Submitted or Approved.")
            if want == "Draft":
                e.status = "Draft"
            else:
                submit_entry(e)
                if want == "Approved":
                    e.status, e.decided_by, e.decided_at = "Approved", self.actor(), timezone.now()
        elif "project" in d or "work_date" in d or "hours" in d:
            pass

    def after_save(self, e, creating):
        recalc_day_overtime(e.company, e.employee, e.work_date, force={e.pk})
        old = getattr(e, "_old_date", None)
        if old and old != e.work_date:
            recalc_day_overtime(e.company, e.employee, old)
        e.refresh_from_db()

    def destroy(self, request, pk=None):
        e = self.scope().filter(pk=pk, is_active=True).first()
        if e and e.status == "Approved" and payroll_locked(e.company, e.employee, e.work_date):
            return err("LOCKED", "Overtime for this month is already passed to payroll; this entry is locked.", 409)
        resp = super().destroy(request, pk)
        if e:
            recalc_day_overtime(e.company, e.employee, e.work_date)
        return resp

    # ---- workflow ----
    def _get(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    @action(detail=True, methods=["post"], url_path="submit")
    def submit(self, request, pk=None):
        e = self._get(pk)
        if e is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if e.status not in ("Draft", "Rejected"):
            return err("INVALID_STATE", f"Only Draft/Rejected entries can be submitted (this one is {e.status}).", 409)
        submit_entry(e)
        e.updated_by = self.actor()
        e.save()
        return ok("TIMESHEET_SUBMITTED", "Timesheet submitted for approval.", entry_row(e, request))

    def _decide(self, request, pk, approve):
        e = self._get(pk)
        if e is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if e.status != "Submitted":
            return err("INVALID_STATE", f"Only Submitted entries can be {'approved' if approve else 'rejected'} (this one is {e.status}).", 409)
        remarks = request.data.get("remarks")
        if not approve and not (remarks or "").strip():
            return err("VALIDATION", "remarks are required when rejecting.")
        decide_entry(e, approve, self.actor(), remarks)
        e.refresh_from_db()
        return ok("TIMESHEET_APPROVED" if approve else "TIMESHEET_REJECTED", "Timesheet approved." if approve else "Timesheet rejected.", entry_row(e, 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="reopen")
    def reopen(self, request, pk=None):
        e = self._get(pk)
        if e is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if e.status not in ("Approved", "Rejected"):
            return err("INVALID_STATE", f"Only Approved/Rejected entries can be reopened (this one is {e.status}).", 409)
        if e.status == "Approved" and payroll_locked(e.company, e.employee, e.work_date):
            return err("LOCKED", "Overtime for this month is already passed to payroll; this entry is locked.", 409)
        submit_entry(e)
        e.updated_by = self.actor()
        e.save()
        recalc_day_overtime(e.company, e.employee, e.work_date)
        e.refresh_from_db()
        return ok("TIMESHEET_REOPENED", "Timesheet moved back to Submitted.", entry_row(e, request))

    def _bulk(self, request, approve):
        ids = request.data.get("ids")
        if not isinstance(ids, list) or not ids:
            return err("VALIDATION", "ids (non-empty list) is required.")
        remarks = request.data.get("remarks")
        if not approve and not (remarks or "").strip():
            return err("VALIDATION", "remarks are required when rejecting.")
        done, skipped = [], []
        with transaction.atomic():
            for e in self.scope().filter(pk__in=ids, is_active=True):
                if e.status != "Submitted":
                    skipped.append({"id": e.id, "reason": f"already {e.status}"})
                    continue
                decide_entry(e, approve, self.actor(), remarks)
                done.append(e.id)
        missing = sorted(set(int(i) for i in ids if str(i).isdigit()) - set(done) - {s["id"] for s in skipped})
        skipped += [{"id": i, "reason": "not found"} for i in missing]
        return ok("BULK_APPROVED" if approve else "BULK_REJECTED", f"{len(done)} timesheet(s) {'approved' if approve else 'rejected'}.", {"processed": done, "skipped": skipped})

    @action(detail=False, methods=["post"], url_path="bulk-approve")
    def bulk_approve(self, request):
        return self._bulk(request, True)

    @action(detail=False, methods=["post"], url_path="bulk-reject")
    def bulk_reject(self, request):
        return self._bulk(request, False)

    @action(detail=False, methods=["get"], url_path="export")
    def export(self, request):
        try:
            qs = self.filter(self.scope().filter(is_active=True), request.query_params).order_by("work_date", "id")
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        resp = HttpResponse(content_type="text/csv")
        resp["Content-Disposition"] = 'attachment; filename="timesheets.csv"'
        w = csv.writer(resp)
        w.writerow(["Date", "Employee Code", "Employee", "Project Code", "Project", "Task Summary", "Hours", "Overtime", "Billable", "Status"])
        for e in qs:
            w.writerow([e.work_date.isoformat(), e.employee.employee_code, e.employee.name, e.project.code, e.project.title,
                        e.task_summary, e.hours, e.overtime_hours, "Yes" if e.is_billable else "No", e.status])
        return resp


# ---------------------------------------------------------------
# Timesheet Approval tab  ("Manager Timesheet Approval Queue")
# ---------------------------------------------------------------
def queue_qs(co, p):
    qs = TimesheetEntry.objects.filter(company=co, is_active=True, status="Submitted").select_related("project", "employee", "employee__department")
    if p.get("employee"):
        qs = qs.filter(employee__employee_code=p["employee"])
    return filter_entries(qs, p)


def queue_payload(request, qs, st, week=None):
    start, end = week_bounds(week or timezone.localdate(), st.week_start_day)
    rows = [entry_row(e, request) for e in qs]
    label = cycle_label(start, end)
    return {"cycle": {"start": start.isoformat(), "end": end.isoformat(), "label": label},
            "pending_count": len(rows), "rows": rows,
            "message": (f"{len(rows)} submitted timesheet(s) awaiting approval." if rows else
                        f"All submitted timesheets for the current weekly cycle ({label}) have been verified and processed into monthly billing.")}


class ApprovalQueueView(TimesheetAuthMixin, APIView):
    """GET /api/timesheet/approvals/   ?week=YYYY-MM-DD ?employee=<code> ?project= ?department= ?date_from= ?date_to="""
    permission_action = "view"

    def get(self, request):
        co, st = self.company(), get_setting(self.company())
        try:
            qs = queue_qs(co, request.query_params).order_by("work_date", "id")
            wk = to_date(request.query_params.get("week"))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        return ok("TIMESHEET_APPROVAL_QUEUE", "Manager timesheet approval queue.", queue_payload(request, qs, st, wk))


class ApproveAllPendingView(TimesheetAuthMixin, APIView):
    """POST /api/timesheet/approvals/approve-all-pending/   {week?, employee_code?, project?, remarks?}   [Approve All Pending button]"""
    permission_action = "approve"

    def post(self, request):
        co, d = self.company(), request.data
        try:
            params = {"week": d.get("week"), "employee": d.get("employee_code"), "project": d.get("project"),
                      "department": d.get("department"), "date_from": d.get("date_from"), "date_to": d.get("date_to")}
            qs = queue_qs(co, {k: v for k, v in params.items() if v})
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        ids = []
        with transaction.atomic():
            for e in qs:
                decide_entry(e, True, self.actor(), d.get("remarks"))
                ids.append(e.id)
        return ok("APPROVE_ALL_PENDING", f"{len(ids)} timesheet(s) approved." if ids else "No pending timesheets to approve.", {"approved": len(ids), "ids": ids})


class _Decide(TimesheetAuthMixin, APIView):
    permission_action = "approve"
    approve = True

    def post(self, request, pk):
        e = TimesheetEntry.objects.filter(company=self.company(), pk=pk, is_active=True).select_related("project", "employee").first()
        if e is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if e.status != "Submitted":
            return err("INVALID_STATE", f"Only Submitted entries can be decided (this one is {e.status}).", 409)
        remarks = request.data.get("remarks")
        if not self.approve and not (remarks or "").strip():
            return err("VALIDATION", "remarks are required when rejecting.")
        decide_entry(e, self.approve, self.actor(), remarks)
        e.refresh_from_db()
        return ok("TIMESHEET_APPROVED" if self.approve else "TIMESHEET_REJECTED", "Timesheet approved." if self.approve else "Timesheet rejected.", entry_row(e, request))


class ApproveView(_Decide):
    """POST /api/timesheet/approvals/<id>/approve/   {remarks?}"""
    approve = True


class RejectView(_Decide):
    """POST /api/timesheet/approvals/<id>/reject/    {remarks}"""
    approve = False
