import logging
import re

from datetime import datetime
from decimal import Decimal, InvalidOperation

from django.db import transaction
from django.db.models import Q
from django.http import JsonResponse
from django.contrib import messages
from django.shortcuts import redirect, render
from django.views.decorators.http import require_GET, require_POST

from NexusApp.models import LoanLead

logger = logging.getLogger(__name__)

# [0-9] instead of \d, because \d also matches non-ASCII digits (e.g. Arabic-Indic)
MOBILE_RE = re.compile(r'[6-9][0-9]{9}')
NAME_RE = re.compile(r"[A-Za-z][A-Za-z .'-]*")

LOAN_TYPES = dict(LoanLead.LOAN_TYPE_CHOICES)
SOURCES = dict(LoanLead.SOURCE_CHOICES)
STATUSES = dict(LoanLead.STATUS_CHOICES)
PAYMENT_TYPES = dict(LoanLead.PAYMENT_TYPE_CHOICES)

ID_RE = re.compile(r'[0-9]+')

MAX_LEN = {
    'name': 150,
    'place': 150,
    'source_details': 200,
    'agent_name': 150,
}


def _parse_date(value):
    try:
        return datetime.strptime(value, '%Y-%m-%d').date()
    except ValueError:
        return None


def _current_staff(request):
    """
    Staff details must come from the logged-in user, NOT from request.POST
    (anyone could post another staff's name/id). Adapt this to however your
    JWT/cookie auth exposes the user.
    """
    user = getattr(request, 'user', None)
    if user is not None and user.is_authenticated:
        return (user.get_full_name() or user.get_username()), str(user.pk)
    return '', ''


