# ============================================================
# ADDITIVE: Admin / HR API - Leave Management & WFH Engine
# ------------------------------------------------------------
# Mounted at  /api/leave-hub/   (see Company/leave_api_urls.py)
#
# Screen tab                 -> endpoint(s)
# -----------------------------------------------------------
# Leave Dashboard            -> GET  dashboard/
# WFH & Remote Policies      -> GET/PUT/PATCH/DELETE wfh-policy/
#                               CRUD wfh-requests/  (+ approve/reject)
# Leave Requests             -> existing CRUD  /api/leaves/  (unchanged)
#                               GET  leave-requests/  (with pipeline)
#                               POST leave-requests/<id>/approve/ | reject/
# Leave Calendar             -> GET  calendar/
# Leave Balances             -> GET  balances/
#                               CRUD balance-allocations/
#                               POST balances/initialize/
# Leave Policies             -> CRUD policies/ , GET policies/framework/
# Approval Workflow          -> GET  workflow/ , CRUD workflow-steps/ ,
#                               POST workflow/reset/
# (hierarchy for approvals)  -> CRUD hierarchy/
# Pending approvals queue    -> GET  approvals/pending/
#
# Permissions are the same dynamic EmployeeRole checkboxes used by
# the rest of the HR API (module "leave"). Company Admin always
# allowed. Every query is company-isolated.
# ============================================================

from datetime import date, timedelta
from decimal import Decimal

from django.db import transaction
from django.db.models import Count, Q, Sum
from django.utils import timezone

from rest_framework import serializers
from rest_framework import status as http_status
from rest_framework.decorators import action
from rest_framework.exceptions import PermissionDenied
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.viewsets import ModelViewSet

from Employee.employee_crud_permissions import (
    AdminOrEmployeeJWTAuthentication,
    IsAdminOrHR,
    actor_label,
    resolve_company_for_user,
    user_can,
)
from Employee.models import EmployeeDT, LeaveRequest
from Employee.leave_models import (
    ApprovalAction,
    ApprovalWorkflowStep,
    LeaveBalance,
    LeavePolicy,
    ReportingHierarchy,
    WFHRequest,
)

from . import leave_engine as eng
from .leave_engine import _err, _ok, _truthy, employee_brief, employee_map


# ============================================================
# BASE
# ============================================================

class HubMixin:
    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = [IsAdminOrHR]
    permission_module = "leave"
    # PUT/PATCH/DELETE have no can_edit_leave / can_delete_leave
    # checkbox, so config writes need the HR-level "approve" flag
    # (or can_manage_leave).
    permission_write_action = "approve"

    def get_company(self):
        company = resolve_company_for_user(self.request.user)
        if company is None:
            raise PermissionDenied("Unable to resolve your company. Access denied.")
        return company

    def _limit(self, default=500, cap=2000):
        try:
            return max(1, min(int(self.request.query_params.get("limit", default)), cap))
        except (TypeError, ValueError):
            return default


class HubAPIView(HubMixin, APIView):

    def handle_exception(self, exc):
        if isinstance(exc, PermissionDenied):
            return _err("permission_denied", str(exc.detail), http_status.HTTP_403_FORBIDDEN)
        return super().handle_exception(exc)


def _emp_in_company(company, code):
    return EmployeeDT.objects.filter(company=company, employee_code=code).first()


# ============================================================
# 1. LEAVE DASHBOARD
# ============================================================

class LeaveHubDashboardView(HubAPIView):
    """
    GET /api/leave-hub/dashboard/?financial_year=2026-27&limit=50

    Total requests / approved leaves / pending approvals / WFH quota
    utilization + the "Leave & Time-off Requests" table.
    """

    permission_write_action = None

    def get(self, request):
        company = self.get_company()

        fy = request.query_params.get("financial_year") or eng.financial_year()
        if not eng.valid_fy(fy):
            return _err("invalid_input", "financial_year must look like 2026-27.")
        start, end = eng.fy_range(fy)

        qs = LeaveRequest.objects.filter(
            company=company, is_active=True, from_date__gte=start, from_date__lte=end
        )
        counts = qs.aggregate(
            total=Count("id"),
            approved=Count("id", filter=Q(status="Approved")),
            pending=Count("id", filter=Q(status="Pending")),
            rejected=Count("id", filter=Q(status="Rejected")),
            cancelled=Count("id", filter=Q(status="Cancelled")),
            approved_days=Sum("total_days", filter=Q(status="Approved")),
        )

        wfh_qs = WFHRequest.objects.filter(
            company=company, is_active=True, wfh_date__gte=start, wfh_date__lte=end
        )
        wfh_counts = wfh_qs.aggregate(
            total=Count("id"),
            approved=Count("id", filter=Q(status="Approved")),
            pending=Count("id", filter=Q(status="Pending")),
        )

        limit = self._limit(50, 500)
        rows = list(qs.order_by("-created_at", "-id")[:limit])
        emp_lookup = employee_map(company, [r.Employee_ID for r in rows])
        acts = eng.actions_map(company, "leave", [r.pk for r in rows])

        today = timezone.localdate()
        on_leave_today = LeaveRequest.objects.filter(
            company=company, is_active=True, status="Approved",
            from_date__lte=today, to_date__gte=today,
        ).count()
        wfh_today = WFHRequest.objects.filter(
            company=company, is_active=True, status="Approved", wfh_date=today
        ).count()

        util = eng.wfh_quota_utilization(company)

        return _ok("leave_hub_dashboard", "Leave dashboard fetched successfully.", {
            "financial_year": fy,
            "cards": {
                "total_requests": {"value": counts["total"] or 0,
                                   "caption": "Current financial year"},
                "approved_leaves": {"value": counts["approved"] or 0,
                                    "caption": "Processed",
                                    "approved_days": counts["approved_days"] or Decimal("0")},
                "pending_approvals": {"value": counts["pending"] or 0,
                                      "caption": "Manager action req."},
                "wfh_quota_utilization": {"value": util["label"],
                                          "caption": "Weekly company average",
                                          **util},
            },
            "leave_counts": {
                "total": counts["total"] or 0, "approved": counts["approved"] or 0,
                "pending": counts["pending"] or 0, "rejected": counts["rejected"] or 0,
                "cancelled": counts["cancelled"] or 0,
            },
            "wfh_counts": {
                "total": wfh_counts["total"] or 0, "approved": wfh_counts["approved"] or 0,
                "pending": wfh_counts["pending"] or 0,
            },
            "today": {"on_leave": on_leave_today, "on_wfh": wfh_today, "date": today},
            "badges": {
                "advance_notice": f"{eng.get_wfh_policy(company).advance_notice_hours}h Advance Notice",
                "weekly_quota": f"{eng.get_wfh_policy(company).weekly_quota_days} Days/Wk Quota",
            },
            "requests": [
                eng.leave_row(r, emp_lookup, acts.get(r.pk, []), request) for r in rows
            ],
        })


