import json
import logging
import os
from datetime import timedelta
from openpyxl import Workbook
from openpyxl import load_workbook as openpyxl_load_workbook
from django.conf import settings
from django.contrib.auth import logout, login
from django.contrib.auth import authenticate
from django.contrib.auth.decorators import login_required
from django.core.exceptions import ValidationError
from django.core.validators import validate_email
from django.db.models import Q
from django.http import HttpResponse, JsonResponse
from django.shortcuts import get_object_or_404, render, redirect
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods
from django.utils import timezone
from django.contrib import messages
from .models import RSVP, Accreditation, Invite
from .utils import send_invitation_email, send_confirmation_email, merge_qr_with_invite, send_whatsapp_message, send_invite_message
logger = logging.getLogger(__name__)

# Index
def index(request):
    return render(request, 'public/index.html')

# Submit RSVP
@csrf_exempt
def submit_rsvp(request):
    try:
        if request.method == 'POST':
            try:
                data = json.loads(request.body)
            except json.JSONDecodeError:
                data = request.POST

            full_name = (data.get('full_name') or '').strip()
            email = (data.get('email') or '').strip()
            phone = (data.get('phone') or '').strip()
            guests = data.get('guests', '1')
            which_event = (data.get('which_event') or '').strip()
            
            if RSVP.objects.filter(email=email).exists():
                return JsonResponse({'status': 'error', 'message': 'Email is already registered.'}, status=400)
            
            try:
                validate_email(email)
            except ValidationError:
                return JsonResponse({'status': 'error', 'message': 'Please enter a valid email address'}, status=400)

            guest = RSVP(
                full_name=full_name,
                email=email,
                phone=phone,
                guests=guests,
                which_event=which_event,
            )
            
            guest.save()
            
            try:
                send_confirmation_email(guest)
            except Exception as e:
                logger.error(f"Failed to send confirmation email: {str(e)}")
            
            return JsonResponse({'status': 'success', 'message': 'RSVP submitted successfully'})
        
        return JsonResponse({'status': 'error', 'message': 'Invalid request method'})
    except Exception as e:
        logger.error(f"Error in submit_rsvp: {str(e)}")
        return JsonResponse({'status': 'error', 'message': f'Server error: {str(e)}'}, status=500)

# Accreditation
@login_required
def accreditation(request):
    return render(request, 'public/accreditation.html')

# Search guests
def search_guests(request):
    """Search for guests by first name or last name prefix"""
    if request.method == 'GET':
        query = request.GET.get('q', '').strip()

        if len(query) >= 2:
            rsvp_results = RSVP.objects.filter(full_name__icontains=query).order_by('full_name')

            ticket_list = []

            # Get today's accreditations
            today = timezone.now().date()
            tomorrow = today + timedelta(days=1)
            rsvp_accreditations = {
                acc.rsvp_id: acc.time.strftime('%I:%M %p')
                for acc in Accreditation.objects.filter(
                    rsvp__in=rsvp_results,
                    date__gte=today,
                    date__lt=tomorrow,
                    is_accredited=True
                ).select_related('rsvp')
            }

            # Process RSVP results
            for rsvp in rsvp_results:
                ticket_list.append({
                    'id': rsvp.id,
                    'name': rsvp.full_name,
                    'email': rsvp.email,
                    'phone': rsvp.phone,
                    'guests': rsvp.guests or '1',
                    'is_accredited': rsvp.id in rsvp_accreditations,
                    'accredit_time': rsvp_accreditations.get(rsvp.id, ''),
                })

            return JsonResponse({'tickets': ticket_list})
        else:
            return JsonResponse({'tickets': []})

    return JsonResponse({'status': 405, 'message': 'Method Not Allowed!'})

def activity_log(request):
    """Return the last 20 accreditation events from the database."""
    if request.method != 'GET':
        return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)
    today = timezone.now().date()
    tomorrow = today + timedelta(days=1)
    events = []
    rows = Accreditation.objects.filter(
        date__gte=today,
        date__lt=tomorrow,
        is_accredited=True
    ).select_related('rsvp').order_by('-date', '-time')[:20]
    for a in rows:
        events.append({
            'name': a.rsvp.full_name if a.rsvp else 'Unknown',
            'guests': a.rsvp.guests if (a.rsvp and a.rsvp.guests) else '1',
            'time': a.time.strftime('%I:%M %p'),
            'ok': True,
        })
    return JsonResponse({'events': events})

