import calendar
import logging
from datetime import date, datetime, timedelta
from decimal import Decimal, InvalidOperation

from django.db import transaction
from django.db.models import DecimalField, Q, Sum, Value
from django.db.models.functions import Coalesce
from django.http import Http404, HttpResponse, JsonResponse
from django.shortcuts import get_object_or_404, render
from django.urls import reverse
from django.utils import timezone
from urllib.parse import urlencode
from django.views.decorators.http import require_POST

from NexusApp.models import Loan, LoanPayment
from NexusApp.utils.excel import date_range, range_label, xlsx_response

logger = logging.getLogger(__name__)

MONEY = DecimalField(max_digits=14, decimal_places=2)
ZERO = Decimal('0')


# ----------------------------------------------------------------- helpers
def _int(value, default):
    try:
        return int(value)
    except (TypeError, ValueError):
        return default


def _in_range(iso, start, end):
    """True when the ISO date string `iso` is inside [start, end] (open ends allowed)."""
    if not (start or end):
        return True
    if not iso:
        return False
    return (not start or iso >= start.isoformat()) and (not end or iso <= end.isoformat())


# due dates skip Sundays - see NexusApp/utils/loan_schedule.py
from NexusApp.utils.loan_schedule import (  # noqa: E402
    add_months as _add_months, loan_position, nth_due_date as _nth_due_date,
)


def _build_row(loan, today, ns='admin'):
    due_amount = loan.due_amount or ZERO
    paid = loan.paid or ZERO
    pos = loan_position(loan, paid, today)
    balance = pos['balance']
    paid_dues = pos['paid_dues']
    next_due = pos['next_due']

    return {
        'loan_id': loan.id,
        'customer_name': loan.customer_name,
        'phone_number': loan.phone_number,
        'place': loan.place.name,
        'place_id': loan.place_id,
        'loan_amount': float(loan.loan_amount),
        'paid_amount': float(paid),
        'pending_amount': float(balance),
        'balance_amount': float(balance),
        'total_payable': float(loan.total_payable),
        'due_amount': float(due_amount),
        'number_of_dues': loan.number_of_dues,
        'paid_dues': paid_dues,
        'pending_dues': loan.number_of_dues - paid_dues,
        'pending_days': pos['pending_days'],
        'overdue_amount': float(pos['overdue']),
        'due_number': min(paid_dues + 1, loan.number_of_dues),   # shown in Pay modal
        'payable_now': float(min(due_amount, balance)),          # default amount in Pay modal
        'payment_type': loan.get_payment_type_display(),
        'loan_date': loan.loan_date.strftime('%d/%m/%Y') if loan.loan_date else '-',
        'loan_date_iso': loan.loan_date.isoformat() if loan.loan_date else '',
        'next_due_date': next_due.strftime('%d/%m/%Y') if next_due else '-',
        'next_due_iso': next_due.isoformat() if next_due else '',
        'status': pos['status'],
        'paid_history_url': (
            f"{reverse(ns + ':paid_due_history')}?"
            f"{urlencode({'id': loan.id, 'place': loan.place.name})}"
        ),
        'invoice_url': f"{reverse(ns + ':payment_invoice')}?id={loan.id}",
        'period_report_url': f"{reverse(ns + ':loan_period_report')}?id={loan.id}",
    }


def _collect_rows(request):
    """Apply place / search / payment-type / due-date / loan-date range filters.
    Completed loans are excluded from Loan Reports.
    """
    place = request.GET.get('place', '').strip()
    start, end = date_range(request)                 # from_date / to_date on loan_date
    search = request.GET.get('search[value]', '').strip().lower()
    payment_type = request.GET.get('payment_type', '').strip().lower()
    due_date = request.GET.get('due_date', '').strip()

    qs = Loan.objects.select_related('place', 'customer').annotate(
        paid=Coalesce(Sum('payments__amount'), Value(0), output_field=MONEY)
    )

    if place:
        qs = qs.filter(place__name__iexact=place)

    today = timezone.localdate()

    # build rows, then drop completed loans
    rows = [_build_row(loan, today) for loan in qs.order_by('-id')]
    rows = [row for row in rows if row['status'] != 'Completed']

    # total active loans before search and other filters
    total = len(rows)

    if payment_type in ('daily', 'weekly', 'monthly'):
        rows = [row for row in rows if row['payment_type'].lower() == payment_type]

    if search:
        rows = [
            row for row in rows
            if search in row['customer_name'].lower()
            or search in row['phone_number'].lower()
        ]

    if due_date:
        rows = [row for row in rows if row['next_due_iso'] == due_date]

    if start or end:
        rows = [row for row in rows if _in_range(row['loan_date_iso'], start, end)]

    return rows, total