# ============================================================
# 2. WFH POLICY  (singleton per company)
# ============================================================

class WFHPolicySerializer(serializers.Serializer):
    is_enabled = serializers.BooleanField(required=False)
    weekly_quota_days = serializers.IntegerField(required=False, min_value=0, max_value=7)
    advance_notice_hours = serializers.IntegerField(required=False, min_value=0, max_value=720)
    work_start_time = serializers.TimeField(required=False)
    description = serializers.CharField(required=False, allow_blank=True)


class WFHPolicyView(HubAPIView):
    """
    GET    /api/leave-hub/wfh-policy/     policy + the 3 summary cards
    PUT    /api/leave-hub/wfh-policy/     update (partial allowed)
    PATCH  /api/leave-hub/wfh-policy/     update
    DELETE /api/leave-hub/wfh-policy/     reset to defaults (2 days/wk, 24h)
    """

    def get(self, request):
        company = self.get_company()
        data = eng.wfh_policy_dict(company)
        data["workflow"] = eng.workflow_chain(company, "wfh")
        return _ok("wfh_policy", "WFH policy fetched successfully.", data)

    def _update(self, request):
        company = self.get_company()
        ser = WFHPolicySerializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        policy = eng.get_wfh_policy(company)
        for k, v in ser.validated_data.items():
            setattr(policy, k, v)
        policy.updated_by = actor_label(request.user)
        policy.id_version = (policy.id_version or 1) + 1
        policy.save()
        return _ok("wfh_policy_updated", "WFH policy updated.", eng.wfh_policy_dict(company))

    put = patch = lambda self, request: self._update(request)

    def delete(self, request):
        company = self.get_company()
        policy = eng.get_wfh_policy(company)
        from datetime import time
        policy.is_enabled, policy.weekly_quota_days = True, 2
        policy.advance_notice_hours, policy.work_start_time = 24, time(9, 0)
        policy.description = ""
        policy.updated_by = actor_label(request.user)
        policy.id_version = (policy.id_version or 1) + 1
        policy.save()
        return _ok("wfh_policy_reset", "WFH policy reset to defaults.",
                   eng.wfh_policy_dict(company))


# ============================================================
# 3. WFH REQUESTS - full CRUD + tier approvals
# ============================================================

class WFHRequestSerializer(serializers.ModelSerializer):
    Employee_ID = serializers.CharField(required=False)

    class Meta:
        model = WFHRequest
        fields = ["id", "Employee_ID", "wfh_date", "reason"]


