from django.shortcuts import render
from django.urls import reverse
from NexusApp.models import Place
from NexusApp.models import Loan, Customer
from django.db.models import Sum, Value, DecimalField
from django.db.models.functions import Coalesce
from NexusApp.models import LoanPayment
from decimal import Decimal
from NexusApp.models.attendance_model import AttendanceMaster
from django.shortcuts import get_object_or_404, redirect, render
from django.utils import timezone
from NexusApp.models.checkin_model import StaffCheckIn
from NexusApp.utils.staff_scope import get_staff_loan_or_404, get_staff_place_or_404

# STAFF PANEL

def login(request):
    return render(request, 'staffpanel/login.html')

def forgot_password(request):
    return render(request, 'staffpanel/forgot_password.html')

def new_password(request):
    return render(request, 'staffpanel/new_password.html')

def reset_password(request):
    return render(request, 'staffpanel/reset_password.html')


def dashboard(request):
    from NexusApp.utils.loan_stats import inr, portfolio_summary
    from NexusApp.utils.staff_scope import staff_customers, staff_loans, staff_places

    # Computed on every request (a module-level value would stay stuck on
    # the day the server started).
    today = timezone.localdate()
    staff = request.staff
    money = DecimalField(max_digits=14, decimal_places=2)

    today_checkin = StaffCheckIn.objects.filter(staff=staff, check_in_date=today).first()
    already_checked_in = today_checkin is not None

    active_attendance_master = AttendanceMaster.objects.filter(is_active=True).first()

    summary = portfolio_summary(staff_loans(request), today)
    total_customers = staff_customers(request).count()
    active_customers = staff_customers(request).filter(
        loans__status='active', loans__place__in=staff_places(request)).distinct().count()

    my_payments = LoanPayment.objects.filter(collected_by=staff)
    zero = Value(Decimal('0.00'))
    total_collection = my_payments.aggregate(
        t=Coalesce(Sum('amount'), zero, output_field=money))['t']
    today_payments = my_payments.filter(payment_date=today)
    today_collection = today_payments.aggregate(
        t=Coalesce(Sum('amount'), zero, output_field=money))['t']
    month_collection = my_payments.filter(
        payment_date__year=today.year, payment_date__month=today.month
    ).aggregate(t=Coalesce(Sum('amount'), zero, output_field=money))['t']

    # progress = loans collected today out of (collected today + still due today/overdue)
    dues_collected_today = today_payments.values('loan_id').distinct().count()
    progress_base = dues_collected_today + summary['due_today'] + summary['overdue_loans']
    collection_progress = int(round(dues_collected_today * 100 / progress_base)) if progress_base else 0

    recent = [
        {
            'id': p.id,
            'loan_id': p.loan_id,
            'customer_name': p.loan.customer.customer_name,
            'amount': float(p.amount),
            'date': p.payment_date.strftime('%d-%m-%Y'),
            'url': f"{reverse('staff:paid_due_history')}?id={p.loan_id}",
        }
        for p in my_payments.select_related('loan__customer').order_by('-payment_date', '-id')[:20]
    ]

    context = {
        'total_customers': total_customers,
        'active_customers': active_customers,
        'inactive_customers': max(total_customers - active_customers, 0),
        'new_loans_month': staff_loans(request).filter(
            loan_date__year=today.year, loan_date__month=today.month).count(),
        'active_loans': summary['active_loans'],
        'completed_loans': summary['completed_loans'],
        'my_collection': inr(total_collection),
        'today_collection': inr(today_collection),
        'month_collection': inr(month_collection),
        'dues_collected_today': dues_collected_today,
        'upcoming_dues': summary['upcoming_dues'] + summary['due_today'],
        'overdue_customers': summary['overdue_customers'],
        'overdue_amount': inr(summary['overdue_amount']),
        'collection_progress': min(collection_progress, 100),
        'recovery_rate': min(summary['recovery_rate'], 100),
        'recent_collections': recent,
        'assigned_places': list(staff_places(request).values_list('name', flat=True)),
        'active_attendance_master': active_attendance_master,
        'already_checked_in': already_checked_in,
        'today_checkin': today_checkin,
    }

    return render(request, 'staffpanel/dashboard.html', context)


# CUSTOMER MANAGEMENT

def customer_management(request):
    return render(request, 'staffpanel/customer_management.html')

def payment_history(request):
    loan_id = request.GET.get('id', '').strip()
    if loan_id.isdigit():
        return redirect(f"{reverse('staff:paid_due_history')}?id={loan_id}")
    return redirect('staff:customer_management')

def edit_customer(request):
    return render(request, 'staffpanel/edit_customer.html')



# LOAN MANAGEMENT


def add_loan(request):
    from NexusApp.utils.staff_scope import staff_customers, staff_places
    return render(request, 'staffpanel/add_loan.html', {
        'places': list(staff_places(request).values_list('name', flat=True)),
        'referral_names': list(
            staff_customers(request).exclude(referral_name__isnull=True).exclude(referral_name='')
            .order_by('referral_name').values_list('referral_name', flat=True).distinct()
        ),
    })

def loan_management(request):
    # old mock-up page; Loan Registers is the staff loan home
    return redirect('staff:loan_registers')

def loan_registers(request):
    return render(request, 'staffpanel/loan_registers.html')


def loan_entries(request):
    return render(request, 'staffpanel/loan_entries.html')