# Check in
@csrf_exempt
def check_in(request):
    if request.method == 'POST':
        data       = request.POST.get('name')
        ticket_num = request.POST.get('ticket_number')
        quantity_str = request.POST.get('quantity')

        # Accept either 'name' (text search) or 'ticket_number' (QR scan)
        lookup_value = ticket_num or data

        if not lookup_value:
            return JsonResponse({'status': 400, 'message': 'Please provide guest name or QR code ID'})

        # Look up RSVP by name or ticket_number
        rsvp = RSVP.objects.filter(
            Q(full_name__iexact=data) | Q(ticket_number__iexact=lookup_value)
        ).first()

        if not rsvp:
            return JsonResponse({'status': 404, 'message': 'RSVP not found'})

        # Handle RSVP check-in
        if rsvp:
            today = timezone.now().date()
            tomorrow = today + timedelta(days=1)
            existing_accreditation = Accreditation.objects.filter(
                rsvp=rsvp,
                is_accredited=True,
                date__gte=today,
                date__lt=tomorrow
            ).first()

            if quantity_str:
                if existing_accreditation:
                    return JsonResponse({
                        'status': 400,
                        'message': 'This RSVP has already been checked in today',
                        'is_already_accredited': True,
                        'rsvp_id': rsvp.id,
                        'accredit_time': existing_accreditation.time.strftime('%I:%M %p'),
                        'guest': {
                            'name': rsvp.full_name,
                            'email': rsvp.email,
                            'phone': rsvp.phone,
                            'rsvp_id': rsvp.id,
                            'guests': rsvp.guests or '1',
                        }
                    })

                Accreditation.objects.create(
                    rsvp=rsvp,
                    is_accredited=True
                )

                return JsonResponse({
                    'status': 200,
                    'message': 'RSVP checked in successfully',
                    'is_already_accredited': False,
                    'guest': {
                        'name': rsvp.full_name,
                        'email': rsvp.email,
                        'phone': rsvp.phone,
                        'rsvp_id': rsvp.id,
                        'guests': rsvp.guests or '1',
                    }
                })
            else:
                ticket_info = {
                    'name':     rsvp.full_name,
                    'email':    rsvp.email,
                    'phone':    rsvp.phone,
                    'rsvp_id':  rsvp.id,
                    'guests':   rsvp.guests or '1',
                    'current_date': timezone.now().strftime('%Y-%m-%d')
                }
                return JsonResponse({'status': 200, 'ticket': ticket_info})

    return JsonResponse({'status': 405, 'message': 'Method not allowed'})

def unaccredit(request):
    """Remove accreditation for a guest (revoke their check-in)."""
    if request.method != 'POST':
        return JsonResponse({'status': 405, 'message': 'Method not allowed'})

    rsvp_id = request.POST.get('rsvp_id')
    if not rsvp_id:
        return JsonResponse({'status': 400, 'message': 'Missing rsvp_id'})

    rsvp = RSVP.objects.filter(id=rsvp_id).first()
    if not rsvp:
        return JsonResponse({'status': 404, 'message': 'RSVP not found'})

    Accreditation.objects.filter(rsvp=rsvp, is_accredited=True).delete()

    return JsonResponse({'status': 200, 'message': rsvp.full_name + ' has been unaccredited.'})

