# ============================================================
# Project Allocation tab (Admin / HR)     /api/timesheet/projects/  /api/timesheet/allocations/
# ============================================================
from django.db.models import Q, Sum
from django.utils import timezone
from rest_framework.decorators import action

from Employee.models import Department

from .common import (ProjectAllocation, TimesheetCrud, TimesheetEntry, TimesheetProject, allocation_row, emp_by_code, entry_row, err,
                     find_project, next_seq, ok, paginate, project_row, to_bool, to_date, to_decimal, to_int)


class ProjectViewSet(TimesheetCrud):
    """
    CRUD   /api/timesheet/projects/               ?status= ?search= ?department=<id>
    POST   /api/timesheet/projects/               {title, code?, client_department?, department?, manager_employee_code?, status?, budget_hours?, start_date?, end_date?, is_billable?, description?}
    GET    /api/timesheet/projects/<id>/allocations/    GET /<id>/entries/ ?status=
    POST   /api/timesheet/projects/<id>/allocate/       {employee_codes:[..] | employee_code, role?, allocation_percent?, start_date?, end_date?}
    """
    model = TimesheetProject
    code = "PROJECT"
    employee_field = None
    select = ("manager", "department")
    search_fields = ("code", "title", "client_department")
    permission_action_map = {"allocate": "create", "allocations": "view", "entries": "view"}

    def build(self, p):
        return project_row(p, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        return qs.filter(department_id=int(p["department"])) if str(p.get("department") or "").isdigit() else qs

    def apply(self, p, d, creating):
        co = self.company()
        title = (d.get("title") or p.title or "").strip()
        if not title:
            raise ValueError("title is required.")
        p.title = title
        if creating or (d.get("code") and d["code"] != p.code):
            code = (d.get("code") or "").strip() or next_seq(TimesheetProject, co, "code", "PRJ-", 2)
            if TimesheetProject.objects.filter(company=co, code__iexact=code).exclude(pk=p.pk).exists():
                raise ValueError(f"Project code '{code}' already exists.")
            p.code = code
        for k in ("client_department", "description"):
            if k in d:
                setattr(p, k, d[k])
        if "status" in d:
            if d["status"] not in dict(TimesheetProject.STATUS):
                raise ValueError(f"Invalid status. Allowed: {', '.join(dict(TimesheetProject.STATUS))}")
            p.status = d["status"]
        if "department" in d:
            p.department = Department.objects.filter(company=co, pk=to_int(d["department"])).first() if d["department"] not in (None, "") else None
            if d["department"] not in (None, "") and p.department is None:
                raise ValueError("department not found in your company.")
        if "manager_employee_code" in d:
            p.manager = emp_by_code(co, d["manager_employee_code"], required=False)
        if "budget_hours" in d:
            b = to_decimal(d["budget_hours"])
            if b is not None and b < 0:
                raise ValueError("budget_hours cannot be negative.")
            p.budget_hours = b
        for k in ("start_date", "end_date"):
            if k in d:
                setattr(p, k, to_date(d[k]))
        if p.start_date and p.end_date and p.end_date < p.start_date:
            raise ValueError("end_date cannot be before start_date.")
        if "is_billable" in d:
            p.is_billable = to_bool(d["is_billable"], True)

    def destroy(self, request, pk=None):
        """Soft delete; the code is released (suffixed) so it can be reused for a new project."""
        p = self.scope().filter(pk=pk, is_active=True).first()
        if p is None:
            return err("NOT_FOUND", "Record not found.", 404)
        p.code = f"{p.code[:20]}~del{p.pk}"
        p.is_active, p.updated_by = False, self.actor()
        p.save()
        p.allocations.filter(is_active=True).update(is_active=False)
        return ok("PROJECT_DELETED", "Deleted.", {"id": int(pk)})

    @action(detail=True, methods=["get"], url_path="allocations")
    def allocations(self, request, pk=None):
        p = self.scope().filter(pk=pk, is_active=True).first()
        if p is None:
            return err("NOT_FOUND", "Record not found.", 404)
        qs = p.allocations.filter(is_active=True).select_related("project", "employee", "employee__department")
        rows, meta = paginate(request, qs, lambda a: allocation_row(a, request))
        return ok("PROJECT_ALLOCATIONS", "Project allocations.", rows, meta=meta)

    @action(detail=True, methods=["get"], url_path="entries")
    def entries(self, request, pk=None):
        p = self.scope().filter(pk=pk, is_active=True).first()
        if p is None:
            return err("NOT_FOUND", "Record not found.", 404)
        qs = TimesheetEntry.objects.filter(project=p, is_active=True).select_related("project", "employee", "employee__department")
        if request.query_params.get("status"):
            qs = qs.filter(status=request.query_params["status"])
        rows, meta = paginate(request, qs, lambda e: entry_row(e, request))
        return ok("PROJECT_ENTRIES", "Project timesheet entries.", rows, meta=meta)

    @action(detail=True, methods=["post"], url_path="allocate")
    def allocate(self, request, pk=None):
        p = self.scope().filter(pk=pk, is_active=True).first()
        if p is None:
            return err("NOT_FOUND", "Record not found.", 404)
        d = request.data
        codes = d.get("employee_codes") or ([d["employee_code"]] if d.get("employee_code") else [])
        if not isinstance(codes, list) or not codes:
            return err("VALIDATION", "employee_codes (list) or employee_code is required.")
        created, failed = [], []
        for c in codes:
            a = ProjectAllocation(company=self.company(), project=p, created_by=self.actor(), updated_by=self.actor())
            try:
                apply_allocation(self.company(), a, {**d, "employee_code": c}, True)
                a.save()
                created.append(allocation_row(a, request))
            except ValueError as ex:
                failed.append({"employee_code": c, "error": str(ex)})
        return ok("PROJECT_ALLOCATED", f"{len(created)} allocated, {len(failed)} failed.", {"allocations": created, "failed": failed},
                  201 if created else 400)


def current_allocation_total(co, employee, exclude_pk=None):
    t = timezone.localdate()
    qs = ProjectAllocation.objects.filter(company=co, employee=employee, is_active=True, start_date__lte=t).filter(Q(end_date__isnull=True) | Q(end_date__gte=t))
    if exclude_pk:
        qs = qs.exclude(pk=exclude_pk)
    return qs.aggregate(s=Sum("allocation_percent"))["s"] or 0


def apply_allocation(co, a, d, creating):
    if creating:
        a.project = a.project if getattr(a, "project_id", None) else find_project(co, d.get("project"))
        a.employee = emp_by_code(co, d.get("employee_code"))
        if a.project.allocations.filter(is_active=True, employee=a.employee).filter(Q(end_date__isnull=True) | Q(end_date__gte=timezone.localdate())).exists():
            raise ValueError(f"{a.employee.name} is already allocated to {a.project.code}.")
    if "role" in d:
        a.role = d["role"]
    if "allocation_percent" in d:
        pct = to_int(d["allocation_percent"])
        if pct is None or not 1 <= pct <= 100:
            raise ValueError("allocation_percent must be between 1 and 100.")
        a.allocation_percent = pct
    for k in ("start_date", "end_date"):
        if k in d:
            setattr(a, k, to_date(d[k]))
    if a.start_date is None:
        a.start_date = timezone.localdate()
    if a.end_date and a.end_date < a.start_date:
        raise ValueError("end_date cannot be before start_date.")
    if "is_billable" in d:
        a.is_billable = to_bool(d["is_billable"], True)
    if not to_bool(d.get("allow_overallocation")):
        total = current_allocation_total(co, a.employee, a.pk) + a.allocation_percent
        if total > 100:
            raise ValueError(f"{a.employee.name} would be allocated {total}% across projects. Pass allow_overallocation=true to override.")


class AllocationViewSet(TimesheetCrud):
    """
    CRUD   /api/timesheet/allocations/     ?project=<id|code> ?employee=<code> ?search=
    POST   /api/timesheet/allocations/     {project, employee_code, role?, allocation_percent?=100, start_date?, end_date?, is_billable?, allow_overallocation?}
    """
    model = ProjectAllocation
    code = "ALLOCATION"
    status_field = None
    select = ("project", "employee", "employee__department")
    search_fields = ("employee__name", "employee__employee_code", "project__title", "project__code", "role")

    def build(self, a):
        return allocation_row(a, self.request)

    def filter(self, qs, p):
        qs = super().filter(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"])
        return qs

    def apply(self, a, d, creating):
        apply_allocation(self.company(), a, d, creating)