class WFHRequestViewSet(HubMixin, ModelViewSet):
    """
    LIST   GET    /api/leave-hub/wfh-requests/
           ?status= &employee_id= &search= &month=&year= &start_date= &end_date= &limit=
    CREATE POST   /api/leave-hub/wfh-requests/
           {"Employee_ID":"7518A82C","wfh_date":"2026-10-12","reason":"...","auto_approve":false}
    DETAIL GET    /api/leave-hub/wfh-requests/<id>/
    UPDATE PUT/PATCH /api/leave-hub/wfh-requests/<id>/   (Pending only)
    DELETE DELETE /api/leave-hub/wfh-requests/<id>/
    TIER   POST   /api/leave-hub/wfh-requests/<id>/approve/   {"review_comment": ""}
           POST   /api/leave-hub/wfh-requests/<id>/reject/
           GET    /api/leave-hub/wfh-requests/<id>/approvals/
    """

    permission_write_action = "create"      # anyone who can create can edit/delete
    permission_action_map = {"approve": "approve", "reject": "approve"}
    http_method_names = ["get", "post", "put", "patch", "delete", "head", "options"]
    serializer_class = WFHRequestSerializer

    def get_queryset(self):
        qs = WFHRequest.objects.filter(company=self.get_company(), is_active=True)
        p = self.request.query_params

        if p.get("status"):
            qs = qs.filter(status__iexact=p["status"].strip())
        if p.get("employee_id"):
            qs = qs.filter(Employee_ID=p["employee_id"].strip())
        if p.get("search"):
            qs = qs.filter(Q(Name__icontains=p["search"]) | Q(Employee_ID__icontains=p["search"]))
        if p.get("month") and p.get("year"):
            try:
                qs = qs.filter(wfh_date__month=int(p["month"]), wfh_date__year=int(p["year"]))
            except (TypeError, ValueError):
                pass
        if p.get("start_date"):
            qs = qs.filter(wfh_date__gte=p["start_date"])
        if p.get("end_date"):
            qs = qs.filter(wfh_date__lte=p["end_date"])
        return qs.order_by("-wfh_date", "-id")

    def _row(self, obj):
        company = self.get_company()
        codes = {obj.Employee_ID}
        acts = eng.actions_map(company, "wfh", [obj.pk])
        for a in acts.get(obj.pk, []):
            if a.approver_code:
                codes.add(a.approver_code)
        return eng.wfh_row(obj, employee_map(company, codes), acts.get(obj.pk, []),
                           self.request, company)

    # ---- list / retrieve ----
    def list(self, request, *args, **kwargs):
        company = self.get_company()
        rows = list(self.get_queryset()[: self._limit()])
        emp_lookup = employee_map(company, [r.Employee_ID for r in rows])
        acts = eng.actions_map(company, "wfh", [r.pk for r in rows])
        data = [eng.wfh_row(r, emp_lookup, acts.get(r.pk, []), request, company) for r in rows]
        return _ok("wfh_request_list", "WFH requests fetched successfully.", {
            "pipeline_count": sum(1 for r in rows if r.status == "Pending"),
            "policy": eng.wfh_policy_dict(company),
            "requests": data,
        })

    def retrieve(self, request, *args, **kwargs):
        return _ok("wfh_request_detail", "WFH request fetched successfully.",
                   self._row(self.get_object()))

    # ---- create ----
    def create(self, request, *args, **kwargs):
        company = self.get_company()
        ser = self.get_serializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)

        code = (request.data.get("Employee_ID") or "").strip()
        if not code:
            return _err("invalid_input", "Employee_ID is required.",
                        errors={"Employee_ID": ["This field is required."]})

        employee = _emp_in_company(company, code)
        if employee is None:
            return _err("employee_not_found",
                        "No employee with this Employee_ID in your company.",
                        http_status.HTTP_404_NOT_FOUND)

        auto_approve = _truthy(request.data.get("auto_approve", False))
        if auto_approve and not user_can(request.user, "leave", "approve"):
            return _err("permission_denied", "You do not have permission to approve leave.",
                        http_status.HTTP_403_FORBIDDEN)

        wfh_date = ser.validated_data["wfh_date"]
        policy, notice, error = eng.validate_wfh(company, code, wfh_date)
        if error is not None:
            return error

        actor = actor_label(request.user)
        with transaction.atomic():
            wfh = WFHRequest.objects.create(
                company=company, Employee_ID=code, Name=employee.name,
                wfh_date=wfh_date, reason=ser.validated_data.get("reason"),
                notice_hours=notice, status="Pending",
                created_by=actor, updated_by=actor,
            )
            eng.create_approval_actions(company, "wfh", wfh, actor)
            if auto_approve:
                ApprovalAction.objects.filter(
                    company=company, request_type="wfh", request_id=wfh.pk, status="Pending"
                ).update(status="Approved", acted_by=actor, acted_at=timezone.now(),
                         comment="Auto-approved on creation")
                eng._finalize(company, "wfh", wfh, "Approved", actor, "Auto-approved on creation")

        wfh.refresh_from_db()
        return _ok("wfh_request_created",
                   "WFH request created." + (" It was approved." if auto_approve else ""),
                   self._row(wfh), http_status.HTTP_201_CREATED)

    # ---- update ----
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop("partial", False)
        company = self.get_company()
        wfh = self.get_object()

        if wfh.status != "Pending":
            return _err("only_pending_editable",
                        "Only a Pending WFH request can be edited.",
                        http_status.HTTP_409_CONFLICT)

        ser = self.get_serializer(wfh, data=request.data, partial=partial)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)

        wfh_date = ser.validated_data.get("wfh_date", wfh.wfh_date)
        notice = wfh.notice_hours
        if wfh_date != wfh.wfh_date:
            _, notice, error = eng.validate_wfh(company, wfh.Employee_ID, wfh_date,
                                                exclude_pk=wfh.pk)
            if error is not None:
                return error

        wfh.wfh_date = wfh_date
        wfh.reason = ser.validated_data.get("reason", wfh.reason)
        wfh.notice_hours = notice
        wfh.updated_by = actor_label(request.user)
        wfh.id_version = (wfh.id_version or 1) + 1
        wfh.save()
        return _ok("wfh_request_updated", "WFH request updated.", self._row(wfh))

    # ---- delete ----
    def destroy(self, request, *args, **kwargs):
        company = self.get_company()
        wfh = self.get_object()
        with transaction.atomic():
            ApprovalAction.objects.filter(
                company=company, request_type="wfh", request_id=wfh.pk).delete()
            wfh.delete()
        return _ok("wfh_request_deleted", "WFH request deleted.")

    # ---- tiers ----
    def _tier(self, request, decision):
        company = self.get_company()
        wfh = self.get_object()
        extra, error = eng.process_tier(
            request.user, company, "wfh", wfh, decision,
            request.data.get("review_comment"),
        )
        if error is not None:
            return error
        wfh.refresh_from_db()
        verb = "approved" if decision == "approve" else "rejected"
        msg = f"WFH tier {verb}."
        if extra.get("final"):
            msg = f"WFH request {extra['final'].lower()}."
        return _ok(f"wfh_tier_{verb}", msg, {**self._row(wfh), **extra})

    @action(detail=True, methods=["post"], url_path="approve")
    def approve(self, request, pk=None):
        return self._tier(request, "approve")

    @action(detail=True, methods=["post"], url_path="reject")
    def reject(self, request, pk=None):
        return self._tier(request, "reject")

    @action(detail=True, methods=["get"], url_path="approvals")
    def approvals(self, request, pk=None):
        return _ok("wfh_approvals", "Approval pipeline fetched.",
                   self._row(self.get_object())["pipeline"])


# ============================================================
# 4. LEAVE REQUESTS - pipeline view + tier approvals
#    (plain CRUD stays on the existing /api/leaves/ endpoints)
# ============================================================

