# ============================================================
# EMPLOYEE SIDE (self-service)   /employee/timesheet/
# Auth: Employee JWT. An employee sees / changes only their OWN data.
# Managers / HODs (Employee.ReportingHierarchy) additionally get an approval queue for their reports.
# ============================================================
import csv
from decimal import Decimal

from django.db.models import Q, Sum
from django.http import HttpResponse
from django.utils import timezone
from rest_framework.views import APIView

from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated
from Employee.employee_crud_permissions import actor_label
from People.common import err, ok, paginate, to_date, to_int

from .common import (OvertimeClaim, ProjectAllocation, TimesheetEntry, TimesheetProject, apply_entry, approved_ot_hours, calc_pay,
                     claim_rate, claim_row, cycle_label, entry_row, get_setting, inr, iso, parse_month_year, project_row,
                     recalc_day_overtime, resolve_approver, week_bounds, OPEN_PROJECT)
from .views_entries import decide_entry, filter_entries, payroll_locked, submit_entry
from .views_overtime import open_claim, reprice


class SelfBase(APIView):
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

    @property
    def me(self):
        return self.request.user

    @property
    def company(self):
        return self.request.user.company

    def actor(self):
        return actor_label(self.me)

    def mine(self):
        return TimesheetEntry.objects.filter(company=self.company, employee=self.me, is_active=True).select_related("project", "employee", "employee__department")

    def team_codes(self):
        from Employee.leave_models import ReportingHierarchy
        h = ReportingHierarchy.objects.filter(company=self.company, is_active=True).filter(Q(manager_code=self.me.employee_code) | Q(hod_code=self.me.employee_code))
        return set(h.values_list("Employee_ID", flat=True))


class MyDashboard(SelfBase):
    """GET /employee/timesheet/dashboard/"""

    def get(self, request):
        st, t = get_setting(self.company), timezone.localdate()
        ws, we = week_bounds(t, st.week_start_day)
        live = self.mine().filter(status__in=["Submitted", "Approved"])
        wk = live.filter(work_date__gte=ws, work_date__lte=we).aggregate(h=Sum("hours"), ot=Sum("overtime_hours"))
        mo = live.filter(work_date__month=t.month, work_date__year=t.year).aggregate(h=Sum("hours"), ot=Sum("overtime_hours"))
        claims = OvertimeClaim.objects.filter(company=self.company, employee=self.me, is_active=True)
        return ok("MY_TIMESHEET_DASHBOARD", "My timesheet dashboard.", {
            "week": {"start": iso(ws), "end": iso(we), "label": cycle_label(ws, we), "hours": float(wk["h"] or 0), "overtime_hours": float(wk["ot"] or 0)},
            "month": {"month": t.month, "year": t.year, "hours": float(mo["h"] or 0), "overtime_hours": float(mo["ot"] or 0)},
            "entries_by_status": {s: self.mine().filter(status=s).count() for s, _ in TimesheetEntry.STATUS},
            "needs_attention": self.mine().filter(status__in=["Draft", "Rejected"]).count(),
            "my_projects": self._allocs().count(),
            "overtime_claims_pending": claims.filter(status="Pending").count(),
            "overtime_approved_unpaid_label": inr(claims.filter(status="Approved").aggregate(p=Sum("calculated_pay"))["p"] or 0),
            "pending_my_approval": TimesheetEntry.objects.filter(company=self.company, is_active=True, status="Submitted", approver_code=self.me.employee_code).count(),
        })

    def _allocs(self):
        t = timezone.localdate()
        return ProjectAllocation.objects.filter(company=self.company, employee=self.me, is_active=True, start_date__lte=t).filter(Q(end_date__isnull=True) | Q(end_date__gte=t))