def loan_reports(request, place_id):
    place = get_staff_place_or_404(request, place_id)
    return render(request, 'staffpanel/loan_reports.html', {
        'place_name': place.name,
    })

def paid_due_history(request):
    return render(request, 'staffpanel/paid_due_history.html')

def completed_loan(request):
    return render(request, 'staffpanel/completed_loan.html')

def view_customer_details(request):
    """?id=<latest loan id of the customer> (from the customer list)."""
    from NexusApp.utils.staff_scope import staff_loans
    loan_id = request.GET.get('id', '').strip()
    selected = staff_loans(request, Loan.objects.select_related('customer', 'place')) \
        .filter(pk=loan_id).first() if loan_id.isdigit() else None
    if selected is None:
        return redirect('staff:customer_management')

    customer = selected.customer
    loans = staff_loans(request, customer.loans.select_related('place')).order_by('-id')
    customer.place = selected.place.name
    aadhaar = customer.aadhaar_number or ''
    return render(request, 'staffpanel/view_customer_details.html', {
        'customer': customer,
        'loans': loans,
        'total_loans': loans.count(),
        'masked_aadhaar': ('XXXX XXXX ' + aadhaar[-4:]) if len(aadhaar) == 12 else '-',
        'aadhaar_photo_url': customer.aadhaar_photo.url if customer.aadhaar_photo else '',
    })


def view_loan_entry(request):
    # detail pages all show the same real loan view (summary + payments)
    loan_id = request.GET.get('id', '').strip()
    if loan_id.isdigit():
        return redirect('staff:view_place_loan', loan_id=int(loan_id))
    return redirect('staff:loan_registers')

def view_completed_loan(request):
    # detail pages all show the same real loan view (summary + payments)
    loan_id = request.GET.get('id', '').strip()
    if loan_id.isdigit():
        return redirect('staff:view_place_loan', loan_id=int(loan_id))
    return redirect('staff:loan_registers')

def place_completed_loan(request, place_id):
    place = get_staff_place_or_404(request, place_id)
    return render(request, 'staffpanel/place_completed_loan.html',
                  {'place': place.name, 'place_id': place.id})

def view_place_loan(request, loan_id):
    loan = get_staff_loan_or_404(request, loan_id, Loan.objects.select_related('place', 'customer'))
    payments = [
        {
            'sno': i,
            'payment_date': p.payment_date.isoformat(),
            'amount': float(p.amount),
            'payment_method': p.get_payment_method_display(),
        }
        for i, p in enumerate(loan.payments.all(), start=1)
    ]
    return render(request, 'staffpanel/view_place_loan.html', {
        'loan': loan,
        'place_name': loan.place.name,
        'payments': payments,
    })

def overdue_loan(request):
    return render(request, 'staffpanel/overdue_loan.html')

def view_overdue_loan(request):
    return render(request, 'staffpanel/view_overdue_loan.html')

def view_loan_report(request):
    # detail pages all show the same real loan view (summary + payments)
    loan_id = request.GET.get('id', '').strip()
    if loan_id.isdigit():
        return redirect('staff:view_place_loan', loan_id=int(loan_id))
    return redirect('staff:loan_registers')

def edit_loan(request):
    return render(request, 'staffpanel/edit_loan.html')

def today_collections(request):
    return render(request, 'staffpanel/today_collections.html')

def collection_list(request):
    return render(request, 'staffpanel/collection_list.html')

# PAYMENT MANAGEMENT


def attendence(request):
    """My Attendance: this month's check-ins of the logged-in staff member."""
    from datetime import timedelta
    today = timezone.localdate()
    month_start = today.replace(day=1)
    master = AttendanceMaster.objects.filter(is_active=True).first()
    working_days = set((master.working_days if master else None) or
                       ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'])

    from controllers.Admin.AdminattendanceController import checkin_locations
    checkins = list(StaffCheckIn.objects.filter(staff=request.staff).order_by('-check_in_date'))
    month = [c for c in checkins if c.check_in_date >= month_start]
    present = len(month)
    late = sum(1 for c in month if c.status == 'late')

    expected = 0
    d = month_start
    while d <= today:
        if d.strftime('%A') in working_days:
            expected += 1
        d += timedelta(days=1)

    rows = [{
        'id': i,
        'date': c.check_in_date.isoformat(),
        'check_in': timezone.localtime(c.check_in_time).strftime('%I:%M %p'),
        'check_out': timezone.localtime(c.check_out_time).strftime('%I:%M %p') if c.check_out_time else '-',
        'working_hours': c.working_hours_label if c.check_out_time else
                         ('Not checked out' if c.check_in_date < today else 'Working'),
        **checkin_locations(c),
        'late_minutes': c.late_minutes,
        'reason': c.late_reason or '-',
        'status': 'Late' if c.status == 'late' else 'Present',
    } for i, c in enumerate(checkins, start=1)]

    return render(request, 'staffpanel/attendence.html', {
        'present_days': present,
        'absent_days': max(expected - present, 0),
        'late_days': late,
        'on_time_days': present - late,
        'on_time_rate': int(round((present - late) * 100 / present)) if present else 0,
        'attendance_rows': rows,
        'today_checkin': next((c for c in checkins if c.check_in_date == today), None),
        'active_attendance_master': master,
    })

# def payment_invoice(request):
#     return render(request, 'staffpanel/payment_invoice.html')