# Send QR Code
@login_required
def send_qr_code(request):
    if request.method == 'POST':
        rsvp_id = request.POST.get('rsvp_id')

        if not rsvp_id:
            return JsonResponse({'status': 400, 'message': "RSVP ID is required"}, status=400)

        try:
            guest = RSVP.objects.get(pk=rsvp_id)
            
            try:
                if guest.email:
                    email = send_invitation_email(guest)
                    
                content_sid = "HX368305c4de177d5f3db3da5cd2a7556f"
            
                if guest.phone:
                    whatsapp = send_whatsapp_message(guest, content_sid)
                
                if email or whatsapp:
                    guest.is_sent = True
                    guest.save()
                
                return JsonResponse({'status': 200, 'message': 'QR code sent successfully!'})

            except Exception as e:
                logger.error(f"Error submitting RSVP: {str(e)}")
                return JsonResponse({'status': 400, 'message': str(e)})
            
        except RSVP.DoesNotExist:
            return JsonResponse({'status': 404, 'message': 'RSVP not found'}, status=404)
        
        except Exception as e:
            return JsonResponse({'status': 500, 'message': f'Error sending QR code: {str(e)}'}, status=500)
        
    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

# Send Bulk QR Codes
@login_required
@csrf_exempt
def send_bulk_qr_codes(request):
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
        except json.JSONDecodeError:
            return JsonResponse({'status': 400, 'message': "Invalid JSON data"}, status=400)
        rsvp_ids = data.get('rsvp_ids', [])

        if not rsvp_ids:
            return JsonResponse({'status': 400, 'message': "No RSVP IDs provided"}, status=400)

        sent_count = 0
        failed_rsvps = []

        for rsvp_id in rsvp_ids:
            try:
                guest = RSVP.objects.get(pk=rsvp_id)
              
                try:
                    if guest.email:
                        email = send_invitation_email(guest)

                    content_sid = "HX368305c4de177d5f3db3da5cd2a7556f"
                    
                    if guest.phone:
                        whatsapp = send_whatsapp_message(guest,content_sid)
                    
                    if email or whatsapp:
                        guest.is_sent = True
                        guest.save()
                        sent_count += 1
                    
                except Exception as e:
                    logger.error(f"Error submitting RSVP: {str(e)}")
                    failed_rsvps.append(f"RSVP ID {rsvp_id} (error: {str(e)})")

            except RSVP.DoesNotExist:
                failed_rsvps.append(f"RSVP ID {rsvp_id} (not found)")
            except Exception as e:
                failed_rsvps.append(f"RSVP ID {rsvp_id} (error: {str(e)})")

        message = f"QR codes sent to {sent_count} RSVP attendee(s)."
        if failed_rsvps:
            message += f" Failed for: {', '.join(failed_rsvps)}."

        return JsonResponse({'status': 200, 'message': message, 'sent_count': sent_count})

    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

# Dashboard
@login_required
def dashboard(request):
    guests = RSVP.objects.all()
    context = { 'guests': guests }
    return render(request, 'dashboard/dashboard.html', context)

# Accredited
@login_required
def accredited(request):
    accredited = Accreditation.objects.prefetch_related('rsvp').all().order_by('-date')
    context = {'guests': accredited}
    return render(request, 'dashboard/accredited.html', context)

# Delete RSVP
@login_required
@csrf_exempt
@require_http_methods(["DELETE"])
def delete_rsvp(request, rsvp_id):
    try:
        rsvp = get_object_or_404(RSVP, id=rsvp_id)
        rsvp.delete()
        return JsonResponse({'success': True, 'message': 'RSVP deleted successfully'})
    except Exception as e:
        logger.error(f'Error deleting RSVP {rsvp_id}: {str(e)}')
        return JsonResponse({'success': False, 'message': str(e)}, status=500)

# Edit RSVP
@login_required
@csrf_exempt
@require_http_methods(["POST"])
def edit_rsvp(request, rsvp_id):
    try:
        rsvp = get_object_or_404(RSVP, id=rsvp_id)
        
        # Parse the request data
        data = json.loads(request.body)
        
        rsvp.full_name = data.get('full_name', rsvp.full_name)
        rsvp.email = data.get('email', rsvp.email)
        rsvp.phone = data.get('phone', rsvp.phone)
        # rsvp.guests = data.get('guests', rsvp.guests)
        
        # Validate email format
        try:
            validate_email(rsvp.email)
        except ValidationError:
            return JsonResponse({
                'success': False,
                'message': 'Please enter a valid email address'
            }, status=400)
        
        # Save the updated RSVP
        rsvp.save()
        
        return JsonResponse({'success': True, 'message': 'RSVP updated successfully'})
    except RSVP.DoesNotExist:
        return JsonResponse({'success': False, 'message': 'RSVP not found'}, status=404)
    except json.JSONDecodeError:
        return JsonResponse({'success': False, 'message': 'Invalid JSON data'}, status=400)
    except Exception as e:
        logger.error(f'Error updating RSVP {rsvp_id}: {str(e)}')
        return JsonResponse({'success': False, 'message': str(e)}, status=500)