class MyProjects(SelfBase):
    """GET /employee/timesheet/projects/   projects I can log hours on (my active allocations)"""

    def get(self, request):
        st, t = get_setting(self.company), timezone.localdate()
        al = ProjectAllocation.objects.filter(company=self.company, employee=self.me, is_active=True, start_date__lte=t,
                                              project__is_active=True).filter(Q(end_date__isnull=True) | Q(end_date__gte=t)).select_related("project")
        rows = [{"project": {"id": a.project_id, "code": a.project.code, "title": a.project.title, "status": a.project.status,
                             "client_department": a.project.client_department, "is_billable": a.project.is_billable},
                 "role": a.role, "allocation_percent": a.allocation_percent, "start_date": iso(a.start_date), "end_date": iso(a.end_date),
                 "can_log_hours": a.project.status in OPEN_PROJECT} for a in al]
        if not st.enforce_allocation:
            seen = {r["project"]["id"] for r in rows}
            for p in TimesheetProject.objects.filter(company=self.company, is_active=True, status__in=OPEN_PROJECT).exclude(pk__in=seen):
                rows.append({"project": {"id": p.id, "code": p.code, "title": p.title, "status": p.status, "client_department": p.client_department,
                                         "is_billable": p.is_billable}, "role": None, "allocation_percent": None, "start_date": None, "end_date": None, "can_log_hours": True})
        return ok("MY_PROJECTS", "My projects.", rows)


class MyEntries(SelfBase):
    """
    GET  /employee/timesheet/entries/   ?status= ?project= ?date_from= ?date_to= ?week= ?month=&year=
    POST /employee/timesheet/entries/   {project, work_date, task_summary, hours, overtime_hours?, is_billable?, save_as_draft?:false}   [Log Work Hours]
    """

    def get(self, request):
        p = request.query_params
        try:
            qs = filter_entries(self.mine().filter(**({"status": p["status"]} if p.get("status") else {})), p)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        rows, meta = paginate(request, qs, lambda e: entry_row(e, request))
        return ok("MY_TIMESHEETS", "My timesheet entries.", rows, meta=meta)

    def post(self, request):
        st, d = get_setting(self.company), request.data
        e = TimesheetEntry(company=self.company, employee=self.me, created_by=self.actor(), updated_by=self.actor())
        try:
            apply_entry(self.company, e, d, True, st, self_service=True)
            if str(d.get("save_as_draft", "")).lower() in ("1", "true", "yes"):
                e.status = "Draft"
            else:
                submit_entry(e)
            e.save()
            recalc_day_overtime(self.company, self.me, e.work_date, st)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        e.refresh_from_db()
        return ok("MY_TIMESHEET_CREATED", "Work hours logged." if e.status == "Submitted" else "Saved as draft.", entry_row(e, request), 201)


class MyEntryDetail(SelfBase):
    """GET / PUT / PATCH / DELETE /employee/timesheet/entries/<id>/      (edit/delete only while Draft or Rejected)
       POST /employee/timesheet/entries/<id>/update/   {..fields.., submit?:true}     POST /employee/timesheet/entries/<id>/delete/"""
    EDITABLE = ("Draft", "Rejected")

    def _e(self, pk):
        return self.mine().filter(pk=pk).first()

    def get(self, request, pk):
        e = self._e(pk)
        return ok("MY_TIMESHEET", "Timesheet entry.", entry_row(e, request)) if e else err("NOT_FOUND", "Entry not found.", 404)

    def patch(self, request, pk):
        e = self._e(pk)
        if e is None:
            return err("NOT_FOUND", "Entry not found.", 404)
        if e.status not in self.EDITABLE:
            return err("INVALID_STATE", f"A {e.status} entry cannot be edited. Recall it first." if e.status == "Submitted" else f"A {e.status} entry is locked.", 409)
        d, old = request.data, e.work_date
        try:
            apply_entry(self.company, e, d, False, get_setting(self.company), self_service=True)
            if str(d.get("submit", "")).lower() in ("1", "true", "yes"):
                submit_entry(e)
            e.updated_by = self.actor()
            e.save()
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        recalc_day_overtime(self.company, self.me, e.work_date)
        if old != e.work_date:
            recalc_day_overtime(self.company, self.me, old)
        e.refresh_from_db()
        return ok("MY_TIMESHEET_UPDATED", "Entry updated.", entry_row(e, request))

    put = patch

    def delete(self, request, pk):
        e = self._e(pk)
        if e is None:
            return err("NOT_FOUND", "Entry not found.", 404)
        if e.status not in self.EDITABLE:
            return err("INVALID_STATE", f"A {e.status} entry cannot be deleted." + (" Recall it first." if e.status == "Submitted" else ""), 409)
        e.is_active, e.updated_by = False, self.actor()
        e.save()
        recalc_day_overtime(self.company, self.me, e.work_date)
        return ok("MY_TIMESHEET_DELETED", "Entry deleted.", {"id": int(pk)})


