import logging
from django.contrib.auth.hashers import make_password
from django.db import transaction, IntegrityError
from django.shortcuts import redirect
from django.contrib import messages
from datetime import datetime
from django.http import JsonResponse
from decimal import Decimal, InvalidOperation
from NexusApp.utils.crypto import encrypt_password, decrypt_password
from NexusApp.models import AdminUser, Place, Staff
from django.shortcuts import render
from django.db.models import Count, Q
from django.urls import reverse
from django.utils.html import escape
from django.views.decorators.http import require_POST
from django.core.validators import validate_email
from django.core.exceptions import ValidationError


logger = logging.getLogger(__name__)


def _is_valid_email(value):
    try:
        validate_email(value)
        return True
    except ValidationError:
        return False


def _is_valid_salary(value):
    # Staff.salary is DecimalField(max_digits=10, decimal_places=2)
    try:
        amount = Decimal(value)
    except InvalidOperation:
        return False
    if not amount.is_finite() or amount < 0 or amount >= Decimal('100000000'):
        return False
    return amount.as_tuple().exponent >= -2


def _selected_places(request):
    ids = [v for v in request.POST.getlist('places') if v.strip().isdigit()]
    return list(Place.objects.filter(id__in=ids))


def storestaff(request):
    logger.info("Staff creation started", extra={'method': request.method})

    if request.method != 'POST':
            return JsonResponse({'status': 'error', 'message': 'Invalid request method.'}, status=400)

    last_staff = Staff.objects.all().order_by('id').last()
    if not last_staff or not last_staff.employee_id:
        employee_id = "EMP001"
    else:
        try:
            last_num = int(last_staff.employee_id.replace('EMP', ''))
            employee_id = f"EMP{last_num + 1:03d}"
        except ValueError:
            employee_id = "EMP001"

    # Extract form data matching your HTML 'name' attributes
    name = request.POST.get('name', '').strip()
    phone = request.POST.get('phone', '').strip()
    gender = request.POST.get('gender', '').strip().lower()
    date_of_birth = request.POST.get('date_of_birth', '').strip()
    address = request.POST.get('address', '').strip()
    joining_date = request.POST.get('joining_date', '').strip()
    salary = request.POST.get('salary', '').strip()
    email = request.POST.get('email', '').strip()
    staff_password = request.POST.get('password', '').strip()

    errors = {}

    # 1. Name validation (required, string, max 255)
    if not name:
        errors['name'] = "Name is required."
    elif len(name) > 255:
        errors['name'] = "Name cannot exceed 255 characters."

    # 2. Email validation (required, email format, min length 10, unique)
    if not email:
        errors['email'] = "Email is required."
    elif len(email) < 10:
        errors['email'] = "Email must be at least 10 characters long."
    elif not _is_valid_email(email):
        errors['email'] = "Enter a valid email address."
    elif Staff.objects.filter(email__iexact=email).exists():
        errors['email'] = "This email is already registered."

    # 3. Password validation (required, min length 6)
    if not staff_password:
        errors['password'] = "Password is required."
    elif len(staff_password) < 8:
        errors['password'] = "Password must be at least 8 characters long."

    # 4. Phone validation (required, exactly 10 digits)
    if not phone:
        errors['phone'] = "Phone number is required."
    elif not phone.isdigit() or len(phone) != 10:
        errors['phone'] = "Phone number must be exactly 10 digits."


    # 6. Gender validation (required, must be male or female)
    if not gender:
        errors['gender'] = "Gender is required."
    elif gender not in ['male', 'female','other']:
        errors['gender'] = "Invalid gender selection."

    if not salary:
        errors['salary'] = "Salary is required."
    elif not _is_valid_salary(salary):
        errors['salary'] = "Enter a valid salary amount."

    if not address:
        errors['address'] = "Address is required."

    if not date_of_birth:
        errors['date_of_birth'] = "Date of birth is required."
    else:
        try:
            # Assuming your HTML date picker sends format 'YYYY-MM-DD' 
            # (If your HTML sends 'DD-MM-YYYY', change the format string to '%d-%m-%Y')
            dob_date = datetime.strptime(date_of_birth, '%Y-%m-%d').date()
            
            if dob_date > datetime.today().date():
                errors['date_of_birth'] = "Date of birth cannot be in the future."
        except ValueError:
            errors['date_of_birth'] = "Invalid date format for date of birth."


    if not joining_date:
        errors['joining_date'] = "Joining date is required."
    else:
        try:
            # This automatically checks if it's a real date and handles 31-day/30-day months correctly
            datetime.strptime(joining_date, '%Y-%m-%d')
        except ValueError:
            errors['joining_date'] = "Invalid date format for joining date."


    if errors:
        logger.warning("Staff creation failed due to validation errors.", extra={'errors': errors})
        return JsonResponse({'status': 'error', 'errors': errors}, status=400)
    try:
        encrypted_password = encrypt_password(staff_password)
        with transaction.atomic():
            staff = Staff.objects.create(
                name=name,
                phone=phone,
                gender=gender,
                date_of_birth=date_of_birth if date_of_birth else None,
                address=address,
                employee_id=employee_id,
                joining_date=joining_date,
                salary=salary,
                email=email,
                password=encrypted_password,
                status='Active',
            )
            staff.places.set(_selected_places(request))
            logger.info('Staff record created successfully.', extra={'staff_id': staff.id})

        return JsonResponse({
                    'status': 'success', 
                    'message': 'Staff added successfully.', 
                    'redirect_url': '/admin/staff_list/'
                })
    except IntegrityError:
        logger.exception(
            "Staff creation failed due to database integrity error.",
            extra={
                'email': email,
                'employee_id': employee_id
            }
        )

        return JsonResponse({
            'status': 'error',
            'message': 'Email or Employee ID already exists.'
        }, status=400)

    except Exception:
        logger.exception(
            "Unexpected error occurred while creating staff."
        )

        return JsonResponse({
            'status': 'error',
            'message': 'Staff could not be added. Please try again.'
        }, status=500)