# -------------------------------------------------------------- endpoints
SORT_KEYS = {
    1: lambda r: r['customer_name'].lower(),
    2: lambda r: r['balance_amount'],
    3: lambda r: r['loan_amount'],
    4: lambda r: r['due_amount'],
    5: lambda r: r['next_due_iso'] or '9999-99-99',
    6: lambda r: r['status'],
}


def admin_loan_reports_data(request):
    if request.headers.get('x-requested-with') != 'XMLHttpRequest':
        return JsonResponse({'status': 'error', 'message': 'Invalid request.'}, status=400)

    draw = _int(request.GET.get('draw'), 1)
    try:
        start = max(_int(request.GET.get('start'), 0), 0)
        length = _int(request.GET.get('length'), 10)

        rows, total = _collect_rows(request)
        filtered = len(rows)

        order_col = _int(request.GET.get('order[0][column]'), -1)
        if order_col in SORT_KEYS:
            rows.sort(
                key=SORT_KEYS[order_col],
                reverse=request.GET.get('order[0][dir]', 'asc') == 'desc',
            )

        page = rows[start:] if length == -1 else rows[start:start + max(length, 1)]
        for i, row in enumerate(page, start=start + 1):
            row['DT_RowIndex'] = i

        return JsonResponse({
            'draw': draw,
            'recordsTotal': total,
            'recordsFiltered': filtered,
            'data': page,
        })

    except Exception:
        logger.exception('admin_loan_reports_data failed')
        return JsonResponse({
            'draw': draw, 'recordsTotal': 0, 'recordsFiltered': 0, 'data': [],
            'error': 'Could not load loan reports.',
        }, status=500)


LOAN_REPORT_HEADERS = [
    'S.No', 'Paid Amount', 'Balance Amount', 'Pending Days', 'Customer Name', 'Phone',
    'Loan Amount', 'Total Payable', 'Number of Dues', 'Due Amount', 'Payment Type',
    'Paid Dues', 'Pending Dues', 'Next Due Date', 'Status',
]


def loan_reports_xlsx(request, rows):
    """Excel of the Loan Reports rows (same columns the old CSV had)."""
    place = request.GET.get('place', '').strip()
    start, end = date_range(request)
    body = [[
        i, r['paid_amount'], r['balance_amount'], r['pending_days'],
        r['customer_name'], r['phone_number'],
        r['loan_amount'], r['total_payable'], r['number_of_dues'], r['due_amount'], r['payment_type'],
        r['paid_dues'], r['pending_dues'], r['next_due_date'], r['status'],
    ] for i, r in enumerate(rows, start=1)]
    totals = ['Total', sum(r['paid_amount'] for r in rows), sum(r['balance_amount'] for r in rows),
              '', '', '', sum(r['loan_amount'] for r in rows), sum(r['total_payable'] for r in rows)]
    return xlsx_response(
        f"loan_reports_{place or 'all'}", 'Loan Reports', LOAN_REPORT_HEADERS, body,
        subtitle=f"{place or 'All Places'} - Loan date: {range_label(start, end)}",
        totals=totals if rows else None)


def admin_loan_reports_export(request):
    rows, _ = _collect_rows(request)
    return loan_reports_xlsx(request, rows)


