"""
Collection corrections with admin approval.

  staff  POST /staff/request_payment_edit/      -> creates a PaymentEditRequest (payment unchanged)
  admin  GET  /admin/payment_edit_requests/      -> page listing requests
  admin  GET  /admin/payment_edit_requests_data/ -> JSON for the table
  admin  POST /admin/review_payment_edit/        -> approve (applies the change) or reject
"""
import logging
from datetime import datetime
from decimal import Decimal, InvalidOperation

from django.db import transaction
from django.db.models import Sum
from django.http import JsonResponse
from django.shortcuts import render
from django.utils import timezone
from django.views.decorators.http import require_POST

from NexusApp.models import Loan, LoanPayment, PaymentEditRequest
from NexusApp.utils.staff_scope import staff_payments

logger = logging.getLogger(__name__)
ZERO = Decimal('0')


def _err(message, status=400, **extra):
    return JsonResponse({'status': 'error', 'message': message, **extra}, status=status)


def _sync_loan_status(loan):
    """Fully paid -> completed (closed on the last payment date), otherwise active."""
    paid = loan.payments.aggregate(s=Sum('amount'))['s'] or ZERO
    if paid >= loan.total_payable:
        last = loan.payments.order_by('-payment_date').first()
        loan.status, loan.closed_date = 'completed', last.payment_date if last else None
    else:
        loan.status, loan.closed_date = 'active', None
    loan.save(update_fields=['status', 'closed_date', 'updated_at'])


# ------------------------------------------------------------------ staff side
@require_POST
def request_payment_edit(request):
    staff = getattr(request, 'staff', None)
    payment_id = request.POST.get('payment_id', '').strip()
    if not payment_id.isdigit():
        return _err('Payment is missing.')

    payment = staff_payments(request, LoanPayment.objects.select_related('loan')).filter(
        pk=int(payment_id)).first()
    if payment is None:
        return _err('Payment not found.', 404)
    if payment.collected_by_id != getattr(staff, 'pk', None):
        return _err('You can only correct collections you entered.', 403)
    if payment.edit_requests.filter(status='pending').exists():
        return _err('A correction for this payment is already waiting for admin approval.', 409)

    errors = {}
    try:
        new_date = datetime.strptime(request.POST.get('payment_date', '').strip(), '%Y-%m-%d').date()
        if new_date > timezone.localdate():
            errors['payment_date'] = 'Payment date cannot be in the future.'
    except ValueError:
        new_date = None
        errors['payment_date'] = 'Enter a valid payment date.'

    try:
        new_amount = Decimal(request.POST.get('amount', '').strip())
        if not new_amount.is_finite() or new_amount <= 0 or new_amount != new_amount.quantize(Decimal('0.01')):
            raise InvalidOperation
    except InvalidOperation:
        new_amount = None
        errors['amount'] = 'Enter a valid positive amount (max 2 decimals).'

    method = request.POST.get('payment_method', '').strip().lower()
    if method not in dict(LoanPayment.METHOD_CHOICES):
        errors['payment_method'] = 'Select a payment method.'

    reason = ' '.join(request.POST.get('reason', '').split())
    if len(reason) < 5:
        errors['reason'] = 'Enter the reason for the correction (at least 5 characters).'
    elif len(reason) > 255:
        errors['reason'] = 'Reason cannot exceed 255 characters.'

    if not errors and new_date == payment.payment_date and new_amount == payment.amount \
            and method == payment.payment_method:
        errors['amount'] = 'Nothing changed.'

    if not errors:
        others = payment.loan.payments.exclude(pk=payment.pk).aggregate(s=Sum('amount'))['s'] or ZERO
        if others + new_amount > payment.loan.total_payable:
            errors['amount'] = (f'Amount is too high. Maximum for this payment is '
                                f'₹{payment.loan.total_payable - others:,.2f}.')

    if errors:
        return _err(next(iter(errors.values())), errors=errors)

    PaymentEditRequest.objects.create(
        payment=payment, requested_by=staff,
        old_payment_date=payment.payment_date, old_amount=payment.amount,
        old_payment_method=payment.payment_method,
        new_payment_date=new_date, new_amount=new_amount, new_payment_method=method,
        reason=reason,
    )
    logger.info('payment edit requested', extra={'payment_id': payment.pk})
    return JsonResponse({'status': 'success',
                         'message': 'Correction sent to admin. It will update after approval.'})