def view_staff(request):
    if request.headers.get('x-requested-with') != 'XMLHttpRequest':
        return JsonResponse({'status': 'error', 'message': 'Invalid request.'}, status=400)

    try:
        draw = int(request.GET.get('draw', 1))
        start = int(request.GET.get('start', 0))
        length = int(request.GET.get('length', 10))
        search = request.GET.get('search[value]', '').strip()

        data = Staff.objects.all().prefetch_related('places').annotate(
            collection_count=Count('collections')
        ).order_by('-id')
        records_total = data.count()

        if search:
            data = data.filter(
                Q(name__icontains=search)
                | Q(employee_id__icontains=search)
                | Q(phone__icontains=search)
                | Q(email__icontains=search)
                | Q(address__icontains=search)
                | Q(places__name__icontains=search)
            ).distinct()
        records_filtered = data.count()

        rows = data[start:] if length == -1 else data[start:start + length]

        result = []
        for index, row in enumerate(rows, start=start + 1):

            name = escape(row.name or '-')
            employee_id = escape(row.employee_id or '-')
            address = escape(row.address or '-')
            phone = escape(row.phone or '-')
            place_names = escape(', '.join(p.name for p in row.places.all()) or 'No location assigned')

            # Staff Details: name + employee id + address (designer layout)
            staff_details = f'''
                <div class="d-flex flex-column">
                    <span class="fw-semibold">{name}</span>
                    <small class="text-muted">{employee_id}</small>
                    <small class="text-secondary">
                        <i class="bi bi-geo-alt me-1"></i>
                        {address}
                    </small>
                    <small class="text-primary">
                        <i class="bi bi-pin-map me-1"></i>
                        {place_names}
                    </small>
                </div>'''

            # No. of Collections
            collection_count = row.collection_count
            collections_url = f"{reverse('admin:staff_collection_details')}?id={row.id}"
            collections = f'''
                <div class="d-flex align-items-center gap-2">
                    <span>{collection_count}</span>
                    <a href="{collections_url}" class="btn btn-outline-primary btn-sm">
                        <i class="bi bi-eye"></i>
                    </a>
                </div>'''

            joining = row.joining_date
            joining_date = joining.strftime('%d-%m-%Y') if hasattr(joining, 'strftime') else (joining or '-')

            # Status: label + toggle
            is_active = (row.status or '').lower() == 'active'
            status_label = 'Active' if is_active else 'Inactive'
            status_class = 'text-success' if is_active else 'text-danger'
            checked = 'checked' if is_active else ''
            status = f'''
                <div class="d-flex flex-column align-items-start gap-1">
                    <span class="status-label {status_class}">{status_label}</span>
                    <input type="checkbox"
                           class="status-toggle"
                           data-id="{row.id}"
                           {checked}
                           aria-label="Change staff status">
                </div>'''

            # Actions: edit + delete
            edit_url = reverse('admin:edit_staff', args=[row.id])
            action = f'''
                <div class="d-flex align-items-center gap-2">
                    <a href="{edit_url}" class="btn btn-warning btn-sm" title="Edit Staff">
                        <i class="bi bi-pencil-square"></i>
                    </a>
                    <button type="button"
                            class="btn btn-danger btn-sm delete-staff"
                            data-id="{row.id}"
                            data-bs-toggle="modal"
                            data-bs-target="#delete"
                            title="Delete Staff">
                        <i class="bi bi-trash"></i>
                    </button>
                </div>'''

            result.append({
                'DT_RowIndex': index,
                'staff_details': staff_details,
                'phone': phone,
                'collections': collections,
                'joining_date': joining_date,
                'status': status,
                'action': action,
            })

        return JsonResponse({
            'draw': draw,
            'recordsTotal': records_total,
            'recordsFiltered': records_filtered,
            'data': result,
        })

    except Exception:
        logger.exception('view_staff failed')
        return JsonResponse({
            'draw': 1, 'recordsTotal': 0, 'recordsFiltered': 0,
            'data': [], 'error': 'Could not load staff.',
        }, status=500)