# ----------------------------------------------------------- record payment
@require_POST
def admin_record_payment(request):
    """Save one collection (a LoanPayment row) from the Record Payment modal."""
    loan_id = request.POST.get('loan_id', '').strip()
    payment_date = request.POST.get('payment_date', '').strip()
    amount_raw = request.POST.get('paid_amount', '').strip()
    method = request.POST.get('payment_method', '').strip().lower()
    pay_status = request.POST.get('payment_status', '').strip().lower()

    errors = {}

    if not loan_id.isdigit():
        errors['loan_id'] = 'Loan is missing. Close the window and try again.'

    parsed_date = None
    if not payment_date:
        errors['payment_date'] = 'Payment date is required.'
    else:
        try:
            parsed_date = datetime.strptime(payment_date, '%Y-%m-%d').date()
            if parsed_date > timezone.localdate():
                errors['payment_date'] = 'Payment date cannot be in the future.'
        except ValueError:
            errors['payment_date'] = 'Invalid date format (use YYYY-MM-DD).'

    amount = None
    if not amount_raw:
        errors['paid_amount'] = 'Paid amount is required.'
    else:
        try:
            amount = Decimal(amount_raw)
            if not amount.is_finite() or amount <= 0:
                errors['paid_amount'] = 'Enter a valid positive paid amount.'
            elif amount != amount.quantize(Decimal('0.01')):
                errors['paid_amount'] = 'Paid amount can have at most 2 decimal places.'
        except InvalidOperation:
            errors['paid_amount'] = 'Enter a valid positive paid amount.'

    if method not in dict(LoanPayment.METHOD_CHOICES):
        errors['payment_method'] = 'Select a payment method.'
    if pay_status not in dict(LoanPayment.PAYMENT_STATUS_CHOICES):
        errors['payment_status'] = 'Select a payment status.'

    if errors:
        return JsonResponse({
            'status': 'error',
            'message': next(iter(errors.values())),
            'errors': errors,
        }, status=400)

    try:
        with transaction.atomic():
            # lock the loan row so two people cannot overpay the same loan at once
            loan = Loan.objects.select_for_update().filter(pk=int(loan_id)).first()
            if loan is None:
                return JsonResponse({'status': 'error', 'message': 'Loan not found.'}, status=404)
            if loan.status == 'completed':
                return JsonResponse(
                    {'status': 'error', 'message': 'This loan is already completed.'}, status=400)

            paid_so_far = loan.payments.aggregate(s=Sum('amount'))['s'] or ZERO
            pending = loan.total_payable - paid_so_far
            if amount > pending:
                return JsonResponse({
                    'status': 'error',
                    'message': f'Paid amount is more than the pending amount (\u20b9{pending:,.2f}).',
                    'errors': {'paid_amount': 'Amount exceeds pending amount.'},
                }, status=400)

            # admin payments have no staff collector (collected_by stays empty)
            LoanPayment.objects.create(
                loan=loan,
                payment_date=parsed_date,
                amount=amount,
                collected_by=None,
                payment_method=method,
                payment_status=pay_status,
            )

            new_pending = pending - amount
            if new_pending <= 0:                      # fully repaid -> close the loan
                loan.status = 'completed'
                loan.closed_date = parsed_date
                loan.save(update_fields=['status', 'closed_date', 'updated_at'])

        logger.info('payment recorded', extra={'loan_id': loan.id, 'amount': str(amount)})
        return JsonResponse({
            'status': 'success',
            'message': _payment_message(loan, amount, paid_so_far, new_pending),
            'pending_amount': float(new_pending),
            'loan_completed': new_pending <= 0,
        })

    except Exception:
        logger.exception('admin_record_payment failed')
        return JsonResponse(
            {'status': 'error', 'message': 'Could not save the payment. Please try again.'},
            status=500)


# ------------------------------------------------------- paid due history
def _loan_with_paid(loan_id):
    """The loan plus its total paid so far (annotated as .paid)."""
    return get_object_or_404(
        Loan.objects.select_related('place', 'customer').annotate(
            paid=Coalesce(Sum('payments__amount'), Value(0), output_field=MONEY)
        ),
        pk=loan_id,
    )


def _history_rows(loan):
    """
    One row per payment, oldest first, with a running ledger so pending / extra
    can be shown per payment:

      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 dues)

    A pending row shows "Cleared" once later payments have covered that due.
    """
    payments = list(
        loan.payments.select_related('collected_by').order_by('payment_date', 'id')
    )
    due = loan.due_amount or ZERO
    total_payable = loan.total_payable
    final_paid = sum((p.amount for p in payments), ZERO)

    rows, running = [], ZERO
    for i, p in enumerate(payments, start=1):
        done = (running % due) if due > 0 else ZERO          # already paid towards this due
        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, ZERO)

        pending = max(need - p.amount, ZERO)
        extra = max(p.amount - need, ZERO)
        running += p.amount

        rows.append({
            'sno': i,
            'payment_date': p.payment_date.strftime('%d %B %Y'),
            'payment_date_iso': p.payment_date.isoformat(),
            'paid_due_amount': float(p.amount),
            'payment_method': p.get_payment_method_display(),
            'collected_by': p.collected_by.name if p.collected_by else '-',
            'pending_amount': float(pending),
            'pending_cleared': 'Yes' if final_paid >= target else 'No',
            'extra_amount': float(extra),
            'id': p.id,
        })
    return rows