class MyEntryUpdatePost(MyEntryDetail):
    def post(self, request, pk):
        return self.patch(request, pk)


class MyEntryDeletePost(MyEntryDetail):
    def post(self, request, pk):
        return self.delete(request, pk)


class MySubmit(SelfBase):
    """POST /employee/timesheet/entries/<id>/submit/"""

    def post(self, request, pk):
        e = self.mine().filter(pk=pk).first()
        if e is None:
            return err("NOT_FOUND", "Entry 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("MY_TIMESHEET_SUBMITTED", "Submitted for approval." if e.approver_code else "Submitted to HR for approval.", entry_row(e, request))


class MyRecall(SelfBase):
    """POST /employee/timesheet/entries/<id>/recall/   Submitted (not yet decided) -> Draft"""

    def post(self, request, pk):
        e = self.mine().filter(pk=pk).first()
        if e is None:
            return err("NOT_FOUND", "Entry not found.", 404)
        if e.status != "Submitted":
            return err("INVALID_STATE", f"Only Submitted entries can be recalled (this one is {e.status}).", 409)
        e.status, e.submitted_at, e.approver_code, e.updated_by = "Draft", None, None, self.actor()
        e.save()
        return ok("MY_TIMESHEET_RECALLED", "Entry recalled to draft.", entry_row(e, request))


class MySubmitWeek(SelfBase):
    """POST /employee/timesheet/entries/submit-week/   {week?: any date in the week (default this week)}"""

    def post(self, request):
        try:
            wk = to_date(request.data.get("week")) or timezone.localdate()
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        start = week_bounds(wk, get_setting(self.company).week_start_day)[0]
        ids = []
        for e in self.mine().filter(week_start=start, status__in=["Draft", "Rejected"]):
            submit_entry(e)
            e.updated_by = self.actor()
            e.save()
            ids.append(e.id)
        return ok("MY_WEEK_SUBMITTED", f"{len(ids)} entr{'y' if len(ids) == 1 else 'ies'} submitted." if ids else "Nothing to submit for that week.", {"submitted": len(ids), "ids": ids, "week_start": iso(start)})


class MyExport(SelfBase):
    """GET /employee/timesheet/entries/export/   CSV of my entries (same filters as the list)"""

    def get(self, request):
        try:
            qs = filter_entries(self.mine(), 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="my_timesheets.csv"'
        w = csv.writer(resp)
        w.writerow(["Date", "Project Code", "Project", "Task Summary", "Hours", "Overtime", "Status"])
        for e in qs:
            w.writerow([e.work_date.isoformat(), e.project.code, e.project.title, e.task_summary, e.hours, e.overtime_hours, e.status])
        return resp


# ---------------- overtime claims ----------------
class MyOvertime(SelfBase):
    """
    GET  /employee/timesheet/overtime/     ?status= ?year=
    POST /employee/timesheet/overtime/     {month, year, remarks?}   hours/pay are computed from my APPROVED timesheets
    """

    def get(self, request):
        qs = OvertimeClaim.objects.filter(company=self.company, employee=self.me, is_active=True).select_related("employee", "employee__department")
        p = request.query_params
        if p.get("status"):
            qs = qs.filter(status=p["status"])
        if p.get("year"):
            qs = qs.filter(year=int(p["year"]))
        return ok("MY_OT_CLAIMS", "My overtime claims.", [claim_row(c, request) for c in qs])

    def post(self, request):
        st, co = get_setting(self.company), self.company
        try:
            month, year = parse_month_year(request.data, default_today=False)
            t = timezone.localdate()
            if (year, month) > (t.year, t.month):
                raise ValueError("You cannot claim overtime for a future month.")
            if open_claim(co, self.me, month, year):
                raise ValueError("You already have an active overtime claim for that month.")
            h = approved_ot_hours(co, self.me, month, year)
            if h <= 0:
                raise ValueError("You have no approved overtime hours in that month.")
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        c = OvertimeClaim(company=co, employee=self.me, month=month, year=year, approved_hours=h, hourly_rate=claim_rate(self.me),
                          multiplier=st.overtime_multiplier, approver_code=resolve_approver(co, self.me), status="Pending", source="Employee",
                          remarks=request.data.get("remarks"), created_by=self.actor(), updated_by=self.actor())
        reprice(c)
        c.save()
        return ok("MY_OT_CLAIM_CREATED", "Overtime claim sent for approval." if c.approver_code else "Overtime claim sent to HR for approval.", claim_row(c, request), 201)


class MyOvertimePreview(SelfBase):
    """GET /employee/timesheet/overtime/preview/?month=&year=    what a claim for that month would be"""

    def get(self, request):
        try:
            month, year = parse_month_year(request.query_params)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        h, rate, mult = approved_ot_hours(self.company, self.me, month, year), claim_rate(self.me), get_setting(self.company).overtime_multiplier
        pay = calc_pay(h, rate, mult)
        ex = open_claim(self.company, self.me, month, year)
        return ok("MY_OT_PREVIEW", "Overtime preview.", {"month": month, "year": year, "approved_ot_hours": float(h), "hourly_rate": float(rate),
                                                           "multiplier": float(mult), "estimated_pay": float(pay), "estimated_pay_label": inr(pay),
                                                           "existing_claim": claim_row(ex, request) if ex else None})


class MyOvertimeDetail(SelfBase):
    """GET /employee/timesheet/overtime/<id>/
       PATCH / PUT  {remarks}   (only while Pending - hours and pay always come from approved timesheets)
       DELETE = cancel while Pending.   POST .../update/  and  POST .../delete/ (or .../cancel/) for POST-only clients"""

    def _c(self, pk):
        return OvertimeClaim.objects.filter(company=self.company, employee=self.me, pk=pk, is_active=True).select_related("employee", "employee__department").first()

    def get(self, request, pk):
        c = self._c(pk)
        return ok("MY_OT_CLAIM", "Overtime claim.", claim_row(c, request)) if c else err("NOT_FOUND", "Claim not found.", 404)

    def patch(self, request, pk):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Claim not found.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Only Pending claims can be edited (this one is {c.status}).", 409)
        if "remarks" in request.data:
            c.remarks = request.data["remarks"]
        c.updated_by = self.actor()
        c.save()
        return ok("MY_OT_CLAIM_UPDATED", "Claim updated.", claim_row(c, request))

    put = patch

    def delete(self, request, pk):
        c = self._c(pk)
        if c is None:
            return err("NOT_FOUND", "Claim not found.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Only Pending claims can be cancelled (this one is {c.status}).", 409)
        c.status, c.updated_by = "Cancelled", self.actor()
        c.save()
        return ok("MY_OT_CLAIM_CANCELLED", "Claim cancelled.", claim_row(c, request))


class MyOvertimeUpdatePost(MyOvertimeDetail):
    def post(self, request, pk):
        return self.patch(request, pk)


class MyOvertimeCancelPost(MyOvertimeDetail):
    def post(self, request, pk):
        return self.delete(request, pk)


# ---------------- manager / HOD ----------------
class TeamEntries(SelfBase):
    """GET /employee/timesheet/team/entries/   ?status= ?employee=<code> ?project= ?week= ?month=&year=    my reports' timesheets"""

    def get(self, request):
        p = request.query_params
        qs = TimesheetEntry.objects.filter(company=self.company, is_active=True, employee__employee_code__in=self.team_codes()) \
            .select_related("project", "employee", "employee__department")
        if p.get("status"):
            qs = qs.filter(status=p["status"])
        if p.get("employee"):
            qs = qs.filter(employee__employee_code=p["employee"])
        try:
            qs = filter_entries(qs, p)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        rows, meta = paginate(request, qs, lambda e: entry_row(e, request))
        return ok("TEAM_TIMESHEETS", "Team timesheets.", rows, meta=meta)


def pending_for(view):
    return TimesheetEntry.objects.filter(company=view.company, is_active=True, status="Submitted", approver_code=view.me.employee_code) \
        .exclude(employee=view.me).select_related("project", "employee", "employee__department")


class ApprovalsPending(SelfBase):
    """GET /employee/timesheet/approvals/pending/   ?week= ?employee=<code> ?project="""

    def get(self, request):
        p = request.query_params
        qs = pending_for(self)
        if p.get("employee"):
            qs = qs.filter(employee__employee_code=p["employee"])
        try:
            qs = filter_entries(qs, p)
            wk = to_date(p.get("week"))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        st = get_setting(self.company)
        s, e = week_bounds(wk or timezone.localdate(), st.week_start_day)
        rows = [entry_row(x, request) for x in qs.order_by("work_date", "id")]
        label = cycle_label(s, e)
        return ok("TIMESHEET_APPROVALS", "Timesheets awaiting my approval.", {
            "cycle": {"start": iso(s), "end": iso(e), "label": label}, "pending_count": len(rows), "rows": rows,
            "message": f"{len(rows)} submitted timesheet(s) awaiting your approval." if rows else
            f"All submitted timesheets for the current weekly cycle ({label}) have been verified and processed into monthly billing."})


class _Decide(SelfBase):
    approve = True

    def post(self, request, pk):
        e = pending_for(self).filter(pk=pk).first()
        if e is None:
            return err("NOT_FOUND", "Timesheet not found in your approvals queue.", 404)
        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 ApproveEntry(_Decide):
    """POST /employee/timesheet/approvals/<id>/approve/  {remarks?}"""
    approve = True


class RejectEntry(_Decide):
    """POST /employee/timesheet/approvals/<id>/reject/   {remarks}"""
    approve = False


class ApproveAll(SelfBase):
    """POST /employee/timesheet/approvals/approve-all/   {week?, employee_code?, project?, remarks?}   [Approve All Pending]"""

    def post(self, request):
        d = request.data
        qs = pending_for(self)
        if d.get("employee_code"):
            qs = qs.filter(employee__employee_code=d["employee_code"])
        try:
            qs = filter_entries(qs, {k: d[k] for k in ("week", "project", "date_from", "date_to") if d.get(k)})
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        ids = []
        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 OvertimeApprovalsPending(SelfBase):
    """GET /employee/timesheet/approvals/overtime/    overtime claims waiting for me"""

    def get(self, request):
        qs = OvertimeClaim.objects.filter(company=self.company, is_active=True, status="Pending", approver_code=self.me.employee_code) \
            .exclude(employee=self.me).select_related("employee", "employee__department")
        return ok("OT_APPROVALS", "Overtime claims awaiting my approval.", [claim_row(c, request) for c in qs])


class _DecideClaim(SelfBase):
    approve = True

    def post(self, request, pk):
        c = OvertimeClaim.objects.filter(company=self.company, is_active=True, pk=pk, approver_code=self.me.employee_code) \
            .exclude(employee=self.me).select_related("employee", "employee__department").first()
        if c is None:
            return err("NOT_FOUND", "Claim not found in your approvals queue.", 404)
        if c.status != "Pending":
            return err("INVALID_STATE", f"Claim is already {c.status}.", 409)
        remarks = request.data.get("remarks")
        if not self.approve and not (remarks or "").strip():
            return err("VALIDATION", "remarks are required when rejecting.")
        c.status = "Approved" if self.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 self.approve else "OT_CLAIM_REJECTED", "Claim approved." if self.approve else "Claim rejected.", claim_row(c, request))


class ApproveClaim(_DecideClaim):
    """POST /employee/timesheet/approvals/overtime/<id>/approve/  {remarks?}"""
    approve = True


class RejectClaim(_DecideClaim):
    """POST /employee/timesheet/approvals/overtime/<id>/reject/   {remarks}"""
    approve = False
