# ============ NexusApp/views/admin_views.py ============
# 1) add these two imports at the top (if not already there):
#      from datetime import datetime, timedelta
#      from django.utils import timezone
#    (Q, Sum, Decimal, JsonResponse, LoanPayment, logger are already imported in that file)
# 2) paste everything below right after your existing  def reports(request):
# 3) urls.py  ->  path('reports_data/', admin_views.reports_data, name='reports_data'),

# ---------------------------------------------------------------- REPORTS (ajax data)
import logging
import re
from django.db import transaction, IntegrityError
from django.shortcuts import redirect
from django.contrib import messages
from datetime import datetime
from django.http import JsonResponse
from decimal import Decimal, InvalidOperation

from NexusApp.models import AdminUser, Staff, Loan, Place,LoanPayment
from django.shortcuts import render, get_object_or_404
from django.db.models import Q
from django.urls import reverse
from django.utils.html import escape
from django.views.decorators.http import require_POST
from django.db.models import Sum
from datetime import datetime, timedelta
from django.utils import timezone

from NexusApp.utils.excel import date_range, range_label, xlsx_response

logger = logging.getLogger(__name__)

REPORT_SORT = {
    1: ['payment_date', 'id'],          # Date
    2: ['loan__customer__customer_name'],         # Customer
    3: ['collected_by__name'],          # Staff
    4: ['amount'],                      # Payment amount
}


def _report_range(period, date_str):
    """(start, end) dates for daily / weekly (Mon-Sun) / monthly, or None for 'all'."""
    if period not in ('daily', 'weekly', 'monthly'):
        return None
    try:
        day = datetime.strptime(date_str, '%Y-%m-%d').date()
    except ValueError:
        day = timezone.localdate()

    if period == 'daily':
        return day, day
    if period == 'weekly':
        start = day - timedelta(days=day.weekday())
        return start, start + timedelta(days=6)
    start = day.replace(day=1)
    next_month = (start + timedelta(days=32)).replace(day=1)
    return start, next_month - timedelta(days=1)


def _report_ledger(loan_ids):
    """
    Pending / extra for every payment of the given loans (same rule as Paid Due History):
      need    = what was still owed on the current due just before this payment
      pending = need - paid     (paid less than the due)
      extra   = paid - need     (paid ahead, goes to the next due)
    Returns {payment_id: {...}}.
    """
    by_loan = {}
    payments = (
        LoanPayment.objects.filter(loan_id__in=loan_ids)
        .select_related('loan__customer').order_by('payment_date', 'id')
    )
    for p in payments:
        by_loan.setdefault(p.loan_id, []).append(p)

    ledger = {}
    for items in by_loan.values():
        loan = items[0].loan
        due = loan.due_amount or Decimal('0')
        total_payable = loan.total_payable
        final_paid = sum((p.amount for p in items), Decimal('0'))
        running = Decimal('0')

        for idx, p in enumerate(items):
            done = (running % due) if due > 0 else Decimal('0')
            target = running - done + due if due > 0 else running + p.amount
            target = min(target, total_payable)               # last due can be smaller
            need = max(target - running, Decimal('0'))

            pending = max(need - p.amount, Decimal('0'))
            extra = max(p.amount - need, Decimal('0'))
            running += p.amount

            ledger[p.id] = {
                'pending_amount': float(pending),
                'pending_cleared': 'Yes' if final_paid >= target else 'No',
                'extra_amount': float(extra),
                # paid-ahead money is "cleared" once a later payment exists for the loan
                'extra_cleared': 'Yes' if extra > 0 and idx < len(items) - 1 else 'No',
            }
    return ledger


def _report_queryset(request):
    """Payments matching the period buttons, the From / To payment-date range and the search box.
    Returns (queryset, total before filters)."""
    period = request.GET.get('period', 'all').strip().lower()
    date_str = request.GET.get('date', '').strip()
    search = request.GET.get('search[value]', '').strip()

    qs = LoanPayment.objects.select_related('loan__place', 'loan__customer', 'collected_by')
    total = qs.count()

    period_range = _report_range(period, date_str)
    if period_range:
        qs = qs.filter(payment_date__range=period_range)

    start, end = date_range(request)                   # from_date / to_date on payment_date
    if start:
        qs = qs.filter(payment_date__gte=start)
    if end:
        qs = qs.filter(payment_date__lte=end)

    if search:
        qs = qs.filter(
            Q(loan__customer__customer_name__icontains=search)
            | Q(loan__customer__phone_number__icontains=search)
            | Q(loan__place__name__icontains=search)
            | Q(collected_by__name__icontains=search)
            | Q(payment_method__icontains=search)
        )
    return qs, total


