# ============================================================
# ADDITIVE: HR / Admin API - Leave management + live attendance
# status, all with employee info attached.
#
#   Leave (module "leave")
#     GET    /api/leaves/                 list (filters below)
#     POST   /api/leaves/                 create for an employee
#     GET    /api/leaves/<id>/            detail
#     PUT    /api/leaves/<id>/            update   (Pending only)
#     PATCH  /api/leaves/<id>/            update   (Pending only)
#     DELETE /api/leaves/<id>/            delete
#     POST   /api/leaves/<id>/approve/    approve  (can_approve_leave)
#     POST   /api/leaves/<id>/reject/     reject   (can_approve_leave)
#     GET    /api/leaves/summary/         total / pending / ... counts
#
#   Attendance (module "attendance")
#     GET    /api/attendance/live-status/ real-time who is in / out
#
# Permissions are 100% dynamic: they come from the EmployeeRole
# checkboxes (see Employee/employee_crud_permissions.py). Company
# Admin is 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 LeaveRequest


MAX_LEAVE_RANGE_DAYS = 366


# ============================================================
# SHARED HELPERS
# ============================================================

def _ok(code, message, data=None, http=http_status.HTTP_200_OK):
    return Response(
        {"status": "success", "code": code, "message": message, "data": data},
        status=http,
    )


def _err(code, message, http=http_status.HTTP_400_BAD_REQUEST, errors=None):
    body = {"status": "error", "code": code, "message": message, "data": None}
    if errors is not None:
        body["errors"] = errors
    return Response(body, status=http)


def _truthy(value):
    return str(value).strip().lower() in ("1", "true", "yes", "y", "on")


def employee_brief(emp, request=None):
    """
    Safe employee info block (no password / bank / statutory data)
    to show next to attendance, login history and leave rows.
    """

    if emp is None:
        return None

    image_url = None
    image = getattr(emp, "profile_image", None) or getattr(emp, "image", None)

    if image:
        try:
            image_url = (
                request.build_absolute_uri(image.url)
                if request is not None
                else image.url
            )
        except Exception:
            image_url = None

    department = None
    if getattr(emp, "department_id", None):
        department = getattr(emp.department, "name", None)
    if not department:
        department = getattr(emp, "Department", None)

    return {
        "employee_code": emp.employee_code,
        "name": emp.name,
        "email": emp.email,
        "phone_number": emp.phone_number,
        "designation": getattr(emp, "Designation", None),
        "department": department,
        "profile_image": image_url,
        "is_active": emp.is_active,
        "check_status": "Checked In" if emp.check_st == "check_in" else "Checked Out",
    }


def employee_map(company, codes):
    """{employee_code: EmployeeDT} for one company, in one query."""

    from Employee.models import EmployeeDT

    codes = [c for c in set(codes) if c]

    if not codes:
        return {}

    qs = EmployeeDT.objects.filter(
        company=company, employee_code__in=codes
    ).select_related("department")

    return {e.employee_code: e for e in qs}


def working_dates(company, from_date, to_date):
    """
    Dates in [from_date, to_date] that count as leave days:
    Sundays and the company's active holidays are excluded
    (they are already paid days in payroll_engine).
    """

    from Company.models import Holiday

    holidays = set(
        Holiday.objects.filter(
            company=company,
            is_active=True,
            date__range=(from_date, to_date),
        ).values_list("date", flat=True)
    )

    days = []
    current = from_date

    while current <= to_date:
        if current.weekday() != 6 and current not in holidays:
            days.append(current)
        current += timedelta(days=1)

    return days


def apply_leave_to_attendance(leave, company, by):
    """
    Write AttendanceEmp rows for an APPROVED leave so payroll
    counts it. Days where the employee actually worked
    (Present / Half Day) are left untouched and reported back.
    """

    from Employee.models import AttendanceEmp

    status_value = (
        "Absent" if leave.leave_type == "Unpaid Leave" else leave.leave_type
    )
    marker = f"[leave:{leave.pk}]"
    comment = f"{leave.leave_type} {marker}"

    applied, skipped = [], []

    for day in working_dates(company, leave.from_date, leave.to_date):

        record = (
            AttendanceEmp.objects.filter(
                company=company, Employee_ID=leave.Employee_ID, date=day
            )
            .order_by("-id")
            .first()
        )

        if record is None:
            AttendanceEmp.objects.create(
                Employee_ID=leave.Employee_ID,
                company=company,
                Name=leave.Name,
                date=day,
                status=status_value,
                comment=comment,
                created_by=by,
            )
            applied.append(day)

        elif record.status in ("Present", "Half Day"):
            skipped.append(day)

        else:
            record.status = status_value
            record.comment = comment
            record.updated_by = by
            record.id_version = (record.id_version or 1) + 1
            record.save()
            applied.append(day)

    return applied, skipped