# 2. Store Lead Details
@require_POST
def store_leads(request):
    try:
        post = request.POST
        lead_date_raw = post.get('lead_date', '').strip()
        followup_raw = post.get('followup_date', '').strip()
        name = ' '.join(post.get('name', '').split())
        place = post.get('place', '').strip()
        phone = post.get('phone', '').strip()
        loan_type = post.get('loan_type', '').strip()
        loan_amount = post.get('loan_amount', '').strip()
        payment_type = post.get('payment_type', '').strip()
        source = post.get('source', '').strip()
        source_details = post.get('source_details', '').strip()
        agent_name = post.get('agent_name', '').strip()
        agent_mobile = post.get('agent_mobile', '').strip()
        purpose = post.get('purpose', '').strip()
        remarks = post.get('remarks', '').strip()

        errors = {}

        # ---- dates ----
        lead_date = _parse_date(lead_date_raw)
        followup_date = _parse_date(followup_raw)
        if not lead_date:
            errors['lead_date'] = 'Enter a valid lead date.'
        if not followup_date:
            errors['followup_date'] = 'Enter a valid follow-up date.'
        if lead_date and followup_date and followup_date < lead_date:
            errors['followup_date'] = 'Follow-up date cannot be before the lead date.'

        if not place:
            errors['place'] = 'Place is required.'

        if not loan_amount:
            errors['loan_amount'] = 'Loan amount is required.'
        else:
            try:
                amount = Decimal(loan_amount)
                if amount <= 0:
                    errors['loan_amount'] = 'Loan amount must be greater than zero.'
            except InvalidOperation:
                errors['loan_amount'] = 'Enter a valid loan amount.'

        # ---- name (elif: the "required" message must not be overwritten) ----
        if not name:
            errors['name'] = 'Customer name is required.'
        elif len(name) < 3:
            errors['name'] = 'Name must be at least 3 characters.'
        elif not NAME_RE.fullmatch(name):
            errors['name'] = "Name can contain only letters, spaces and . ' -"

        # ---- phone ----
        if not MOBILE_RE.fullmatch(phone):
            errors['phone'] = 'Enter a valid 10-digit mobile number.'

        # ---- loan ----
        if loan_type not in LOAN_TYPES:
            errors['loan_type'] = 'Select a valid loan type.'

        amount = None
        if loan_amount:
            try:
                amount = Decimal(loan_amount)
                if not amount.is_finite():          # rejects "NaN" / "Infinity"
                    raise InvalidOperation
                if amount <= 0:
                    errors['loan_amount'] = 'Loan amount must be greater than zero.'
                elif amount.as_tuple().exponent < -2:
                    errors['loan_amount'] = 'Loan amount can have at most 2 decimal places.'
                elif amount >= Decimal('10000000000'):   # max_digits=12, decimal_places=2
                    errors['loan_amount'] = 'Loan amount is too large.'
            except InvalidOperation:
                errors['loan_amount'] = 'Enter a valid loan amount.'

        if payment_type and payment_type not in PAYMENT_TYPES:
            errors['payment_type'] = 'Select a valid payment type.'

        # ---- source ----
        if source not in SOURCES:
            errors['source'] = 'Select a valid source.'
        elif source in ('reference', 'social_media', 'advertisement') and not source_details:
            errors['source_details'] = 'Please enter source details.'

        # ---- agent ----
        if agent_mobile and not MOBILE_RE.fullmatch(agent_mobile):
            errors['agent_mobile'] = 'Enter a valid agent mobile number.'
        if agent_mobile and not agent_name:
            errors['agent_name'] = 'Enter the agent name for this mobile number.'

        # ---- max lengths (otherwise the DB raises DataError -> 500) ----
        values = {'name': name, 'place': place,
                  'source_details': source_details, 'agent_name': agent_name}
        for field, limit in MAX_LEN.items():
            if len(values[field]) > limit and field not in errors:
                errors[field] = f'Maximum {limit} characters allowed.'

        if errors:
            return JsonResponse({'status': 'error', 'errors': errors}, status=422)

        staff_name, staff_id = _current_staff(request)

        with transaction.atomic():
            lead = LoanLead.objects.create(
                lead_date=lead_date,
                followup_date=followup_date,
                name=name,
                place=place,
                phone=phone,
                loan_type=loan_type,
                loan_amount=amount,
                payment_type=payment_type or None,
                source=source,
                source_details=source_details,
                status='active',          # new leads are ALWAYS Active (never trust POST)
                staff_name=staff_name,
                staff_id=staff_id,
                agent_name=agent_name,
                agent_mobile=agent_mobile,
                purpose=purpose,
                remarks=remarks,
            )

        return JsonResponse({
            'status': 'success',
            'message': 'Lead added successfully.',
            'lead_id': lead.id,
        })

    except Exception:
        logger.exception('Error while storing lead')
        return JsonResponse({
            'status': 'error',
            'message': 'Something went wrong while saving lead details.',
        }, status=500)


# 3. Loan Request Page View
def loan_request(request):
    return render(request, 'adminpanel/loan_request.html')


# 4. Get Loan Requests for DataTable (server-side processing, like Yajra)
# DataTables column "name" -> model field that is allowed to be sorted on
ORDERABLE = {
    'lead_date': 'lead_date',
    'customer': 'name',
    'staff': 'staff_name',
    'loan': 'loan_amount',
    'status': 'status',
}


def _label_keys(choices, term):
    """Choice keys whose label contains the search term (so 'active' / 'daily' / 'personal' are searchable)."""
    term = term.lower()
    return [key for key, label in choices if term in label.lower()]