class LeaveRequestPipelineView(HubAPIView):
    """
    GET /api/leave-hub/leave-requests/
        ?status= &employee_id= &leave_type= &search= &month=&year= &limit=
    GET /api/leave-hub/leave-requests/<id>/
    """

    permission_write_action = None

    def _qs(self, company, p):
        qs = LeaveRequest.objects.filter(company=company, is_active=True)
        if p.get("status"):
            qs = qs.filter(status__iexact=p["status"].strip())
        if p.get("employee_id"):
            qs = qs.filter(Employee_ID=p["employee_id"].strip())
        if p.get("leave_type"):
            qs = qs.filter(leave_type__iexact=p["leave_type"].strip())
        if p.get("search"):
            qs = qs.filter(Q(Name__icontains=p["search"]) | Q(Employee_ID__icontains=p["search"]))
        if p.get("month") and p.get("year"):
            try:
                first = date(int(p["year"]), int(p["month"]), 1)
                nxt = (date(first.year + 1, 1, 1) if first.month == 12
                       else date(first.year, first.month + 1, 1))
                qs = qs.filter(from_date__lt=nxt, to_date__gte=first)
            except (TypeError, ValueError):
                pass
        return qs.order_by("-created_at", "-id")

    def get(self, request, pk=None):
        company = self.get_company()

        if pk is not None:
            leave = self._qs(company, {}).filter(pk=pk).first()
            if leave is None:
                return _err("not_found", "Leave request not found.", http_status.HTTP_404_NOT_FOUND)
            acts = eng.actions_map(company, "leave", [leave.pk]).get(leave.pk, [])
            codes = {leave.Employee_ID} | {a.approver_code for a in acts if a.approver_code}
            return _ok("leave_pipeline_detail", "Leave request fetched successfully.",
                       eng.leave_row(leave, employee_map(company, codes), acts, request))

        rows = list(self._qs(company, request.query_params)[: self._limit()])
        emp_lookup = employee_map(company, [r.Employee_ID for r in rows])
        acts = eng.actions_map(company, "leave", [r.pk for r in rows])
        return _ok("leave_pipeline_list", "Leave requests fetched successfully.",
                   [eng.leave_row(r, emp_lookup, acts.get(r.pk, []), request) for r in rows])


class LeaveTierActionView(HubAPIView):
    """
    POST /api/leave-hub/leave-requests/<id>/approve/   {"review_comment": ""}
    POST /api/leave-hub/leave-requests/<id>/reject/
    Moves the request through its multi-tier chain. The LAST tier
    approval marks the leave Approved and writes attendance (so payroll
    counts it) exactly like the existing single-step endpoint.
    """

    permission_write_action = None
    permission_action = "approve"      # needs the HR "approve leave" checkbox
    decision = "approve"

    def post(self, request, pk):
        company = self.get_company()

        if not user_can(request.user, "leave", "approve"):
            return _err("permission_denied", "You do not have permission to approve leave.",
                        http_status.HTTP_403_FORBIDDEN)

        leave = LeaveRequest.objects.filter(company=company, is_active=True, pk=pk).first()
        if leave is None:
            return _err("not_found", "Leave request not found.", http_status.HTTP_404_NOT_FOUND)

        if self.decision == "approve":
            err = eng.check_leave_balance(
                company, leave.Employee_ID, leave.leave_type, leave.from_date,
                leave.total_days, exclude_pk=leave.pk)
            if err is not None:
                return err

        with transaction.atomic():
            extra, error = eng.process_tier(
                request.user, company, "leave", leave, self.decision,
                request.data.get("review_comment"))
        if error is not None:
            return error

        leave.refresh_from_db()
        acts = eng.actions_map(company, "leave", [leave.pk]).get(leave.pk, [])
        emp_lookup = employee_map(
            company, {leave.Employee_ID} | {a.approver_code for a in acts if a.approver_code})
        msg = f"Leave {extra['final'].lower()}." if extra.get("final") else "Tier approved."
        return _ok(f"leave_tier_{self.decision}", msg,
                   {**eng.leave_row(leave, emp_lookup, acts, request), **extra})


class LeaveTierRejectView(LeaveTierActionView):
    decision = "reject"


# ============================================================
# 5. PENDING APPROVALS QUEUE
# ============================================================

class PendingApprovalsView(HubAPIView):
    """
    GET /api/leave-hub/approvals/pending/?request_type=leave|wfh&limit=
    The requests whose CURRENT tier is waiting for action.
    """

    permission_write_action = None

    def get(self, request):
        company = self.get_company()
        rtype = request.query_params.get("request_type")
        out = []

        for kind, model in (("leave", LeaveRequest), ("wfh", WFHRequest)):
            if rtype and rtype != kind:
                continue
            reqs = list(model.objects.filter(
                company=company, is_active=True, status="Pending"
            ).order_by("created_at")[: self._limit(200, 1000)])
            acts = eng.actions_map(company, kind, [r.pk for r in reqs])
            codes = {r.Employee_ID for r in reqs}
            for lst in acts.values():
                codes |= {a.approver_code for a in lst if a.approver_code}
            emp_lookup = employee_map(company, codes)
            for r in reqs:
                row = (eng.leave_row(r, emp_lookup, acts.get(r.pk, []), request)
                       if kind == "leave"
                       else eng.wfh_row(r, emp_lookup, acts.get(r.pk, []), request, company))
                row["request_type"] = kind
                out.append(row)

        return _ok("pending_approvals", "Pending approvals fetched successfully.", out)


# ============================================================
# 6. LEAVE CALENDAR
# ============================================================