# Reset RSVP Status
@login_required
def reset_rsvp_status(request):
    if request.method == 'POST':
        RSVP.objects.filter(is_sent=True).update(is_sent=False)
        return JsonResponse({'status': 200, 'message': 'Status has been reset.'})
    return JsonResponse(
        {'status': 405, 'message': 'Method not allowed'},
        status=405
    )

# Login
def login_view(request):
    if request.user.is_authenticated:
        return _postLoginRedirect(request.user)
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        
        if username and password:
            user = authenticate(request, username=username, password=password)
            if user is not None:
                if user.is_staff:
                    login(request, user)
                    return _postLoginRedirect(user)
                else:
                    messages.error(request, "You do not have permission to access this dashboard.")
            else:
                messages.error(request, "Invalid credentials.")
        else:
            messages.error(request, "Invalid credentials.")

    return render(request, 'public/login.html')

def _postLoginRedirect(user):
    """Redirect staff users based on username domain.
       @accredit.com  →  accreditation page (QR scanner)
       anything else  →  dashboard
    """
    if user.username.lower().endswith('@accredit.com'):
        return redirect('accreditation')
    return redirect('dashboard')

# Logout
@login_required
def logout_view(request):
    logout(request)
    return redirect('login')

# Create Access Cards
@login_required
def create_accesscard(request):
    if request.method == 'GET':
        qr_codes_dir = os.path.join(settings.MEDIA_ROOT, 'qr_codes')
        accesscards_dir = os.path.join(settings.MEDIA_ROOT, 'access')
        card_path = os.path.join(settings.MEDIA_ROOT, 'card.png')

        if not os.path.exists(card_path):
            return JsonResponse({'status': 400, 'message': 'card.png not found in media directory'})

        os.makedirs(accesscards_dir, exist_ok=True)

        processed_count = 0
        failed_files = []

        for filename in os.listdir(qr_codes_dir):
            if filename.endswith('.png'):
                qr_path = os.path.join(qr_codes_dir, filename)
                output_path = os.path.join(accesscards_dir, filename)
                try:
                    merge_qr_with_invite(card_path, qr_path, output_path)
                    processed_count += 1
                except Exception as e:
                    failed_files.append(f"{filename}: {str(e)}")

        message = f"Processed {processed_count} access cards."
        if failed_files:
            message += f" Failed: {', '.join(failed_files)}"

        return JsonResponse({'status': 200, 'message': message, 'processed': processed_count})

    return JsonResponse({'status': 405, 'message': 'Method not allowed'})