@require_GET
def get_loan_requests(request):
    if request.headers.get('x-requested-with') != 'XMLHttpRequest':
        return JsonResponse({'status': 'error', 'message': 'Invalid request.'}, status=400)

    try:
        get = request.GET
        try:
            draw = int(get.get('draw', 1))
            start = max(int(get.get('start', 0)), 0)
            length = int(get.get('length', 10))
        except ValueError:
            return JsonResponse({'status': 'error', 'message': 'Invalid request.'}, status=400)
        length = 100 if length < 1 or length > 100 else length   # never return the whole table

        qs = LoanLead.objects.all()
        total = qs.count()

        # ---- search ----
        search = get.get('search[value]', '').strip()
        if search:
            q = (Q(name__icontains=search) | Q(phone__icontains=search) |
                 Q(place__icontains=search) | Q(staff_name__icontains=search) |
                 Q(staff_id__icontains=search))
            q |= Q(loan_type__in=_label_keys(LoanLead.LOAN_TYPE_CHOICES, search))
            q |= Q(payment_type__in=_label_keys(LoanLead.PAYMENT_TYPE_CHOICES, search))
            q |= Q(status__in=_label_keys(LoanLead.STATUS_CHOICES, search))
            qs = qs.filter(q)
        filtered = qs.count()

        # ---- ordering (whitelisted, never trust the column name blindly) ----
        order_by = ['-id']
        try:
            col_idx = int(get.get('order[0][column]', -1))
            field = ORDERABLE.get(get.get(f'columns[{col_idx}][name]', ''))
        except ValueError:
            field = None
        if field:
            prefix = '-' if get.get('order[0][dir]') == 'desc' else ''
            order_by = [prefix + field, '-id']
        qs = qs.order_by(*order_by)

        data = []
        for lead in qs[start:start + length]:
            data.append({
                'id': lead.id,
                'request_date': lead.lead_date.strftime('%d-%m-%Y') if lead.lead_date else '',
                'customer_name': lead.name,
                'mobile_number': lead.phone,
                'place': lead.place or '',
                'staff_name': lead.staff_name or '',
                'staff_id': lead.staff_id or '',
                # None (not '') so the frontend can tell "no amount" from 0
                'loan_amount': float(lead.loan_amount) if lead.loan_amount is not None else None,
                'payment_type': lead.get_payment_type_display() if lead.payment_type else '',
                'loan_type': lead.get_loan_type_display(),
                'status': lead.get_status_display(),   # Active / Confirmed
                'status_key': lead.status,             # active / confirmed
            })

        return JsonResponse({
            'draw': draw,
            'recordsTotal': total,
            'recordsFiltered': filtered,
            'data': data,
        })

    except Exception:
        logger.exception('Error while fetching loan requests')
        return JsonResponse({
            'draw': 0, 'recordsTotal': 0, 'recordsFiltered': 0, 'data': [],
            'status': 'error',
            'message': 'Unable to load loan requests.',
        }, status=500)


# 5. Confirm a lead (Active -> Confirmed)
@require_POST
def confirm_lead(request):
    lead_id = request.POST.get('id', '').strip()
    if not ID_RE.fullmatch(lead_id):
        return JsonResponse({'status': 'error', 'message': 'Invalid lead.'}, status=400)

    try:
        with transaction.atomic():
            # lock the row so a double click / two staff can't confirm twice
            lead = LoanLead.objects.select_for_update().get(pk=int(lead_id))

            if lead.status == 'confirmed':
                return JsonResponse({
                    'status': 'error',
                    'message': 'This lead is already confirmed.',
                }, status=409)

            lead.status = 'confirmed'
            lead.save(update_fields=['status', 'updated_at'])

        return JsonResponse({'status': 'success', 'message': 'Lead confirmed successfully.'})

    except LoanLead.DoesNotExist:
        return JsonResponse({'status': 'error', 'message': 'Lead not found.'}, status=404)
    except Exception:
        logger.exception('Error while confirming lead')
        return JsonResponse({
            'status': 'error',
            'message': 'Something went wrong while confirming the lead.',
        }, status=500)


# 6. View one lead (read-only details page)
def view_loan_request(request, lead_id):
    try:
        lead = LoanLead.objects.get(pk=lead_id)
    except LoanLead.DoesNotExist:
        messages.error(request, 'Lead not found.')
        return redirect('admin:loan_request')
    return render(request, 'adminpanel/view_loan_request.html', {'lead': lead})


# 7. Number of Active leads (sidebar badge)
@require_GET
def loan_request_count(request):
    return JsonResponse({
        'status': 'success',
        'count': LoanLead.objects.filter(status='active').count(),
    })