class LeaveCalendarView(HubAPIView):
    """
    GET /api/leave-hub/calendar/?month=9&year=2026
    GET /api/leave-hub/calendar/?start_date=2026-09-11&end_date=2026-09-18
        &department=Engineering &include_pending=true
    One entry per day: who is on leave / WFH, holidays, weekly offs.
    """

    permission_write_action = None

    def get(self, request):
        company = self.get_company()
        start, end, error = eng.parse_calendar_range(request.query_params)
        if error:
            return _err("invalid_input", error)

        include_pending = _truthy(request.query_params.get("include_pending", "true"))
        days = eng.build_calendar(
            company, start, end, include_pending=include_pending,
            department=request.query_params.get("department"), request=request)

        names = sorted({x["name"] for d in days for x in d["on_leave"]})
        return _ok("leave_calendar", "Leave calendar fetched successfully.", {
            "title": "Organization Leave & Absence Calendar",
            "start_date": start, "end_date": end,
            "summary": f"Showing planned leaves from {start:%d %b %Y} to {end:%d %b %Y}.",
            "employees_on_leave": names,
            "days": days,
        })


# ============================================================
# 7. LEAVE BALANCES
# ============================================================

class LeaveBalancesView(HubAPIView):
    """
    GET /api/leave-hub/balances/?employee_id=7518A82C&financial_year=2026-27
        -> that employee's PL / CL / SL balances (cards on the screen)
    GET /api/leave-hub/balances/?financial_year=2026-27&search=&limit=100&offset=0
        -> balances of every active employee
    """

    permission_write_action = None

    def get(self, request):
        company = self.get_company()
        p = request.query_params

        fy = p.get("financial_year") or eng.financial_year()
        if not eng.valid_fy(fy):
            return _err("invalid_input", "financial_year must look like 2026-27.")

        wfh = eng.wfh_policy_dict(company)

        if p.get("employee_id"):
            emp = _emp_in_company(company, p["employee_id"].strip())
            if emp is None:
                return _err("employee_not_found", "Employee not found.",
                            http_status.HTTP_404_NOT_FOUND)
            used = eng.wfh_quota_used(company, emp.employee_code, timezone.localdate())
            return _ok("leave_balances", "Leave balances fetched successfully.", {
                "title": f"Leave Quotas & WFH Balances (FY {fy})",
                "financial_year": fy,
                "employee": employee_brief(emp, request),
                "balances": eng.balances_for(company, emp.employee_code, fy),
                "weekly_wfh_cap": {
                    "quota_days": wfh["weekly_quota_days"], "used_this_week": used,
                    "remaining_this_week": max(wfh["weekly_quota_days"] - used, 0),
                },
            })

        qs = EmployeeDT.objects.filter(company=company, is_active=True).order_by("name")
        if p.get("search"):
            qs = qs.filter(Q(name__icontains=p["search"]) | Q(employee_code__icontains=p["search"]))

        try:
            offset = max(int(p.get("offset", 0)), 0)
        except (TypeError, ValueError):
            offset = 0
        limit = self._limit(100, 500)
        total = qs.count()

        out = []
        for emp in qs.select_related("department")[offset: offset + limit]:
            out.append({
                "employee": employee_brief(emp, request),
                "balances": eng.balances_for(company, emp.employee_code, fy),
            })

        return _ok("leave_balances_all", "Leave balances fetched successfully.", {
            "financial_year": fy, "total_employees": total,
            "offset": offset, "limit": limit,
            "weekly_wfh_cap": {"quota_days": wfh["weekly_quota_days"]},
            "employees": out,
        })


class BalanceAllocationSerializer(serializers.ModelSerializer):
    class Meta:
        model = LeaveBalance
        fields = ["id", "Employee_ID", "leave_type", "financial_year", "allocated",
                  "carried_forward", "adjustment", "remarks", "created_at", "updated_at"]
        read_only_fields = ["id", "created_at", "updated_at"]

    def validate_financial_year(self, value):
        if not eng.valid_fy(value):
            raise serializers.ValidationError("Use the format 2026-27.")
        return value


class BalanceAllocationViewSet(HubMixin, ModelViewSet):
    """
    Per-employee allocation overrides (CRUD).
      GET    /api/leave-hub/balance-allocations/?employee_id=&financial_year=&leave_type=
      POST   /api/leave-hub/balance-allocations/
             {"Employee_ID":"7518A82C","leave_type":"Paid Leave","financial_year":"2026-27",
              "allocated":18,"carried_forward":4,"adjustment":0,"remarks":""}
      GET/PUT/PATCH/DELETE /api/leave-hub/balance-allocations/<id>/
    DELETE removes the override -> the employee falls back to the policy default.
    """

    http_method_names = ["get", "post", "put", "patch", "delete", "head", "options"]
    serializer_class = BalanceAllocationSerializer

    def get_queryset(self):
        qs = LeaveBalance.objects.filter(company=self.get_company(), is_active=True)
        p = self.request.query_params
        if p.get("employee_id"):
            qs = qs.filter(Employee_ID=p["employee_id"].strip())
        if p.get("financial_year"):
            qs = qs.filter(financial_year=p["financial_year"].strip())
        if p.get("leave_type"):
            qs = qs.filter(leave_type__iexact=p["leave_type"].strip())
        return qs

    def list(self, request, *args, **kwargs):
        rows = self.get_queryset()[: self._limit()]
        return _ok("balance_allocation_list", "Allocations fetched successfully.",
                   self.get_serializer(rows, many=True).data)

    def retrieve(self, request, *args, **kwargs):
        return _ok("balance_allocation_detail", "Allocation fetched successfully.",
                   self.get_serializer(self.get_object()).data)

    def create(self, request, *args, **kwargs):
        company = self.get_company()
        ser = self.get_serializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data
        if _emp_in_company(company, d["Employee_ID"]) is None:
            return _err("employee_not_found", "No employee with this Employee_ID in your company.",
                        http_status.HTTP_404_NOT_FOUND)
        if LeaveBalance.objects.filter(
            company=company, Employee_ID=d["Employee_ID"],
            leave_type=d["leave_type"], financial_year=d["financial_year"],
        ).exists():
            return _err("allocation_exists",
                        "An allocation already exists for this employee / type / year. "
                        "Update it instead.", http_status.HTTP_409_CONFLICT)
        actor = actor_label(request.user)
        obj = ser.save(company=company, created_by=actor, updated_by=actor)
        return _ok("balance_allocation_created", "Allocation created.",
                   self.get_serializer(obj).data, http_status.HTTP_201_CREATED)

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop("partial", False)
        obj = self.get_object()
        ser = self.get_serializer(obj, data=request.data, partial=partial)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data
        # identity of the row cannot change
        if any(k in d and d[k] != getattr(obj, k)
               for k in ("Employee_ID", "leave_type", "financial_year")):
            return _err("immutable_fields",
                        "Employee_ID, leave_type and financial_year cannot be changed.")
        obj = ser.save(updated_by=actor_label(request.user),
                       id_version=(obj.id_version or 1) + 1)
        return _ok("balance_allocation_updated", "Allocation updated.",
                   self.get_serializer(obj).data)

    def destroy(self, request, *args, **kwargs):
        self.get_object().delete()
        return _ok("balance_allocation_deleted",
                   "Allocation removed. Policy default now applies.")