def revert_leave_attendance(leave, company):
    """
    Remove the attendance rows a previously approved leave wrote.
    (No row for a past day is treated as Absent by payroll.)
    """

    from Employee.models import AttendanceEmp

    AttendanceEmp.objects.filter(
        company=company,
        Employee_ID=leave.Employee_ID,
        comment__contains=f"[leave:{leave.pk}]",
    ).delete()


# ============================================================
# LEAVE SERIALIZER
# ============================================================

class LeaveRequestSerializer(serializers.ModelSerializer):

    employee = serializers.SerializerMethodField()

    class Meta:
        model = LeaveRequest
        fields = "__all__"
        read_only_fields = [
            "company",
            "Name",
            "total_days",
            "status",
            "reviewed_by",
            "reviewed_at",
            "review_comment",
            "created_at",
            "updated_at",
            "created_by",
            "updated_by",
            "id_version",
            "is_active",
        ]
        extra_kwargs = {"Employee_ID": {"required": False}}

    def get_employee(self, obj):

        emp_map = self.context.get("employee_map")

        if emp_map is not None:
            emp = emp_map.get(obj.Employee_ID)
        else:
            emp = employee_map(obj.company, [obj.Employee_ID]).get(
                obj.Employee_ID
            )

        return employee_brief(emp, self.context.get("request"))


# ============================================================
# LEAVE VIEWSET
# ============================================================