def pending_edit_map(payment_ids):
    """payment id -> latest request status, for the payment history tables."""
    out = {}
    for r in PaymentEditRequest.objects.filter(payment_id__in=payment_ids).order_by('created_at'):
        out[r.payment_id] = r.status
    return out


# ------------------------------------------------------------------ admin side
def payment_edit_requests(request):
    return render(request, 'adminpanel/payment_edit_requests.html')


def _fmt_method(code):
    return dict(LoanPayment.METHOD_CHOICES).get(code, code)


def payment_edit_requests_data(request):
    status = request.GET.get('status', 'pending').strip()
    qs = PaymentEditRequest.objects.select_related(
        'payment__loan__customer', 'payment__loan__place', 'requested_by')
    if status in dict(PaymentEditRequest.STATUS_CHOICES):
        qs = qs.filter(status=status)
    data = []
    for i, r in enumerate(qs, start=1):
        loan = r.payment.loan
        data.append({
            'sno': i,
            'id': r.pk,
            'loan_id': loan.pk,
            'customer': loan.customer.customer_name,
            'phone': loan.customer.phone_number,
            'place': loan.place.name,
            'staff': r.requested_by.name if r.requested_by else '-',
            'old_date': r.old_payment_date.strftime('%d %b %Y'),
            'new_date': r.new_payment_date.strftime('%d %b %Y'),
            'old_amount': float(r.old_amount),
            'new_amount': float(r.new_amount),
            'old_method': _fmt_method(r.old_payment_method),
            'new_method': _fmt_method(r.new_payment_method),
            'reason': r.reason,
            'status': r.get_status_display(),
            'admin_note': r.admin_note,
            'requested_at': timezone.localtime(r.created_at).strftime('%d %b %Y %I:%M %p'),
            'reviewed': (f"{r.reviewed_by} · {timezone.localtime(r.reviewed_at).strftime('%d %b %Y %I:%M %p')}"
                         if r.reviewed_at else ''),
        })
    return JsonResponse({'data': data,
                         'pending_count': PaymentEditRequest.objects.filter(status='pending').count()})


def payment_edit_requests_count(request):
    return JsonResponse({'count': PaymentEditRequest.objects.filter(status='pending').count()})


@require_POST
def review_payment_edit(request):
    req_id = request.POST.get('request_id', '').strip()
    action = request.POST.get('action', '').strip()
    note = ' '.join(request.POST.get('admin_note', '').split())[:255]
    if not req_id.isdigit() or action not in ('approve', 'reject'):
        return _err('Invalid request.')

    reviewer = getattr(request.user, 'email', '') or getattr(request.user, 'name', '') or 'admin'
    with transaction.atomic():
        r = PaymentEditRequest.objects.select_for_update().filter(pk=int(req_id)).first()
        if r is None:
            return _err('Request not found.', 404)
        if r.status != 'pending':
            return _err('This request was already reviewed.', 409)

        if action == 'approve':
            payment = LoanPayment.objects.select_for_update().get(pk=r.payment_id)
            loan = Loan.objects.select_for_update().get(pk=payment.loan_id)
            others = loan.payments.exclude(pk=payment.pk).aggregate(s=Sum('amount'))['s'] or ZERO
            if others + r.new_amount > loan.total_payable:
                return _err(f'Cannot approve: total paid would be more than the total payable '
                            f'(₹{loan.total_payable:,.2f}).')
            payment.payment_date = r.new_payment_date
            payment.amount = r.new_amount
            payment.payment_method = r.new_payment_method
            payment.save(update_fields=['payment_date', 'amount', 'payment_method'])
            _sync_loan_status(loan)

        r.status = 'approved' if action == 'approve' else 'rejected'
        r.admin_note = note
        r.reviewed_by = reviewer[:150]
        r.reviewed_at = timezone.now()
        r.save(update_fields=['status', 'admin_note', 'reviewed_by', 'reviewed_at'])

    logger.info('payment edit %s', r.status, extra={'request_id': r.pk})
    return JsonResponse({'status': 'success',
                         'message': 'Correction approved and the payment is updated.'
                         if action == 'approve' else 'Correction rejected.'})