@require_POST
def update_staff_status(request):
    staff_id = request.POST.get('id', '').strip()
    new_status = request.POST.get('status', '').strip().capitalize()

    if new_status not in ('Active', 'Inactive'):
        return JsonResponse({'status': 'error', 'message': 'Invalid status value.'}, status=400)

    try:
        staff = Staff.objects.get(id=staff_id)
    except (Staff.DoesNotExist, ValueError):
        return JsonResponse({'status': 'error', 'message': 'Staff not found.'}, status=404)

    try:
        staff.status = new_status
        staff.save(update_fields=['status'])
        logger.info('Staff status updated successfully.', extra={'staff_id': staff.id, 'new_status': new_status})
        return JsonResponse({
            'status': 'success',
            'message': f'Staff status updated to {new_status}.',
            'new_status': new_status,
        })
    except Exception:
        logger.exception('update_staff_status failed')
        return JsonResponse({'status': 'error', 'message': 'Could not update staff status. Please try again.'}, status=500)

def delete_staff(request):
    if request.method != 'POST':
        messages.error(request, "Invalid request method.")
        return redirect('admin:staff_list')

    staff_id = request.POST.get('id', '').strip()

    try:
        staff = Staff.objects.get(id=staff_id)
    except (Staff.DoesNotExist, ValueError):
        messages.error(request, "Staff not found.")
        return redirect('admin:staff_list')

    try:
        staff_name = staff.name
        staff.delete()
        logger.info('Staff deleted successfully.', extra={'staff_id': staff_id})
        messages.success(request, "Staff deleted successfully.")
    except Exception:
        logger.exception('delete_staff failed')
        messages.error(request, "Could not delete staff. Please try again.")

    return redirect('admin:staff_list')