# Export Invites
@login_required
def export_invites(request):
    """Export all invites to Excel"""
    wb = Workbook()
    ws = wb.active
    ws.title = "Invites"

    headers = ["Name", "Email", "Phone", "Invite Status", "Created At"]
    ws.append(headers)

    for invite in Invite.objects.all().order_by('-created_at'):
        row = [
            invite.name,
            invite.email or "",
            invite.phone or "",
            "Yes" if invite.is_invited else "No",
            invite.created_at.strftime("%Y-%m-%d %H:%M")
        ]
        ws.append(row)

    response = HttpResponse(content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
    current_date = timezone.now().date()
    filename = f"Oba_Xperience_Invites_{current_date}.xlsx"
    response['Content-Disposition'] = f'attachment; filename={filename}'
    wb.save(response)
    return response

# Invite Management
@login_required
def list_invites(request):
    """List all invites"""
    invites = Invite.objects.all()
    total_invites = invites.count()
    invited_count = invites.filter(is_invited=True).count()
    context = {
        'invites': invites,
        'total_invites': total_invites,
        'invited_count': invited_count,
    }
    return render(request, 'dashboard/invite.html', context)

@login_required
@csrf_exempt
def add_invite(request):
    """Add a single invite"""
    if request.method == 'POST':
        try:
            # Parse request body
            if not request.body:
                return JsonResponse({'success': False, 'message': 'Request body is empty'}, status=400)
            
            try:
                data = json.loads(request.body)
            except json.JSONDecodeError as e:
                logger.error(f"JSON decode error in add_invite: {str(e)}")
                logger.error(f"Request body: {request.body}")
                return JsonResponse({'success': False, 'message': 'Invalid JSON format'}, status=400)
            
            name = (data.get('name') or '').strip()
            email = (data.get('email') or '').strip() or None
            phone = (data.get('phone') or '').strip() or None

            if not name:
                return JsonResponse({'success': False, 'message': 'Name is required'}, status=400)

            # Check if email already exists (if provided)
            if email and Invite.objects.filter(email=email).exists():
                return JsonResponse({'success': False, 'message': 'An invite with this email already exists'}, status=400)

            # Check if phone already exists (if provided)
            if phone and Invite.objects.filter(phone=phone).exists():
                return JsonResponse({'success': False, 'message': 'An invite with this phone number already exists'}, status=400)

            invite = Invite.objects.create(
                name=name,
                email=email,
                phone=phone,
            )

            return JsonResponse({
                'success': True,
                'message': 'Invite added successfully',
                'invite': {
                    'id': invite.id,
                    'name': invite.name,
                    'email': invite.email,
                    'phone': invite.phone,
                    'is_invited': invite.is_invited,
                    'created_at': invite.created_at.strftime('%Y-%m-%d %H:%M'),
                }
            })
        except Exception as e:
            logger.error(f"Error in add_invite: {str(e)}", exc_info=True)
            return JsonResponse({'success': False, 'message': f'Server error: {str(e)}'}, status=400)
    else:
        return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

@login_required
@csrf_exempt
def edit_invite(request, invite_id):
    """Edit an invite"""
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
            invite = Invite.objects.get(id=invite_id)

            name = (data.get('name') or '').strip()
            email = (data.get('email') or '').strip() or None
            phone = (data.get('phone') or '').strip() or None

            if name:
                invite.name = name
            if email is not None:
                invite.email = email
            if phone is not None:
                invite.phone = phone

            invite.save()
            return JsonResponse({'success': True, 'message': 'Invite updated successfully'})
        except Invite.DoesNotExist:
            return JsonResponse({'success': False, 'message': 'Invite not found'}, status=404)
        except Exception as e:
            return JsonResponse({'success': False, 'message': str(e)}, status=400)
    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

@login_required
@csrf_exempt
def delete_invite(request, invite_id):
    """Delete an invite"""
    if request.method == 'DELETE':
        try:
            invite = Invite.objects.get(id=invite_id)
            invite.delete()
            return JsonResponse({'success': True, 'message': 'Invite deleted successfully'})
        except Invite.DoesNotExist:
            return JsonResponse({'success': False, 'message': 'Invite not found'}, status=404)
    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

@login_required
@csrf_exempt
def send_invite(request, invite_id):
    """Send invite (email and/or WhatsApp) to a single invite"""
    if request.method == 'POST':
        try:
            guest = Invite.objects.get(id=invite_id)

            errors = []
            success_msg = []

            if guest.is_invited:
                return JsonResponse({
                    'success': False,
                    'message': 'Invite already sent to guest.'
                }, status=400)

            # Determine available contact methods
            send_email = bool(guest.email)
            send_whatsapp = bool(guest.phone)

            if not send_email and not send_whatsapp:
                return JsonResponse({
                    'success': False,
                    'message': 'No contact method available. Please add email or phone.'
                }, status=400)


            # Send Email
            if send_email:
                send_invite_message(guest)
                success_msg.append('Email sent')

            content_sid = "HX1990d9d8e827621c4119194d3e839617"

            # Send WhatsApp
            if send_whatsapp:
                whatsapp = send_whatsapp_message(guest, content_sid)
                
                if whatsapp:
                    success_msg.append('WhatsApp message sent')
                    
                guest.is_invited = bool(success_msg)
                guest.save()

            message = ', '.join(success_msg) if success_msg else 'No messages were sent'
            if errors and not success_msg:
                return JsonResponse({
                    'success': False,
                    'message': message,
                    'errors': errors
                }, status=400)

            return JsonResponse({'success': True, 'message': message})
        except Invite.DoesNotExist:
            return JsonResponse({'success': False, 'message': 'Guest not found'}, status=404)
        except Exception as e:
            return JsonResponse({'success': False, 'message': str(e)}, status=400)
    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

@login_required
@csrf_exempt
def send_bulk_invites(request):
    """Send invites to multiple invitees (auto-sends to available contact methods)"""
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
        except json.JSONDecodeError:
            return JsonResponse({'status': 400, 'message': "Invalid JSON data"}, status=400)

        invite_ids = data.get('invite_ids', [])

        if not invite_ids:
            return JsonResponse({'status': 400, 'message': "No Invite IDs provided"}, status=400)

        sent_count = 0
        failed = []

        for invite_id in invite_ids:
            try:
                guest = Invite.objects.get(id=invite_id)

                # If already invited, skip
                if guest.is_invited:
                    sent_count += 1
                    continue

                send_email = bool(guest.email)
                send_whatsapp = bool(guest.phone)

                if not send_email and not send_whatsapp:
                    failed.append(f"{guest.name} ({guest.id}): No contact info available")
                    continue

                success = False
                errors = []

                # Send Email
                if send_email:
                    send_invite_message(guest)
                    success = True

                # Send WhatsApp
                content_sid = "HX1990d9d8e827621c4119194d3e839617"

                # Send WhatsApp
                if send_whatsapp:
                    whatsapp = send_whatsapp_message(guest, content_sid)
                    
                    if whatsapp:
                        success = True
                        
                guest.is_invited = success
                guest.save()
                if success:
                    sent_count += 1
                elif errors:
                    failed.append(f"{guest.name} ({guest.id}): {'; '.join(errors)}")

            except Invite.DoesNotExist:
                failed.append(f"Invite ID {invite_id} not found")
            except Exception as e:
                failed.append(f"Invite ID {invite_id}: {str(e)}")

        message = f"Sent {sent_count} invite(s)."
        if failed:
            message += f" Failed: {', '.join(failed)}"

        return JsonResponse({
            'status': 200,
            'message': message,
            'sent_count': sent_count,
            'failed': failed
        })
    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

@login_required
@csrf_exempt
def import_invites(request):
    """Import invites from CSV/Excel file"""
    if request.method == 'POST':
        try:
            import csv
            import io

            if 'file' in request.FILES:
                file_obj = request.FILES['file']
                filename = file_obj.name.lower()
                rows_imported = 0
                rows_failed = []

                # CSV handling
                if filename.endswith('.csv'):
                    # Read CSV
                    data = file_obj.read().decode('utf-8-sig')
                    io_string = io.StringIO(data)
                    reader = csv.DictReader(io_string)
                    headers = [h.strip().lower() for h in reader.fieldnames]

                    name_idx = next((i for i, h in enumerate(headers) if 'name' in h), None)
                    email_idx = next((i for i, h in enumerate(headers) if 'email' in h), None)
                    phone_idx = next((i for i, h in enumerate(headers) if 'phone' in h or 'mobile' in h or 'number' in h), None)

                    # Map index to column name
                    if name_idx is not None:
                        name_key = reader.fieldnames[name_idx]
                    else:
                        name_key = 'name'
                    if email_idx is not None:
                        email_key = reader.fieldnames[email_idx]
                    else:
                        email_key = 'email'
                    if phone_idx is not None:
                        phone_key = reader.fieldnames[phone_idx]
                    else:
                        phone_key = 'phone'

                    for row in reader:
                        try:
                            name = row.get(name_key, '').strip()
                            email = row.get(email_key, '').strip() or None
                            phone = row.get(phone_key, '').strip() or None

                            if not name:
                                rows_failed.append(f"Row {rows_imported + 2}: Name is required")
                                continue

                            if email and Invite.objects.filter(email=email).exists():
                                rows_failed.append(f"Row {rows_imported + 2}: Email already exists")
                                continue
                            if phone and Invite.objects.filter(phone=phone).exists():
                                rows_failed.append(f"Row {rows_imported + 2}: Phone already exists")
                                continue

                            Invite.objects.create(name=name, email=email, phone=phone)
                            rows_imported += 1
                        except Exception as e:
                            rows_failed.append(f"Row {rows_imported + 2}: {str(e)}")

                # Excel handling
                elif filename.endswith('.xlsx') or filename.endswith('.xls'):
                    wb = openpyxl_load_workbook(file_obj, data_only=True)
                    ws = wb.active

                    headers = None
                    for row in ws.iter_rows(values_only=True):
                        if headers is None:
                            headers = [str(cell).strip().lower() if cell else '' for cell in row]
                            name_idx = next((i for i, h in enumerate(headers) if 'name' in h), None)
                            email_idx = next((i for i, h in enumerate(headers) if 'email' in h), None)
                            phone_idx = next((i for i, h in enumerate(headers) if 'phone' in h or 'mobile' in h or 'number' in h), None)
                            continue

                        try:
                            name = row[name_idx] if name_idx is not None and row[name_idx] else None
                            email = row[email_idx] if email_idx is not None and row[email_idx] else None
                            phone = row[phone_idx] if phone_idx is not None and row[phone_idx] else None

                            if not name:
                                rows_failed.append(f"Row {rows_imported + 2}: Name is required")
                                continue

                            name = str(name).strip()
                            email = str(email).strip() if email else None
                            phone = str(phone).strip() if phone else None

                            if email in ['', 'None']:
                                email = None
                            if phone in ['', 'None']:
                                phone = None

                            if email and Invite.objects.filter(email=email).exists():
                                rows_failed.append(f"Row {rows_imported + 2}: Email already exists")
                                continue
                            if phone and Invite.objects.filter(phone=phone).exists():
                                rows_failed.append(f"Row {rows_imported + 2}: Phone already exists")
                                continue

                            Invite.objects.create(name=name, email=email, phone=phone)
                            rows_imported += 1
                        except Exception as e:
                            rows_failed.append(f"Row {rows_imported + 2}: {str(e)}")
                else:
                    return JsonResponse({'status': 400, 'message': 'Unsupported file format. Please upload .xlsx, .xls, or .csv files.'}, status=400)

                message = f"Successfully imported {rows_imported} invite(s)."
                if rows_failed:
                    message += f" Failed rows: {', '.join(rows_failed)}"

                return JsonResponse({
                    'status': 200,
                    'message': message,
                    'imported': rows_imported,
                    'failed': rows_failed
                })
            else:
                return JsonResponse({'status': 400, 'message': 'No file provided'}, status=400)
        except Exception as e:
            return JsonResponse({'status': 500, 'message': f'Import error: {str(e)}'}, status=500)
    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)

@login_required
@csrf_exempt
def get_invite(request, invite_id):
    """Get invite details for editing"""
    try:
        invite = Invite.objects.get(id=invite_id)
        return JsonResponse({
            'id': invite.id,
            'name': invite.name,
            'email': invite.email,
            'phone': invite.phone,
            'is_invited': invite.is_invited,
        })
    except Invite.DoesNotExist:
        return JsonResponse({'error': 'Invite not found'}, status=404)
@login_required
@csrf_exempt
def reset_invite_status(request):
    """Reset invite status for all invites (clear sent flags)"""
    if request.method == 'POST':
        Invite.objects.all().update(
            is_invited=False,
            email_sent=False,
            whatsapp_sent=False,
            message_sid=None
        )
        return JsonResponse({'status': 200, 'message': 'All invite statuses have been reset.'})
    return JsonResponse({'status': 405, 'message': 'Method not allowed'}, status=405)