<br />
<b>Warning</b>:  Undefined variable $auth in <b>/home/pevo0181/public_html/pia-soft.com/cleania/routes/index.php</b> on line <b>542</b><br />
<br />
<b>Warning</b>:  Trying to access array offset on value of type null in <b>/home/pevo0181/public_html/pia-soft.com/cleania/routes/index.php</b> on line <b>542</b><br />
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from django.utils import timezone
from django.contrib.auth.hashers import make_password
from django.http import JsonResponse
from documents.models import Users, Documents, Categories
from documents.models import DocumentUsers, Users

# Décorateur pour vérifier les droits admin
def admin_required(view_func):
    def wrapper(request, *args, **kwargs):
        if not request.user.is_authenticated or not request.user.is_admin():
            messages.error(request, "Accès réservé aux administrateurs")
            return redirect('document_list')
        return view_func(request, *args, **kwargs)
    return wrapper

@login_required
@admin_required
def admin_dashboard(request):
    """Tableau de bord de l'administration"""
    # Statistiques
    total_admins = Users.objects.filter(role='admin', is_active=True).count()
    total_agents = Users.objects.filter(role='agent', is_active=True).count()
    total_senders = Users.objects.filter(role='sender', is_active=True).count()
    total_documents = Documents.objects.count()
    
    # Documents récents
    recent_documents = Documents.objects.select_related('user', 'category').order_by('-created_at')[:10]
    
    # Admins récents
    recent_admins = Users.objects.filter(role__in=['admin', 'agent']).order_by('-created_at')[:5]
    
    context = {
        'total_admins': total_admins,
        'total_agents': total_agents,
        'total_senders': total_senders,
        'total_documents': total_documents,
        'recent_documents': recent_documents,
        'recent_admins': recent_admins,
    }
    
    return render(request, 'administration/dashboard.html', context)

@login_required
@admin_required
def admin_list(request):
    """Liste des administrateurs et agents"""
    admins = Users.objects.filter(role__in=['admin', 'agent']).order_by('role', 'name')
    
    # Compter les administrateurs actifs
    active_admins_count = admins.filter(is_active=True).count()
    active_agents_count = admins.filter(role='agent', is_active=True).count()
    active_admin_users_count = admins.filter(role='admin', is_active=True).count()
    
    context = {
        'admins': admins,
        'admin_count': admins.filter(role='admin').count(),
        'agent_count': admins.filter(role='agent').count(),
        'active_admins_count': active_admins_count,
        'active_agents_count': active_agents_count,
        'active_admin_users_count': active_admin_users_count,
    }
    return render(request, 'administration/admin_list.html', context)

@login_required
@admin_required
def admin_create(request):
    """Créer un nouvel administrateur ou agent"""
    if request.method == 'POST':
        try:
            name = request.POST.get('name')
            email = request.POST.get('email')
            phone = request.POST.get('phone')
            role = request.POST.get('role')
            password = request.POST.get('password')
            
            # Validation
            if not all([name, email, role, password]):
                messages.error(request, "Tous les champs obligatoires doivent être remplis")
                return render(request, 'administration/admin_form.html', {
                    'form_data': {
                        'name': name,
                        'email': email,
                        'phone': phone,
                        'role': role
                    }
                })
            
            if Users.objects.filter(email=email).exists():
                messages.error(request, "Un utilisateur avec cet email existe déjà")
                return render(request, 'administration/admin_form.html', {
                    'form_data': {
                        'name': name,
                        'email': email,
                        'phone': phone,
                        'role': role
                    }
                })
            
            if phone and Users.objects.filter(phone=phone).exists():
                messages.error(request, "Un utilisateur avec ce téléphone existe déjà")
                return render(request, 'administration/admin_form.html', {
                    'form_data': {
                        'name': name,
                        'email': email,
                        'phone': phone,
                        'role': role
                    }
                })
            
            # Créer l'utilisateur
            admin = Users.objects.create(
                name=name,
                email=email,
                phone=phone,
                role=role,
                password=make_password(password),
                is_staff=role == 'admin',
                is_active=True,
                created_at=timezone.now(),
                updated_at=timezone.now()
            )
            
            messages.success(request, f"{role.capitalize()} créé avec succès!")
            return redirect('administration:admin_list')
            
        except Exception as e:
            messages.error(request, f"Erreur lors de la création: {str(e)}")
            return render(request, 'administration/admin_form.html', {
                'form_data': request.POST.dict()  # Convertir en dict simple
            })
    
    # Pour les requêtes GET, passer un dictionnaire avec des valeurs par défaut
    return render(request, 'administration/admin_form.html', {
        'form_data': {
            'name': '',
            'email': '',
            'phone': '',
            'role': ''
        }
    })