def admin_paid_due_history(request):
    """Page: /admin/paid_due_history/?id=<loan id>"""
    loan_id = request.GET.get('id', '').strip()
    if not loan_id.isdigit():
        raise Http404('Loan not found')

    loan = _loan_with_paid(int(loan_id))
    summary = _build_row(loan, timezone.localdate())

    return render(request, 'adminpanel/paid_due_history.html', {
        'loan': loan,
        'summary': summary,
        'place_name': loan.place.name,
        'total_amount': float(loan.total_payable),
    })


HISTORY_SORT_KEYS = {
    1: lambda r: (r['payment_date_iso'], r['id']),
    2: lambda r: r['paid_due_amount'],
    3: lambda r: r['pending_amount'],
    4: lambda r: r['extra_amount'],
}


def history_in_range(request, rows):
    """Keep the payments whose payment_date is inside from_date / to_date.
    The ledger is built on every payment first, so pending / extra stay correct."""
    start, end = date_range(request)
    if start or end:
        rows = [r for r in rows if _in_range(r['payment_date_iso'], start, end)]
    return rows


HISTORY_HEADERS = ['S.No', 'Payment Date', 'Paid Amount', 'Payment Method',
                   'Collected By', 'Pending Amount', 'Pending Cleared', 'Extra Amount']


def history_xlsx(request, loan, rows):
    start, end = date_range(request)
    body = [[
        r['sno'], r['payment_date'], r['paid_due_amount'], r['payment_method'],
        r['collected_by'], r['pending_amount'], r['pending_cleared'], r['extra_amount'],
    ] for r in rows]
    totals = ['Total', '', sum(r['paid_due_amount'] for r in rows)] if rows else None
    return xlsx_response(
        f'payment_history_loan_{loan.id}', 'Payment History', HISTORY_HEADERS, body,
        subtitle=f'{loan.customer_name} (Loan #{loan.id}) - Payment date: {range_label(start, end)}',
        totals=totals)


def _history_filtered(request):
    loan_id = request.GET.get('id', '').strip()
    if not loan_id.isdigit():
        return None
    loan = get_object_or_404(Loan, pk=int(loan_id))
    rows = history_in_range(request, _history_rows(loan))

    search = request.GET.get('search[value]', '').strip().lower()
    if search:
        rows = [
            r for r in rows
            if search in r['payment_date'].lower()
            or search in r['payment_method'].lower()
            or search in r['collected_by'].lower()
            or search in str(r['paid_due_amount'])
        ]
    return loan, rows


def admin_paid_due_history_data(request):
    if request.headers.get('x-requested-with') != 'XMLHttpRequest':
        return JsonResponse({'status': 'error', 'message': 'Invalid request.'}, status=400)

    draw = _int(request.GET.get('draw'), 1)
    try:
        result = _history_filtered(request)
        if result is None:
            return JsonResponse({'status': 'error', 'message': 'Loan is missing.'}, status=400)
        loan, rows = result

        total = loan.payments.count()
        filtered = len(rows)

        order_col = _int(request.GET.get('order[0][column]'), -1)
        if order_col in HISTORY_SORT_KEYS:
            rows.sort(
                key=HISTORY_SORT_KEYS[order_col],
                reverse=request.GET.get('order[0][dir]', 'asc') == 'desc',
            )
        else:
            rows.reverse()                       # default: newest payment first

        start = max(_int(request.GET.get('start'), 0), 0)
        length = _int(request.GET.get('length'), 10)
        page = rows[start:] if length == -1 else rows[start:start + max(length, 1)]

        return JsonResponse({
            'draw': draw,
            'recordsTotal': total,
            'recordsFiltered': filtered,
            'data': page,
        })

    except Http404:
        return JsonResponse({'status': 'error', 'message': 'Loan not found.'}, status=404)
    except Exception:
        logger.exception('admin_paid_due_history_data failed')
        return JsonResponse({
            'draw': draw, 'recordsTotal': 0, 'recordsFiltered': 0, 'data': [],
            'error': 'Could not load payment history.',
        }, status=500)