class BalanceInitializeView(HubAPIView):
    """
    POST /api/leave-hub/balances/initialize/
    {"financial_year":"2026-27", "leave_types":["Paid Leave"],   # optional
     "employee_ids":["7518A82C"],                                # optional (default: all active)
     "carry_forward": true, "overwrite": false}
    Creates allocation rows from the policy quota for every active employee,
    optionally carrying forward the unused balance of the previous year
    (capped by the policy's max_carry_forward_days).
    """

    def post(self, request):
        company = self.get_company()
        fy = request.data.get("financial_year") or eng.financial_year()
        if not eng.valid_fy(fy):
            return _err("invalid_input", "financial_year must look like 2026-27.")

        overwrite = _truthy(request.data.get("overwrite", False))
        carry = _truthy(request.data.get("carry_forward", False))
        wanted_types = request.data.get("leave_types") or eng.LEAVE_TYPES
        wanted_codes = request.data.get("employee_ids")

        eng.ensure_default_policies(company)
        policies = {p.leave_type: p for p in LeavePolicy.objects.filter(
            company=company, is_active=True) if p.leave_type in wanted_types}

        emps = EmployeeDT.objects.filter(company=company, is_active=True)
        if wanted_codes:
            emps = emps.filter(employee_code__in=wanted_codes)

        prev_fy = f"{int(fy.split('-')[0]) - 1}-{int(fy.split('-')[0]) % 100:02d}"
        actor = actor_label(request.user)
        created = updated = skipped = 0

        with transaction.atomic():
            for emp in emps:
                prev = {b["leave_type"]: b for b in
                        eng.balances_for(company, emp.employee_code, prev_fy)} if carry else {}

                for lt, pol in policies.items():
                    if pol.annual_quota is None:
                        continue
                    cf = Decimal("0")
                    if carry and pol.carry_forward and lt in prev and prev[lt]["remaining"]:
                        cf = max(Decimal("0"), min(prev[lt]["remaining"],
                                                   pol.max_carry_forward_days))
                    row = LeaveBalance.objects.filter(
                        company=company, Employee_ID=emp.employee_code,
                        leave_type=lt, financial_year=fy).first()
                    if row and not overwrite:
                        skipped += 1
                        continue
                    if row:
                        row.allocated, row.carried_forward = pol.annual_quota, cf
                        row.updated_by = actor
                        row.id_version = (row.id_version or 1) + 1
                        row.save()
                        updated += 1
                    else:
                        LeaveBalance.objects.create(
                            company=company, Employee_ID=emp.employee_code,
                            leave_type=lt, financial_year=fy,
                            allocated=pol.annual_quota, carried_forward=cf,
                            created_by=actor, updated_by=actor)
                        created += 1

        return _ok("balances_initialized", "Leave balances initialized.", {
            "financial_year": fy, "created": created, "updated": updated, "skipped": skipped,
        })


# ============================================================
# 8. LEAVE POLICIES - CRUD
# ============================================================

class LeavePolicySerializer(serializers.ModelSerializer):
    class Meta:
        model = LeavePolicy
        fields = ["id", "leave_type", "code", "title", "description", "annual_quota",
                  "accrual_per_month", "carry_forward", "max_carry_forward_days",
                  "encashable", "max_encashable_days", "medical_certificate_after_days",
                  "min_notice_hours", "is_paid", "is_active", "created_at", "updated_at"]
        read_only_fields = ["id", "created_at", "updated_at"]