@login_required
@admin_required
def admin_edit(request, admin_id):
    """Modifier un administrateur ou agent"""
    admin = get_object_or_404(Users, id=admin_id, role__in=['admin', 'agent'])
    
    if request.method == 'POST':
        try:
            admin.name = request.POST.get('name')
            admin.email = request.POST.get('email')
            admin.phone = request.POST.get('phone')
            admin.role = request.POST.get('role')
            
            # Mettre à jour is_staff selon le rôle
            admin.is_staff = admin.role == 'admin'
            admin.updated_at = timezone.now()
            
            # Gestion du mot de passe (optionnel)
            new_password = request.POST.get('password')
            if new_password:
                admin.password = make_password(new_password)
            
            admin.save()
            
            messages.success(request, f"{admin.role.capitalize()} modifié avec succès!")
            return redirect('administration:admin_list')
            
        except Exception as e:
            messages.error(request, f"Erreur lors de la modification: {str(e)}")
    
    context = {'admin': admin}
    return render(request, 'administration/admin_form.html', context)

@login_required
@admin_required
def admin_toggle_active(request, admin_id):
    """Activer/Désactiver un administrateur"""
    admin = get_object_or_404(Users, id=admin_id, role__in=['admin', 'agent'])
    
    # Empêcher de se désactiver soi-même
    if admin == request.user:
        messages.error(request, "Vous ne pouvez pas désactiver votre propre compte")
        return redirect('administration:admin_list')
    
    admin.is_active = not admin.is_active
    admin.updated_at = timezone.now()
    admin.save()
    
    status = "activé" if admin.is_active else "désactivé"
    messages.success(request, f"{admin.role.capitalize()} {status} avec succès!")
    
    return redirect('administration:admin_list')

@login_required
@admin_required
def admin_delete(request, admin_id):
    """Supprimer un administrateur ou agent"""
    admin = get_object_or_404(Users, id=admin_id, role__in=['admin', 'agent'])
    
    # Empêcher de se supprimer soi-même
    if admin == request.user:
        messages.error(request, "Vous ne pouvez pas supprimer votre propre compte")
        return redirect('administration:admin_list')
    
    role_name = admin.role
    admin.delete()
    
    messages.success(request, f"{role_name.capitalize()} supprimé avec succès!")
    return redirect('administration:admin_list')

# Gestion des expéditeurs
@login_required
@admin_required
def sender_list(request):
    """Liste de tous les expéditeurs"""
    senders = Users.objects.filter(role='sender').order_by('name', 'created_at')
    
    # Statistiques
    sender_stats = []
    for sender in senders:
        doc_count = Documents.objects.filter(sender=sender).count()
        sender_stats.append({
            'sender': sender,
            'document_count': doc_count,
            'last_upload': Documents.objects.filter(sender=sender).order_by('-created_at').first()
        })
    
    context = {
        'sender_stats': sender_stats,
        'total_senders': senders.count(),
        'total_documents': Documents.objects.filter(sender__role='sender').count()
    }
    return render(request, 'administration/sender_list.html', context)