def admin_paid_due_history_export(request):
    result = _history_filtered(request)
    if result is None:
        return HttpResponse('Loan is missing.', status=400)
    loan, rows = result
    return history_xlsx(request, loan, rows)


# --------------------------------------------------- today collections page
def collection_range(request):
    """(start, end) payment dates for the collection pages.

    from_date / to_date pick a range. Only From given = From .. today (or just From
    when it is in the future); only To given = that one day. The old single
    ?date=YYYY-MM-DD still works when no range is given. Default = today only.
    """
    today = timezone.localdate()
    start, end = date_range(request)
    if not (start or end):
        try:
            day = datetime.strptime(request.GET.get('date', '').strip(), '%Y-%m-%d').date()
        except ValueError:
            day = today
        return day, day
    if start and not end:
        end = max(start, today)
    start = start or end
    return (start, end) if start <= end else (end, start)


def payments_in_range(request, base_qs=None):
    """Payments inside the collection range (+ optional ?search=) and the paid-so-far map."""
    start, end = collection_range(request)
    payments = (
        (LoanPayment.objects.all() if base_qs is None else base_qs)
        .filter(payment_date__range=(start, end))
        .select_related('loan__place', 'loan__customer', 'collected_by')
        .order_by('-payment_date', '-id')
    )
    search = request.GET.get('search', '').strip()
    if search:
        payments = payments.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)
        )

    # total paid so far per loan (to show the remaining balance)
    loan_ids = {p.loan_id for p in payments}
    paid_map = dict(
        LoanPayment.objects.filter(loan_id__in=loan_ids)
        .values('loan_id').annotate(s=Sum('amount'))
        .values_list('loan_id', 's')
    )
    return payments, paid_map


def _payments_for_day(request):
    """All staff collections in the selected range (default today). Admin sees every staff."""
    return payments_in_range(request)


COLLECTION_HEADERS = ['S.No', 'Payment Date', 'Customer Name', 'Phone', 'Place', 'Collected By',
                      'Payment Type', 'Payment Method', 'Amount', 'Payment Status', 'Loan Balance']


def collections_xlsx(request, payments, paid_map, filename='collections'):
    start, end = collection_range(request)
    body, total = [], ZERO
    for i, p in enumerate(payments, start=1):
        loan = p.loan
        total += p.amount
        body.append([
            i, p.payment_date.strftime('%d-%m-%Y'), loan.customer_name, loan.phone_number,
            loan.place.name, p.collected_by.name if p.collected_by else 'Admin',
            loan.get_payment_type_display(), p.get_payment_method_display(), p.amount,
            p.get_payment_status_display(),
            max(loan.total_payable - paid_map.get(loan.id, ZERO), ZERO),
        ])
    return xlsx_response(
        filename, 'Collections', COLLECTION_HEADERS, body,
        subtitle=f'Payment date: {range_label(start, end)}',
        totals=['Total', '', '', '', '', '', '', '', total] if body else None)


def admin_collections_export(request):
    payments, paid_map = payments_in_range(request)
    return collections_xlsx(request, payments, paid_map)


def admin_today_collections_data(request):
    payments, paid_map = _payments_for_day(request)

    data = []
    total = cash = upi = ZERO
    for i, p in enumerate(payments, start=1):
        loan = p.loan
        balance = max(loan.total_payable - paid_map.get(loan.id, ZERO), ZERO)
        total += p.amount
        if p.payment_method == 'cash':
            cash += p.amount
        elif p.payment_method == 'upi':
            upi += p.amount
        data.append({
            'sno': i,
            'loan_id': loan.id,
            'customer': loan.customer_name,
            'phone': loan.phone_number,
            'place': loan.place.name,
            'staff': p.collected_by.name if p.collected_by else '-',
            'payment_type': loan.get_payment_type_display(),
            'payment_method': p.get_payment_method_display(),
            'payment_date': p.payment_date.isoformat(),
            'amount': float(p.amount),
            'payment_status': p.get_payment_status_display(),
            'loan_balance': float(balance),
        })

    return JsonResponse({
        'data': data,
        'summary': {
            'total': float(total), 'cash': float(cash),
            'upi': float(upi), 'count': len(data),
        },
    })