def update_staff(request,staff_id):
    logger.info("staff updated started",extra={'method':request.method,'staff_id':staff_id})

    if request.method != 'POST':
        return JsonResponse({'status': 'error', 'message': 'Invalid request method.'}, status=400)

    try:
        staff=Staff.objects.get(id=staff_id)
    except(Staff.DoesNotExist,ValueError):
        logger.warning("staff update failed:staff not found.",extra={'staff_id':staff_id})
        return JsonResponse({'status':'error','message':'staff member not found.'},status=404)

    name=request.POST.get('name','').strip()
    phone=request.POST.get('phone','').strip()
    gender=request.POST.get('gender','').strip().lower()
    date_of_birth=request.POST.get('date_of_birth','').strip()
    address=request.POST.get('address','').strip()
    joining_date=request.POST.get('joining_date','').strip()
    salary=request.POST.get('salary','').strip()
    email=request.POST.get('email','').strip()
    staff_password=request.POST.get('password','').strip()

    errors={}

    if not name:
        errors['name']="name is required."
    elif len(name)>255:
        errors['name']="name cannot exceed 255 characters"

    if not email:
        errors['email']="email is required"
    elif len(email)<10:
        errors['email']="email must me at least 10 character long."
    elif not _is_valid_email(email):
        errors['email']="enter a valid email address."
    elif Staff.objects.filter(email__iexact=email).exclude(id=staff.id).exists():
        errors['email']="this email is already registereed by another staff"

    if staff_password and len(staff_password)<8:
        errors['password']="new password must be atleast 8 character long."

    if not phone:
        errors['phone']="phone number is  required"
    elif not phone.isdigit() or len(phone)!=10:
        errors['phone']="please enter a valid phone no"

    if not gender:
        errors['gender']="gender is required."
    elif gender not in ['male','female','other']:
        errors['gender']="invalid gender selection."

    if not salary:
        errors['salary']="salary is required"
    elif not _is_valid_salary(salary):
        errors['salary']="enter a valid salary amount."

    if not address:
        errors['address']="address is required"

    if not date_of_birth:
        errors['date_of_birth']="DOB is required."

    else:
        try:
            dob_date=datetime.strptime(date_of_birth,'%Y-%m-%d').date()
            if dob_date > datetime.today().date():
                errors['date_of_birth']="date of birth could not be in future."
        except ValueError:
             errors['date_of_birth']="invalid date format for date of birth."

    if not joining_date:
        errors['joining_date']="joining date is required"
    else:
        try:
            datetime.strptime(joining_date,'%Y-%m-%d')
        except ValueError:
            errors['joining_date']="invalid date format for joining date."

    if errors:
        logger.warning("staff update failed due to validation errors",extra={'errors':errors})
        return JsonResponse({'status':'error','errors':errors},status=400)

    try:
        with transaction.atomic():
            staff.name=name
            staff.phone=phone
            staff.gender=gender
            staff.date_of_birth=date_of_birth
            staff.address=address
            staff.joining_date=joining_date
            staff.salary=salary
            staff.email=email

            if staff_password:
                staff.password = encrypt_password(staff_password)

            staff.save()
            staff.places.set(_selected_places(request))
            logger.info('staff recorded updated successfully',extra={'staff_id':staff.id})

            return JsonResponse({
                'status':'success',
                'message':'staff updated successfully.',
                'redirect_url':'/admin/staff_list/'
            })
    except IntegrityError:
        logger.exception("staff update failed due to database integrity error",extra={'email':email})
        return JsonResponse({'status': 'error','message': 'Email or Employee ID already exists.'}, status=400)
    except Exception:
        logger.exception('unexpected error occour staff updated ')
        return JsonResponse({'status':'error','message':'staff could not be updated.please try again'},status=500)


@require_POST
def view_staff_password(request):
    staff_id = request.POST.get('id', '').strip()
    try:
        staff = Staff.objects.get(id=staff_id)
    except (Staff.DoesNotExist, ValueError):
        return JsonResponse({'status': 'error', 'message': 'Staff not found.'}, status=404)

    plain = decrypt_password(staff.password)
    if not plain:
        return JsonResponse({
            'status': 'error',
            'message': 'Password cannot be decrypted. Please type a new password and update.'
        }, status=400)

    return JsonResponse({'status': 'success', 'password': plain})

def staff_collection_data(request):
    """GET /admin/staff_collection_data/?id=<staff id> - every payment this staff collected."""
    from NexusApp.models import Loan, LoanPayment
    from controllers.Admin.AdminloanreportController import _history_rows

    staff_id = request.GET.get('id', '').strip()
    if not staff_id.isdigit():
        return JsonResponse({'data': []})
    staff_id = int(staff_id)

    mine = set(LoanPayment.objects.filter(collected_by_id=staff_id).values_list('id', flat=True))
    loans = Loan.objects.filter(payments__collected_by_id=staff_id)         .select_related('place', 'customer').distinct()

    result = []
    for loan in loans:
        due = loan.due_amount or Decimal('0')
        running = Decimal('0')
        for row in _history_rows(loan):       # ledger needs every payment of the loan
            before = running
            running += Decimal(str(row['paid_due_amount']))
            if row['id'] not in mine:
                continue
            due_number = int(before // due) + 1 if due > 0 else 1
            result.append({
                'name': loan.customer.customer_name,
                'place': loan.place.name,
                'phone': loan.customer.phone_number,
                'due_number': min(due_number, loan.number_of_dues),
                'paid_due_amount': row['paid_due_amount'],
                'payment_method': row['payment_method'],
                'payment_date': row['payment_date_iso'],
                'pending_amount': row['pending_amount'],
                'pending_cleared': row['pending_cleared'],
                'extra_amount': row['extra_amount'],
                'extra_cleared': 'Yes' if row['extra_amount'] > 0 else 'No',
            })
    result.sort(key=lambda r: r['payment_date'], reverse=True)
    for i, r in enumerate(result, start=1):
        r['sno'] = i
    return JsonResponse({'data': result})
