"""
controllers/Admin/AdminoverdueController.py

Backend for the two admin pages:

    /admin/overdue_loan/        -> list of every loan whose next due date has passed
    /admin/view_overdue_loan/   -> one overdue loan (?id=<loan id>) + its payment history

A loan is "overdue" when it is not completed and the next unpaid due date is
earlier than today (same rule the Loan Reports page uses for its Overdue badge).
"""
import logging

from django.db.models import Sum, Value
from django.db.models.functions import Coalesce
from django.http import Http404, HttpResponse, JsonResponse
from django.shortcuts import redirect,render
from django.urls import reverse
from django.utils import timezone

from NexusApp.models import Loan
from NexusApp.utils.excel import date_range, range_label, xlsx_response

# reuse the helpers that already power Loan Reports so both pages always agree
from .AdminloanreportController import (
    MONEY,
    ZERO,
    _build_row,
    _in_range,
    _int,
    _loan_with_paid,
    _nth_due_date,
)

logger = logging.getLogger(__name__)


# ----------------------------------------------------------------- helpers
def _overdue_numbers(loan, row, today):
    """How many dues / how much money / how many working days are overdue."""
    from datetime import timedelta
    from NexusApp.utils.loan_schedule import dues_elapsed, working_days_between

    # dues whose date is already behind us (due date < today)
    elapsed = dues_elapsed(loan, today - timedelta(days=1))
    overdue_dues = max(elapsed - row['paid_dues'], 0)
    should_have_paid = min((loan.due_amount or ZERO) * elapsed, loan.total_payable)
    overdue_amount = max(should_have_paid - (loan.paid or ZERO), ZERO)

    overdue_days = 0
    if row['next_due_iso']:
        next_due = _nth_due_date(loan.first_due_date, loan.payment_type, row['paid_dues'])
        overdue_days = working_days_between(next_due + timedelta(days=1), today)   # Sundays not counted

    return overdue_dues, overdue_amount, overdue_days


def _overdue_row(loan, today, view_url_name='admin:view_overdue_loan'):
    """One DataTable row, or None when the loan is not overdue."""
    row = _build_row(loan, today, view_url_name.split(':')[0])
    if row['status'] != 'Overdue':
        return None

    overdue_dues, overdue_amount, overdue_days = _overdue_numbers(loan, row, today)
    row.update({
        'place': loan.place.name,
        'loan_date': loan.loan_date.strftime('%d/%m/%Y'),
        'loan_date_iso': loan.loan_date.isoformat(),
        'overdue_dues': overdue_dues,
        'overdue_amount': float(overdue_amount),
        'overdue_days': overdue_days,
        'view_url': f"{reverse(view_url_name)}?id={loan.id}",
    })
    return row


def _collect_rows(request, base_qs=None, view_url_name='admin:view_overdue_loan'):
    """Every overdue loan, then the search box / payment-type / place / loan-date filters."""
    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()
    place = request.GET.get('place', '').strip()

    qs = (
        (Loan.objects.all() if base_qs is None else base_qs)
        .exclude(status='completed')
        .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()
    rows = [r for r in (_overdue_row(loan, today, view_url_name) for loan in qs.order_by('-id')) if r]

    total = len(rows)                                   # before search / filters

    if payment_type in ('daily', 'weekly', 'monthly'):
        rows = [r for r in rows if r['payment_type'].lower() == payment_type]

    if search:
        rows = [
            r for r in rows
            if search in r['customer_name'].lower()
            or search in r['phone_number'].lower()
            or search in r['place'].lower()
            or search in r['payment_type'].lower()
            or search in r['loan_date'].lower()
        ]

    if start or end:
        rows = [r for r in rows if _in_range(r['loan_date_iso'], start, end)]
    return rows, total


# ------------------------------------------------------------- list page data
SORT_KEYS = {
    1: lambda r: r['loan_date_iso'],
    2: lambda r: r['customer_name'].lower(),
    3: lambda r: r['loan_amount'],
    4: lambda r: r['overdue_days'],
}


def admin_overdue_loan_data(request):
    """DataTables server-side endpoint for the Overdue Loans table."""
    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',
            )
        else:
            rows.sort(key=lambda r: r['overdue_days'], reverse=True)   # most late first

        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_overdue_loan_data failed')
        return JsonResponse({
            'draw': draw, 'recordsTotal': 0, 'recordsFiltered': 0, 'data': [],
            'error': 'Could not load overdue loans.',
        }, status=500)


OVERDUE_HEADERS = [
    'S.No', 'Loan Date', 'Customer Name', 'Phone', 'Place', 'Loan Amount',
    'Payment Type', 'Number of Dues', 'Due Amount', 'Overdue Dues',
    'Overdue Amount', 'Overdue Days', 'Next Due Date',
]


def overdue_xlsx(request, rows):
    """Excel of every overdue loan matching the current search / filters."""
    rows.sort(key=lambda r: r['overdue_days'], reverse=True)
    start, end = date_range(request)
    body = [[
        i, r['loan_date'], r['customer_name'], r['phone_number'], r['place'], r['loan_amount'],
        r['payment_type'], r['number_of_dues'], r['due_amount'], r['overdue_dues'],
        r['overdue_amount'], r['overdue_days'], r['next_due_date'],
    ] for i, r in enumerate(rows, start=1)]
    totals = (['Total', '', '', '', '', sum(r['loan_amount'] for r in rows), '', '', '', '',
               sum(r['overdue_amount'] for r in rows)] if rows else None)
    return xlsx_response('overdue_loans', 'Overdue Loans', OVERDUE_HEADERS, body,
                         subtitle=f'Loan date: {range_label(start, end)}', totals=totals)


def admin_overdue_loan_export(request):
    rows, _ = _collect_rows(request)
    return overdue_xlsx(request, rows)


# ---------------------------------------------------------- detail page
def admin_view_overdue_loan(request):
    """Page: /admin/view_overdue_loan/?id=<loan id>

    The payment table on this page is filled by the existing
    admin:paid_due_history_data endpoint, so only the summary cards are built here.
    """
    loan_id = request.GET.get('id', '').strip()
    if not loan_id.isdigit():
        return redirect('admin:overdue_loan')      # no id -> back to the list

    if not Loan.objects.filter(pk=int(loan_id)).exists():
        return redirect('admin:overdue_loan')      # wrong id -> back to the list

    loan = _loan_with_paid(int(loan_id))
    today = timezone.localdate()

    summary = _build_row(loan, today)
    overdue_dues, overdue_amount, overdue_days = _overdue_numbers(loan, summary, today)

    return render(request, 'adminpanel/view_overdue_loan.html', {
        'loan': loan,
        'summary': summary,
        'place_name': loan.place.name,
        'total_amount': float(loan.total_payable),
        'overdue_amount': float(overdue_amount),
        'overdue_dues': overdue_dues,
        'overdue_days': overdue_days,
    })