class LeavePolicyViewSet(HubMixin, ModelViewSet):
    """
    GET    /api/leave-hub/policies/          (defaults PL/CL/SL/Unpaid auto-created once)
    POST   /api/leave-hub/policies/
    GET/PUT/PATCH/DELETE /api/leave-hub/policies/<id>/
    """

    http_method_names = ["get", "post", "put", "patch", "delete", "head", "options"]
    serializer_class = LeavePolicySerializer

    def get_queryset(self):
        company = self.get_company()
        eng.ensure_default_policies(company)
        qs = LeavePolicy.objects.filter(company=company)
        if self.request.query_params.get("active_only"):
            qs = qs.filter(is_active=True)
        return qs

    def list(self, request, *args, **kwargs):
        return _ok("leave_policy_list", "Leave policies fetched successfully.",
                   self.get_serializer(self.get_queryset(), many=True).data)

    def retrieve(self, request, *args, **kwargs):
        return _ok("leave_policy_detail", "Leave policy fetched successfully.",
                   self.get_serializer(self.get_object()).data)

    def create(self, request, *args, **kwargs):
        company = self.get_company()
        ser = self.get_serializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        if LeavePolicy.objects.filter(
            company=company, leave_type=ser.validated_data["leave_type"]).exists():
            return _err("policy_exists", "A policy for this leave type already exists.",
                        http_status.HTTP_409_CONFLICT)
        actor = actor_label(request.user)
        obj = ser.save(company=company, created_by=actor, updated_by=actor)
        return _ok("leave_policy_created", "Leave policy created.",
                   self.get_serializer(obj).data, http_status.HTTP_201_CREATED)

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop("partial", False)
        obj = self.get_object()
        ser = self.get_serializer(obj, data=request.data, partial=partial)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        if ser.validated_data.get("leave_type", obj.leave_type) != obj.leave_type:
            return _err("immutable_fields", "leave_type cannot be changed.")
        obj = ser.save(updated_by=actor_label(request.user),
                       id_version=(obj.id_version or 1) + 1)
        return _ok("leave_policy_updated", "Leave policy updated.",
                   self.get_serializer(obj).data)

    def destroy(self, request, *args, **kwargs):
        self.get_object().delete()
        return _ok("leave_policy_deleted", "Leave policy deleted.")


class PolicyFrameworkView(HubAPIView):
    """GET /api/leave-hub/policies/framework/ - the numbered policy cards."""

    permission_write_action = None

    def get(self, request):
        company = self.get_company()
        return _ok("policy_framework", "Policy framework fetched successfully.", {
            "title": "Leave & Remote Work Policy Framework",
            "policies": eng.policy_framework(company),
        })


# ============================================================
# 9. APPROVAL WORKFLOW
# ============================================================

class WorkflowView(HubAPIView):
    """
    GET /api/leave-hub/workflow/?request_type=leave|wfh
    The "Automated Multi-Tier Approval Chain" boxes.
    """

    permission_write_action = None

    def get(self, request):
        company = self.get_company()
        rtype = request.query_params.get("request_type")
        if rtype and rtype not in ("leave", "wfh"):
            return _err("invalid_input", "request_type must be leave or wfh.")

        types = [rtype] if rtype else ["leave", "wfh"]
        return _ok("approval_workflow", "Approval workflow fetched successfully.", {
            "title": "Automated Multi-Tier Approval Chain",
            "chains": {t: eng.workflow_chain(company, t) for t in types},
            "custom": {
                t: ApprovalWorkflowStep.objects.filter(company=company, request_type=t).exists()
                for t in types
            },
        })


class WorkflowResetView(HubAPIView):
    """POST /api/leave-hub/workflow/reset/  {"request_type":"leave"}  -> built-in chain."""

    def post(self, request):
        company = self.get_company()
        rtype = request.data.get("request_type")
        if rtype not in ("leave", "wfh"):
            return _err("invalid_input", "request_type must be leave or wfh.")
        n, _ = ApprovalWorkflowStep.objects.filter(
            company=company, request_type=rtype).delete()
        return _ok("workflow_reset", "Workflow reset to the default chain.",
                   {"removed_steps": n, "chain": eng.workflow_chain(company, rtype)})


class WorkflowStepSerializer(serializers.ModelSerializer):
    class Meta:
        model = ApprovalWorkflowStep
        fields = ["id", "request_type", "step_order", "name", "approver_type",
                  "sla_hours", "description", "is_active", "created_at", "updated_at"]
        read_only_fields = ["id", "created_at", "updated_at"]


class WorkflowStepViewSet(HubMixin, ModelViewSet):
    """
    CRUD for custom chain steps.
      GET  /api/leave-hub/workflow-steps/?request_type=leave
      POST /api/leave-hub/workflow-steps/
           {"request_type":"leave","step_order":1,"name":"Reporting Manager",
            "approver_type":"reporting_manager","sla_hours":12,
            "description":"12-Hour SLA Review"}
      GET/PUT/PATCH/DELETE /api/leave-hub/workflow-steps/<id>/
    Changes only affect requests submitted AFTER the change.
    """

    http_method_names = ["get", "post", "put", "patch", "delete", "head", "options"]
    serializer_class = WorkflowStepSerializer

    def get_queryset(self):
        qs = ApprovalWorkflowStep.objects.filter(company=self.get_company())
        if self.request.query_params.get("request_type"):
            qs = qs.filter(request_type=self.request.query_params["request_type"])
        return qs

    def list(self, request, *args, **kwargs):
        return _ok("workflow_step_list", "Workflow steps fetched successfully.",
                   self.get_serializer(self.get_queryset(), many=True).data)

    def retrieve(self, request, *args, **kwargs):
        return _ok("workflow_step_detail", "Workflow step fetched successfully.",
                   self.get_serializer(self.get_object()).data)

    def _dup(self, company, rtype, order, exclude_pk=None):
        qs = ApprovalWorkflowStep.objects.filter(
            company=company, request_type=rtype, step_order=order)
        if exclude_pk:
            qs = qs.exclude(pk=exclude_pk)
        return qs.exists()

    def create(self, request, *args, **kwargs):
        company = self.get_company()
        ser = self.get_serializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data
        if self._dup(company, d["request_type"], d["step_order"]):
            return _err("step_order_exists", "That step_order is already used.",
                        http_status.HTTP_409_CONFLICT)
        actor = actor_label(request.user)
        obj = ser.save(company=company, created_by=actor, updated_by=actor)
        return _ok("workflow_step_created", "Workflow step created.",
                   self.get_serializer(obj).data, http_status.HTTP_201_CREATED)

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop("partial", False)
        company = self.get_company()
        obj = self.get_object()
        ser = self.get_serializer(obj, data=request.data, partial=partial)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = ser.validated_data
        rtype = d.get("request_type", obj.request_type)
        order = d.get("step_order", obj.step_order)
        if self._dup(company, rtype, order, exclude_pk=obj.pk):
            return _err("step_order_exists", "That step_order is already used.",
                        http_status.HTTP_409_CONFLICT)
        obj = ser.save(updated_by=actor_label(request.user),
                       id_version=(obj.id_version or 1) + 1)
        return _ok("workflow_step_updated", "Workflow step updated.",
                   self.get_serializer(obj).data)

    def destroy(self, request, *args, **kwargs):
        self.get_object().delete()
        return _ok("workflow_step_deleted", "Workflow step deleted.")