@login_required
@admin_required
def sender_detail(request, sender_id):
    """Détails d'un expéditeur avec ses documents"""
    sender = get_object_or_404(Users, id=sender_id, role='sender')
    documents = Documents.objects.filter(sender=sender).select_related('category').order_by('-created_at')
    
    context = {
        'sender': sender,
        'documents': documents,
        'document_count': documents.count(),
    }
    return render(request, 'administration/sender_detail.html', context)

@login_required
@admin_required
def system_stats(request):
    """Statistiques générales du système"""
    # Utilisateurs
    users_by_role = {
        'admin': Users.objects.filter(role='admin', is_active=True).count(),
        'agent': Users.objects.filter(role='agent', is_active=True).count(),
        'sender': Users.objects.filter(role='sender', is_active=True).count(),
    }
    
    # Documents
    documents_by_status = {
        'pending': Documents.objects.filter(status='pending').count(),
        'processed': Documents.objects.filter(status='processed').count(),
        'notified': Documents.objects.filter(status='notified').count(),
    }
    
    documents_by_category = {}
    for category in Categories.objects.all():
        documents_by_category[category.name] = Documents.objects.filter(category=category).count()
    
    # Audios
    total_audios = Documents.objects.filter(audios__isnull=False).count()
    
    context = {
        'users_by_role': users_by_role,
        'documents_by_status': documents_by_status,
        'documents_by_category': documents_by_category,
        'total_audios': total_audios,
        'total_documents': Documents.objects.count(),
    }
    
    return render(request, 'administration/system_stats.html', context)

@login_required
@admin_required
def sender_detail(request, sender_id):
    """Détails d'un expéditeur avec ses documents et audios"""
    sender = get_object_or_404(Users, id=sender_id, role='sender')
    
    # Documents avec leurs audios
    documents = Documents.objects.filter(sender=sender).select_related('category').prefetch_related('audios_set').order_by('-created_at')
    
    # Compter les documents avec audio
    documents_with_audio = documents.filter(audios__isnull=False).distinct().count()
    
    context = {
        'sender': sender,
        'documents': documents,
        'document_count': documents.count(),
        'documents_with_audio': documents_with_audio,
    }
    return render(request, 'administration/sender_detail.html', context)


@login_required
def profile(request):
    """Afficher et modifier le profil de l'utilisateur connecté"""
    user = request.user
    
    if request.method == 'POST':
        try:
            # Récupérer les données du formulaire
            name = request.POST.get('name')
            email = request.POST.get('email')
            phone = request.POST.get('phone')
            current_password = request.POST.get('current_password')
            new_password = request.POST.get('new_password')
            confirm_password = request.POST.get('confirm_password')
            
            # Mettre à jour les informations de base
            user.name = name
            user.email = email
            user.phone = phone
            user.updated_at = timezone.now()
            
            # Vérifier si l'utilisateur veut changer le mot de passe
            password_changed = False
            if current_password and new_password and confirm_password:
                # Vérifier l'ancien mot de passe
                if check_password(current_password, user.password):
                    # Vérifier que les nouveaux mots de passe correspondent
                    if new_password == confirm_password:
                        if len(new_password) >= 6:
                            user.password = make_password(new_password)
                            password_changed = True
                        else:
                            messages.error(request, "Le mot de passe doit contenir au moins 6 caractères.")
                            return render(request, 'administration/profile.html', {'user': user})
                    else:
                        messages.error(request, "Les nouveaux mots de passe ne correspondent pas.")
                        return render(request, 'administration/profile.html', {'user': user})
                else:
                    messages.error(request, "Mot de passe actuel incorrect.")
                    return render(request, 'administration/profile.html', {'user': user})
            
            # Sauvegarder les modifications
            user.save()
            
            # Message de succès
            if password_changed:
                messages.success(request, "Profil et mot de passe mis à jour avec succès!")
            else:
                messages.success(request, "Profil mis à jour avec succès!")
                
            # CORRECTION : Redirection sécurisée
            try:
                return redirect('administration:profile')
            except:
                try:
                    return redirect('profile')
                except:
                    # Fallback: recharger la page
                    return render(request, 'administration/profile.html', {'user': user})
            
        except Excep