def _report_row(p, ledger):
    row = {
        'date': p.payment_date.strftime('%d-%m-%Y'),
        'customer': p.loan.customer_name,
        'phone': p.loan.phone_number,
        'place': p.loan.place.name,
        'staff': p.collected_by.name if p.collected_by else 'Admin',
        'payment_method': p.get_payment_method_display(),
        'amount': float(p.amount),
    }
    row.update(ledger.get(p.id, {}))
    return row


def reports_export(request):
    """Excel of every payment matching the Reports page filters (not only the visible page)."""
    qs, _ = _report_queryset(request)
    payments = list(qs.order_by('-payment_date', '-id'))
    ledger = _report_ledger({p.loan_id for p in payments})

    body, total = [], Decimal('0')
    for i, p in enumerate(payments, start=1):
        r = _report_row(p, ledger)
        total += p.amount
        pending, extra = r.get('pending_amount', 0), r.get('extra_amount', 0)
        body.append([
            i, r['date'], r['customer'], r['phone'], r['place'], r['staff'], r['payment_method'],
            p.amount, pending, r.get('pending_cleared', '-') if pending > 0 else '-',
            extra, r.get('extra_cleared', '-') if extra > 0 else '-',
        ])

    start, end = date_range(request)
    period = request.GET.get('period', 'all').strip().lower()
    period_range = _report_range(period, request.GET.get('date', '').strip())
    subtitle = f'Payment date: {range_label(start, end)}'
    if period_range:
        subtitle += f' | {period.title()}: {range_label(*period_range)}'
    return xlsx_response(
        'collection_report', 'Collection Report',
        ['S.No', 'Date', 'Customer', 'Phone', 'Place', 'Staff', 'Mode', 'Amount',
         'Pending', 'Pending Cleared', 'Extra', 'Extra Cleared'],
        body, subtitle=subtitle,
        totals=['Total', '', '', '', '', '', '', total] if body else None)


def reports_data(request):
    """AJAX (DataTables server-side) for /admin/reports/ - one row per collected payment."""
    if request.headers.get('x-requested-with') != 'XMLHttpRequest':
        return JsonResponse({'status': 'error', 'message': 'Invalid request.'}, status=400)

    def to_int(value, default):
        try:
            return int(value)
        except (TypeError, ValueError):
            return default

    draw = to_int(request.GET.get('draw'), 1)
    try:
        qs, total = _report_queryset(request)
        filtered = qs.count()

        # ordering (default: newest payment first)
        order_col = to_int(request.GET.get('order[0][column]'), -1)
        if order_col in REPORT_SORT:
            desc = request.GET.get('order[0][dir]', 'asc') == 'desc'
            qs = qs.order_by(*[('-' + f if desc else f) for f in REPORT_SORT[order_col]])
        else:
            qs = qs.order_by('-payment_date', '-id')

        start = max(to_int(request.GET.get('start'), 0), 0)
        length = to_int(request.GET.get('length'), 10)
        page = list(qs[start:] if length == -1 else qs[start:start + max(length, 1)])

        ledger = _report_ledger({p.loan_id for p in page})

        data = []
        for i, p in enumerate(page, start=start + 1):
            row = {'DT_RowIndex': i}
            row.update(_report_row(p, ledger))
            data.append(row)

        return JsonResponse({
            'draw': draw,
            'recordsTotal': total,
            'recordsFiltered': filtered,
            'data': data,
        })

    except Exception:
        logger.exception('reports_data failed')
        return JsonResponse({
            'draw': draw, 'recordsTotal': 0, 'recordsFiltered': 0, 'data': [],
            'error': 'Could not load reports.',
        }, status=500)