# ============================================================
# 10. REPORTING HIERARCHY (who approves whom) - CRUD
# ============================================================

class HierarchySerializer(serializers.ModelSerializer):
    class Meta:
        model = ReportingHierarchy
        fields = ["id", "Employee_ID", "manager_code", "hod_code",
                  "created_at", "updated_at"]
        read_only_fields = ["id", "created_at", "updated_at"]
        extra_kwargs = {"manager_code": {"required": False, "allow_null": True,
                                         "allow_blank": True},
                        "hod_code": {"required": False, "allow_null": True,
                                     "allow_blank": True}}


class HierarchyViewSet(HubMixin, ModelViewSet):
    """
    GET    /api/leave-hub/hierarchy/?employee_id=&manager_code=&hod_code=
    POST   /api/leave-hub/hierarchy/
           {"Employee_ID":"A1","manager_code":"M1","hod_code":"H1"}
    GET/PUT/PATCH/DELETE /api/leave-hub/hierarchy/<id>/
    """

    http_method_names = ["get", "post", "put", "patch", "delete", "head", "options"]
    serializer_class = HierarchySerializer

    def get_queryset(self):
        qs = ReportingHierarchy.objects.filter(company=self.get_company(), is_active=True)
        p = self.request.query_params
        for field, key in (("Employee_ID", "employee_id"), ("manager_code", "manager_code"),
                           ("hod_code", "hod_code")):
            if p.get(key):
                qs = qs.filter(**{field: p[key].strip()})
        return qs

    def _rows(self, objs, many=True):
        company = self.get_company()
        data = self.get_serializer(objs, many=many).data
        rows = data if many else [data]
        codes = set()
        for r in rows:
            codes |= {r["Employee_ID"], r.get("manager_code"), r.get("hod_code")}
        lookup = employee_map(company, codes)
        for r in rows:
            r["employee"] = employee_brief(lookup.get(r["Employee_ID"]), self.request)
            r["manager"] = employee_brief(lookup.get(r.get("manager_code")), self.request)
            r["hod"] = employee_brief(lookup.get(r.get("hod_code")), self.request)
        return rows if many else rows[0]

    def list(self, request, *args, **kwargs):
        return _ok("hierarchy_list", "Reporting hierarchy fetched successfully.",
                   self._rows(self.get_queryset()[: self._limit()]))

    def retrieve(self, request, *args, **kwargs):
        return _ok("hierarchy_detail", "Reporting hierarchy fetched successfully.",
                   self._rows(self.get_object(), many=False))

    def _check_codes(self, company, d, employee_code):
        for key in ("manager_code", "hod_code"):
            val = (d.get(key) or "").strip()
            if not val:
                d[key] = None
                continue
            if val == employee_code:
                return _err("invalid_input", f"{key} cannot be the employee themself.")
            if _emp_in_company(company, val) is None:
                return _err("employee_not_found", f"{key} {val} not found in your company.",
                            http_status.HTTP_404_NOT_FOUND)
        return None

    def create(self, request, *args, **kwargs):
        company = self.get_company()
        ser = self.get_serializer(data=request.data)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = dict(ser.validated_data)
        code = d["Employee_ID"].strip()
        if _emp_in_company(company, code) is None:
            return _err("employee_not_found", "No employee with this Employee_ID in your company.",
                        http_status.HTTP_404_NOT_FOUND)
        bad = self._check_codes(company, d, code)
        if bad is not None:
            return bad
        if ReportingHierarchy.objects.filter(company=company, Employee_ID=code).exists():
            return _err("hierarchy_exists",
                        "A hierarchy already exists for this employee. Update it instead.",
                        http_status.HTTP_409_CONFLICT)
        actor = actor_label(request.user)
        obj = ReportingHierarchy.objects.create(
            company=company, Employee_ID=code, manager_code=d.get("manager_code"),
            hod_code=d.get("hod_code"), created_by=actor, updated_by=actor)
        return _ok("hierarchy_created", "Reporting hierarchy created.",
                   self._rows(obj, many=False), http_status.HTTP_201_CREATED)

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop("partial", False)
        company = self.get_company()
        obj = self.get_object()
        ser = self.get_serializer(obj, data=request.data, partial=partial)
        if not ser.is_valid():
            return _err("invalid_input", "Please correct the highlighted fields.",
                        errors=ser.errors)
        d = dict(ser.validated_data)
        if d.get("Employee_ID", obj.Employee_ID) != obj.Employee_ID:
            return _err("immutable_fields", "Employee_ID cannot be changed.")
        bad = self._check_codes(company, d, obj.Employee_ID)
        if bad is not None:
            return bad
        for k in ("manager_code", "hod_code"):
            if k in d or not partial:
                setattr(obj, k, d.get(k))
        obj.updated_by = actor_label(request.user)
        obj.id_version = (obj.id_version or 1) + 1
        obj.save()
        return _ok("hierarchy_updated", "Reporting hierarchy updated.",
                   self._rows(obj, many=False))

    def destroy(self, request, *args, **kwargs):
        self.get_object().delete()
        return _ok("hierarchy_deleted", "Reporting hierarchy deleted.")