def admin_collection_list_data(request):
    payments, paid_map = _payments_for_day(request)

    data = []
    for i, p in enumerate(payments, start=1):
        loan = p.loan
        balance = max(loan.total_payable - paid_map.get(loan.id, ZERO), ZERO)
        data.append({
            'sno': i,
            'loan_id': loan.id,
            'customer': loan.customer_name,
            'phone': loan.phone_number,
            'place': loan.place.name,
            'staff': p.collected_by.name if p.collected_by else '-',
            'payment_type': loan.get_payment_type_display(),
            'payment': p.get_payment_method_display(),
            'payment_date': p.payment_date.isoformat(),
            'payment_status': p.payment_status,          # 'completed' / 'pending'
            'amount': float(p.amount),
            'pending_amount': float(balance),
            'pending_cleared': 'Yes' if p.payment_status == 'completed' else 'No',
            'extra_amount': 0,
            'extra_cleared': 'No',
        })
    return JsonResponse({'data': data})

# ------------------------------------------------- extra amount / auto close
def _payment_message(loan, amount, paid_before, new_balance):
    """Explain what the payment did: normal due, extra adjusted to next dues, or loan closed."""
    if new_balance <= 0:
        return 'Payment saved. Full balance is paid, the loan is now closed.'
    due = loan.due_amount or ZERO
    if due > 0:
        done = paid_before % due                       # part of the current due already paid
        need = due - done
        if amount > need:
            extra = amount - need
            covers = int(extra // due)
            note = f' (covers {covers} more due{"s" if covers != 1 else ""})' if covers else ''
            return (f'Payment saved. Extra ₹{extra:,.2f} is adjusted to the next dues{note}. '
                    f'Balance ₹{new_balance:,.2f}.')
    return f'Payment saved. Balance ₹{new_balance:,.2f}.'


# -------------------------------------------- day collection cards (reports)
def collection_totals(loans_qs, day):
    """Total collected today and on `day` for the given loans."""
    today = timezone.localdate()
    pays = LoanPayment.objects.filter(loan__in=loans_qs)

    def total(d):
        agg = pays.filter(payment_date=d).aggregate(
            t=Coalesce(Sum('amount'), Value(0), output_field=MONEY))
        return float(agg['t']), pays.filter(payment_date=d).count()

    t_amount, t_count = total(today)
    s_amount, s_count = total(day)
    return {
        'today': today.isoformat(), 'today_label': today.strftime('%d %b %Y'),
        'today_total': t_amount, 'today_count': t_count,
        'date': day.isoformat(), 'date_label': day.strftime('%d %b %Y'),
        'date_total': s_amount, 'date_count': s_count,
    }


def _parse_day(value):
    try:
        return datetime.strptime((value or '').strip(), '%Y-%m-%d').date()
    except ValueError:
        return timezone.localdate()


def admin_loan_reports_summary(request):
    qs = Loan.objects.all()
    place = request.GET.get('place', '').strip()
    if place:
        qs = qs.filter(place__name__iexact=place)
    return JsonResponse(collection_totals(qs, _parse_day(request.GET.get('date'))))


# ------------------------------------- weekly / monthly report of one loan
def period_report_payload(loan):
    from NexusApp.utils.loan_schedule import period_report
    today = timezone.localdate()
    payments = list(loan.payments.order_by('payment_date', 'id'))
    paid = sum((p.amount for p in payments), ZERO)
    loan.paid = paid
    pos = loan_position(loan, paid, today)
    return {
        'loan_id': loan.id,
        'customer_name': loan.customer_name,
        'payment_type': loan.get_payment_type_display(),
        'total_payable': float(loan.total_payable),
        'paid_amount': float(paid),
        'balance_amount': float(pos['balance']),
        'pending_days': pos['pending_days'],
        'status': pos['status'],
        'weekly': period_report(loan, payments, today, 'weekly'),
        'monthly': period_report(loan, payments, today, 'monthly'),
    }


def admin_loan_period_report(request):
    loan_id = request.GET.get('id', '').strip()
    if not loan_id.isdigit():
        return JsonResponse({'status': 'error', 'message': 'Loan is missing.'}, status=400)
    loan = Loan.objects.select_related('customer').filter(pk=int(loan_id)).first()
    if loan is None:
        return JsonResponse({'status': 'error', 'message': 'Loan not found.'}, status=404)
    return JsonResponse(period_report_payload(loan))