class LeaveRequestViewSet(ModelViewSet):
    """
    Leave CRUD for Admin/HR (employee info included on every row).

    LIST filters (all optional, combine freely):
      ?status=Pending|Approved|Rejected|Cancelled
      ?employee_id=<employee_code>
      ?leave_type=Paid Leave|Sick Leave|Casual Leave|Unpaid Leave
      ?month=9&year=2026        leaves overlapping that month
      ?start_date=YYYY-MM-DD&end_date=YYYY-MM-DD   overlapping range
      ?search=<name or employee code>
      ?limit=<n>                default 500

    CREATE body:
      {"Employee_ID": "7518A82C", "leave_type": "Sick Leave",
       "from_date": "2026-09-30", "to_date": "2026-10-01",
       "reason": "Fever", "auto_approve": false}
      auto_approve=true needs the "approve leave" checkbox.

    Only Pending leave can be edited. Approving writes the
    matching attendance rows (so payroll counts them); rejecting
    or deleting an approved leave removes those rows again.
    """

    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = [IsAdminOrHR]

    permission_module = "leave"
    permission_action_map = {"approve": "approve", "reject": "approve"}

    http_method_names = ["get", "post", "put", "patch", "delete", "head", "options"]

    # ---------------- plumbing ----------------

    serializer_class = LeaveRequestSerializer

    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 get_queryset(self):

        qs = LeaveRequest.objects.filter(
            company=self.get_company(), is_active=True
        )

        params = self.request.query_params

        status_value = params.get("status")
        if status_value:
            qs = qs.filter(status__iexact=status_value.strip())

        employee_id = params.get("employee_id")
        if employee_id:
            qs = qs.filter(Employee_ID=employee_id.strip())

        leave_type = params.get("leave_type")
        if leave_type:
            qs = qs.filter(leave_type__iexact=leave_type.strip())

        search = params.get("search")
        if search:
            qs = qs.filter(
                Q(Name__icontains=search) | Q(Employee_ID__icontains=search)
            )

        month, year = params.get("month"), params.get("year")
        if month and year:
            try:
                first = date(int(year), int(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

        start_date, end_date = params.get("start_date"), params.get("end_date")
        if start_date:
            qs = qs.filter(to_date__gte=start_date)
        if end_date:
            qs = qs.filter(from_date__lte=end_date)

        return qs.order_by("-created_at", "-id")

    def get_serializer_context(self):

        context = super().get_serializer_context()

        if getattr(self, "action", None) == "list":
            codes = self.get_queryset().values_list("Employee_ID", flat=True)
            context["employee_map"] = employee_map(self.get_company(), codes)

        return context

    def _overlaps(self, company, employee_code, from_date, to_date, exclude_pk=None):

        qs = LeaveRequest.objects.filter(
            company=company,
            Employee_ID=employee_code,
            is_active=True,
            status__in=["Pending", "Approved"],
            from_date__lte=to_date,
            to_date__gte=from_date,
        )

        if exclude_pk:
            qs = qs.exclude(pk=exclude_pk)

        return qs.exists()

    def _validate_range(self, company, employee_code, from_date, to_date, exclude_pk=None):
        """Returns (days_count, error_response_or_None)."""

        if to_date < from_date:
            return None, _err("invalid_dates", "to_date cannot be before from_date.")

        if (to_date - from_date).days + 1 > MAX_LEAVE_RANGE_DAYS:
            return None, _err(
                "range_too_long",
                f"A leave cannot span more than {MAX_LEAVE_RANGE_DAYS} days.",
            )

        days = working_dates(company, from_date, to_date)

        if not days:
            return None, _err(
                "no_working_days",
                "The selected range has no working days (only Sundays / holidays).",
            )

        if self._overlaps(company, employee_code, from_date, to_date, exclude_pk):
            return None, _err(
                "leave_overlap",
                "This employee already has a pending/approved leave in that range.",
                http_status.HTTP_409_CONFLICT,
            )

        return len(days), None

    # ---------------- list / retrieve ----------------

    def list(self, request, *args, **kwargs):

        try:
            limit = min(int(request.query_params.get("limit", 500)), 2000)
        except (TypeError, ValueError):
            limit = 500

        qs = self.get_queryset()[:limit]

        data = self.get_serializer(qs, many=True).data

        return _ok("leave_list", "Leave requests fetched successfully.", data)

    def retrieve(self, request, *args, **kwargs):

        leave = self.get_object()

        return _ok(
            "leave_detail",
            "Leave request fetched successfully.",
            self.get_serializer(leave).data,
        )

    # ---------------- create ----------------

    def create(self, request, *args, **kwargs):

        from Employee.models import EmployeeDT

        company = self.get_company()

        serializer = self.get_serializer(data=request.data)

        if not serializer.is_valid():
            return _err(
                "invalid_input", "Please correct the highlighted fields.",
                errors=serializer.errors,
            )

        data = serializer.validated_data

        employee_code = (request.data.get("Employee_ID") or "").strip()

        if not employee_code:
            return _err(
                "invalid_input", "Employee_ID is required.",
                errors={"Employee_ID": ["This field is required."]},
            )

        employee = EmployeeDT.objects.filter(
            company=company, employee_code=employee_code
        ).first()

        if employee is None:
            return _err(
                "employee_not_found",
                "No employee with this Employee_ID in your company.",
                http_status.HTTP_404_NOT_FOUND,
            )

        days, error = self._validate_range(
            company, employee_code, data["from_date"], data["to_date"]
        )

        if error is not None:
            return error

        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,
            )

        actor = actor_label(request.user)

        with transaction.atomic():

            leave = serializer.save(
                company=company,
                Employee_ID=employee_code,
                Name=employee.name,
                total_days=Decimal(days),
                status="Pending",
                created_by=actor,
                updated_by=actor,
            )

            extra = {}

            if auto_approve:
                extra = self._approve(leave, company, actor, "Auto-approved on creation")

        leave.refresh_from_db()

        return _ok(
            "leave_created",
            "Leave request created."
            + (" It was approved." if auto_approve else ""),
            {**self.get_serializer(leave).data, **extra},
            http_status.HTTP_201_CREATED,
        )

    # ---------------- update ----------------

    def update(self, request, *args, **kwargs):

        partial = kwargs.pop("partial", False)

        company = self.get_company()
        leave = self.get_object()

        if leave.status != "Pending":
            return _err(
                "only_pending_editable",
                "Only a Pending leave can be edited. Reject or delete it first.",
                http_status.HTTP_409_CONFLICT,
            )

        serializer = self.get_serializer(leave, data=request.data, partial=partial)

        if not serializer.is_valid():
            return _err(
                "invalid_input", "Please correct the highlighted fields.",
                errors=serializer.errors,
            )

        data = serializer.validated_data

        from_date = data.get("from_date", leave.from_date)
        to_date = data.get("to_date", leave.to_date)

        days, error = self._validate_range(
            company, leave.Employee_ID, from_date, to_date, exclude_pk=leave.pk
        )

        if error is not None:
            return error

        leave = serializer.save(
            Employee_ID=leave.Employee_ID,   # employee cannot be changed
            Name=leave.Name,
            total_days=Decimal(days),
            updated_by=actor_label(request.user),
            id_version=(leave.id_version or 1) + 1,
        )

        return _ok(
            "leave_updated", "Leave request updated.",
            self.get_serializer(leave).data,
        )

    # ---------------- delete ----------------

    def destroy(self, request, *args, **kwargs):

        company = self.get_company()
        leave = self.get_object()

        with transaction.atomic():

            if leave.status == "Approved":
                revert_leave_attendance(leave, company)

            leave.delete()

        return _ok("leave_deleted", "Leave request deleted.")

    # ---------------- approve / reject ----------------

    def _approve(self, leave, company, actor, comment):

        applied, skipped = apply_leave_to_attendance(leave, company, actor)

        leave.status = "Approved"
        leave.reviewed_by = actor
        leave.reviewed_at = timezone.now()
        leave.review_comment = comment or None
        leave.updated_by = actor
        leave.id_version = (leave.id_version or 1) + 1
        leave.save()

        return {
            "attendance_marked": [d.isoformat() for d in applied],
            "attendance_skipped_worked_days": [d.isoformat() for d in skipped],
        }

    @action(detail=True, methods=["post"], url_path="approve")
    def approve(self, request, pk=None):

        company = self.get_company()
        leave = self.get_object()

        if leave.status != "Pending":
            return _err(
                "invalid_state",
                f"Only a Pending leave can be approved (this one is {leave.status}).",
                http_status.HTTP_409_CONFLICT,
            )

        with transaction.atomic():
            extra = self._approve(
                leave, company, actor_label(request.user),
                request.data.get("review_comment"),
            )

        return _ok(
            "leave_approved", "Leave approved.",
            {**self.get_serializer(leave).data, **extra},
        )

    @action(detail=True, methods=["post"], url_path="reject")
    def reject(self, request, pk=None):

        company = self.get_company()
        leave = self.get_object()

        if leave.status not in ("Pending", "Approved"):
            return _err(
                "invalid_state",
                f"A {leave.status} leave cannot be rejected.",
                http_status.HTTP_409_CONFLICT,
            )

        actor = actor_label(request.user)

        with transaction.atomic():

            if leave.status == "Approved":
                revert_leave_attendance(leave, company)

            leave.status = "Rejected"
            leave.reviewed_by = actor
            leave.reviewed_at = timezone.now()
            leave.review_comment = request.data.get("review_comment") or None
            leave.updated_by = actor
            leave.id_version = (leave.id_version or 1) + 1
            leave.save()

        return _ok(
            "leave_rejected", "Leave rejected.",
            self.get_serializer(leave).data,
        )


# ============================================================
# LEAVE SUMMARY (total / pending / ...)
# ============================================================

class LeaveSummaryView(APIView):
    """
    GET /api/leaves/summary/?month=9&year=2026   (month/year optional)

    Returns total / pending / approved / rejected / cancelled counts,
    approved days, a by-type breakdown, who is on leave today and
    the oldest pending requests - each with employee info.
    """

    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = [IsAdminOrHR]
    permission_module = "leave"

    def get(self, request):

        try:

            company = resolve_company_for_user(request.user)

            if company is None:
                raise PermissionDenied("Unable to resolve your company. Access denied.")

            qs = LeaveRequest.objects.filter(company=company, is_active=True)

            month, year = request.query_params.get("month"), request.query_params.get("year")

            if month and year:
                first = date(int(year), int(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)

            counts = qs.aggregate(
                total=Count("id"),
                pending=Count("id", filter=Q(status="Pending")),
                approved=Count("id", filter=Q(status="Approved")),
                rejected=Count("id", filter=Q(status="Rejected")),
                cancelled=Count("id", filter=Q(status="Cancelled")),
                approved_days=Sum("total_days", filter=Q(status="Approved")),
            )

            by_type = {
                row["leave_type"]: row["n"]
                for row in qs.values("leave_type").annotate(n=Count("id"))
            }

            today = timezone.localdate()

            on_leave = list(
                LeaveRequest.objects.filter(
                    company=company,
                    is_active=True,
                    status="Approved",
                    from_date__lte=today,
                    to_date__gte=today,
                )
            )

            pending_list = list(
                qs.filter(status="Pending").order_by("created_at")[:10]
            )

            emp_map = employee_map(
                company,
                [l.Employee_ID for l in on_leave + pending_list],
            )

            def row(leave):
                return {
                    "id": leave.pk,
                    "leave_type": leave.leave_type,
                    "from_date": leave.from_date,
                    "to_date": leave.to_date,
                    "total_days": leave.total_days,
                    "reason": leave.reason,
                    "status": leave.status,
                    "employee": employee_brief(emp_map.get(leave.Employee_ID), request),
                }

            return _ok("leave_summary", "Leave summary fetched successfully.", {
                "total": counts["total"] or 0,
                "pending": counts["pending"] or 0,
                "approved": counts["approved"] or 0,
                "rejected": counts["rejected"] or 0,
                "cancelled": counts["cancelled"] or 0,
                "approved_days": counts["approved_days"] or Decimal("0"),
                "by_type": by_type,
                "on_leave_today": [row(l) for l in on_leave],
                "pending_requests": [row(l) for l in pending_list],
            })

        except PermissionDenied as exc:
            return _err("permission_denied", str(exc), http_status.HTTP_403_FORBIDDEN)

        except (TypeError, ValueError):
            return _err("invalid_input", "month and year must be valid integers.")

        except Exception as exc:
            return _err(
                "server_error", f"Could not fetch leave summary: {exc}",
                http_status.HTTP_500_INTERNAL_SERVER_ERROR,
            )


# ============================================================
# ATTENDANCE: REAL-TIME STATUS
# ============================================================

class AttendanceLiveStatusView(APIView):
    """
    GET /api/attendance/live-status/?search=&department=&status=

    Real-time picture of every ACTIVE employee right now:
      Checked In | Checked Out | Not Checked In | On Leave
    plus summary counts and today's login/logout times, each row
    with employee info (never the password hash).

    ?status=  filter rows by one of the four labels above
              (summary counts always cover everyone).
    """

    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = [IsAdminOrHR]
    permission_module = "attendance"

    def get(self, request):

        try:

            from Employee.models import EmployeeDT, EMP_check_in_check_out

            company = resolve_company_for_user(request.user)

            if company is None:
                raise PermissionDenied("Unable to resolve your company. Access denied.")

            today = timezone.localdate()

            employees = EmployeeDT.objects.filter(
                company=company, is_active=True
            ).select_related("department")

            search = request.query_params.get("search")
            if search:
                employees = employees.filter(
                    Q(name__icontains=search) | Q(employee_code__icontains=search)
                )

            department = request.query_params.get("department")
            if department:
                employees = employees.filter(
                    Q(department__name__iexact=department)
                    | Q(Department__iexact=department)
                )

            employees = list(employees.order_by("name"))

            # latest check-in record per employee for today
            # (oldest first, so later rows overwrite earlier ones)
            todays = {}
            first_login = {}

            for rec in EMP_check_in_check_out.objects.filter(
                company=company, login_date=today
            ).order_by("id"):
                todays[rec.Employee_ID] = rec
                first_login.setdefault(rec.Employee_ID, rec.login_time)

            on_leave_codes = set(
                LeaveRequest.objects.filter(
                    company=company,
                    is_active=True,
                    status="Approved",
                    from_date__lte=today,
                    to_date__gte=today,
                ).values_list("Employee_ID", flat=True)
            )

            rows = []
            summary = {
                "total_active": len(employees),
                "checked_in": 0,
                "checked_out": 0,
                "not_checked_in": 0,
                "on_leave": 0,
            }

            for emp in employees:

                rec = todays.get(emp.employee_code)

                if emp.check_st == "check_in":
                    live = "Checked In"
                    summary["checked_in"] += 1
                elif rec is not None:
                    live = "Checked Out"
                    summary["checked_out"] += 1
                elif emp.employee_code in on_leave_codes:
                    live = "On Leave"
                    summary["on_leave"] += 1
                else:
                    live = "Not Checked In"
                    summary["not_checked_in"] += 1

                rows.append({
                    "live_status": live,
                    "first_login_time": first_login.get(emp.employee_code),
                    "last_login_time": getattr(rec, "login_time", None),
                    "last_logout_time": getattr(rec, "logout_time", None),
                    "total_working_hours": getattr(rec, "total_working_hours", None),
                    "location_type": getattr(rec, "checkin_location_type", None),
                    "employee": employee_brief(emp, request),
                })

            wanted = request.query_params.get("status")
            if wanted:
                rows = [r for r in rows if r["live_status"].lower() == wanted.strip().lower()]

            return _ok(
                "attendance_live_status",
                "Live attendance status fetched successfully.",
                {
                    "date": today,
                    "as_of": timezone.now(),
                    "summary": summary,
                    "employees": rows,
                },
            )

        except PermissionDenied as exc:
            return _err("permission_denied", str(exc), http_status.HTTP_403_FORBIDDEN)

        except Exception as exc:
            return _err(
                "server_error", f"Could not fetch live status: {exc}",
                http_status.HTTP_500_INTERNAL_SERVER_ERROR,
            )
