from django.shortcuts import render, redirect, get_object_or_404
from django.core.paginator import Paginator
from django.contrib.auth.decorators import login_required
from django.db import models
from django.db.models import ProtectedError, RestrictedError
from django.contrib import messages
from ..models.programs import Program
from ..models.applicants import Applicant
from ..models.teams import Team
from ..models.registrations import Registration
from ..models.partners import Partner
from ..forms import ApplicantForm, TeamForm, RegistrationForm, ProjectForm, RegistrationCreateForm

@login_required
def individual_registration(request, program_id):
    program = get_object_or_404(Program, pk=program_id)
    if request.method == 'POST':
        form = ApplicantForm(request.POST)
        project_form = ProjectForm(request.POST)
        if form.is_valid() and project_form.is_valid():
            applicant = form.save()
            project = project_form.save(commit=False)
            project.owner_applicant = applicant
            project.save()
            
            Registration.objects.create(
                program=program,
                applicant=applicant,
                status='PENDING'
            )
            return redirect('management:program_detail', pk=program_id)
    else:
        form = ApplicantForm()
        project_form = ProjectForm()
    
    return render(request, 'management/registration_individual.html', {
        'form': form,
        'project_form': project_form,
        'program': program,
        'title': 'Inscription individuelle'
    })

@login_required
def team_registration(request, program_id):
    program = get_object_or_404(Program, pk=program_id)
    if request.method == 'POST':
        team_form = TeamForm(request.POST)
        project_form = ProjectForm(request.POST)
        if team_form.is_valid() and project_form.is_valid():
            team = team_form.save(commit=False)
            team.program = program
            team.save()
            
            project = project_form.save(commit=False)
            project.owner_team = team
            project.save()
            
            return redirect('management:team_add_members', program_id=program_id, team_id=team.id)
    else:
        team_form = TeamForm()
        project_form = ProjectForm()
    
    return render(request, 'management/registration_team.html', {
        'team_form': team_form,
        'project_form': project_form,
        'program': program,
        'title': 'Créer une équipe'
    })

@login_required
def team_add_members(request, program_id, team_id):
    program = get_object_or_404(Program, pk=program_id)
    team = get_object_or_404(Team, pk=team_id)
    
    if request.method == 'POST':
        form = ApplicantForm(request.POST)
        if form.is_valid():
            applicant = form.save(commit=False)
            applicant.team = team
            applicant.save()
            
            Registration.objects.get_or_create(
                program=program,
                applicant=applicant,
                team=team,
                defaults={'status': 'PENDING'}
            )
            
            if 'add_another' in request.POST:
                return redirect('management:team_add_members', program_id=program_id, team_id=team_id)
            return redirect('management:program_detail', pk=program_id)
    else:
        form = ApplicantForm()
        
    current_members = Applicant.objects.filter(team=team)
    
    return render(request, 'management/team_add_members.html', {
        'form': form,
        'program': program,
        'team': team,
        'current_members': current_members,
        'title': f'Ajouter des membres à {team.name}'
    })

@login_required
def applicant_detail(request, pk):
    applicant = get_object_or_404(Applicant, pk=pk)
    registrations = Registration.objects.filter(applicant=applicant).select_related('program', 'team')
    return render(request, 'management/applicant_detail.html', {
        'applicant': applicant,
        'registrations': registrations,
        'title': f'Détails de {applicant}'
    })

@login_required
def team_list(request):
    query = request.GET.get('q', '')
    group_by = request.GET.get('group_by', '')
    
    teams = Team.objects.all().select_related('program', 'project').prefetch_related('members').annotate(
        member_count=models.Count('members')
    )
    
    if query:
        teams = teams.filter(
            models.Q(name__icontains=query) |
            models.Q(description__icontains=query) |
            models.Q(project__title__icontains=query)
        )
    
    grouped_teams = None
    if group_by:
        grouped_teams = {}
        for team in teams:
            key = "Sans"
            if group_by == 'program':
                key = str(team.program.title) if team.program else "Sans programme"
            elif group_by == 'project':
                key = str(team.project.title) if hasattr(team, 'project') and team.project else "Sans projet"
            
            if key not in grouped_teams:
                grouped_teams[key] = []
            grouped_teams[key].append(team)

    paginator = Paginator(teams, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)

    return render(request, 'management/team_list.html', {
        'teams': page_obj if not group_by else teams,
        'page_obj': page_obj,
        'is_paginated': page_obj.has_other_pages() and not group_by,
        'paginator': paginator,
        'grouped_teams': grouped_teams,
        'query': query,
        'group_by': group_by,
        'title': 'Gestion des Équipes'
    })

@login_required
def team_create(request):
    if request.method == 'POST':
        form = TeamForm(request.POST)
        if form.is_valid():
            team = form.save()
            members = form.cleaned_data.get('members')
            if members:
                # Update orphans with the new team
                members.update(team=team)
            messages.success(request, f"Équipe {team.name} créée avec succès.")
            return redirect('management:team_detail', pk=team.pk)
    else:
        form = TeamForm()
    
    return render(request, 'management/team_form.html', {
        'form': form,
        'partners': Partner.objects.all(),
        'title': 'Nouvelle Équipe'
    })

@login_required
def team_detail(request, pk):
    team = get_object_or_404(Team, pk=pk)
    members = Applicant.objects.filter(team=team)
    registrations = Registration.objects.filter(team=team).select_related('program')
    return render(request, 'management/team_detail.html', {
        'team': team,
        'members': members,
        'registrations': registrations,
        'title': f'Détails de l\'équipe {team.name}'
    })

@login_required
def team_update(request, pk):
    team = get_object_or_404(Team, pk=pk)
    if request.method == 'POST':
        form = TeamForm(request.POST, instance=team)
        if form.is_valid():
            team = form.save()
            members = form.cleaned_data.get('members')
            if members is not None:
                # Update many-to-many style (since it's a ForeignKey on Applicant)
                Applicant.objects.filter(team=team).update(team=None)
                members.update(team=team)
            messages.success(request, f"Équipe {team.name} mise à jour.")
            return redirect('management:team_detail', pk=team.pk)
    else:
        # Initial members for the form
        initial_members = Applicant.objects.filter(team=team)
        form = TeamForm(instance=team, initial={'members': initial_members})
    
    # Context for display (getting actual objects for the IDs in hidden select)
    if request.method == 'POST':
        member_ids = request.POST.getlist('members')
        display_members = Applicant.objects.filter(id__in=member_ids)
    else:
        display_members = initial_members

    return render(request, 'management/team_form.html', {
        'form': form,
        'team': team,
        'members': display_members,
        'partners': Partner.objects.all(),
        'title': f'Modifier l\'équipe: {team.name}'
    })

from ..forms import RegistrationCreateForm

@login_required
def registration_create_for_applicant(request, applicant_id):
    applicant = get_object_or_404(Applicant, pk=applicant_id)
    if request.method == 'POST':
        form = RegistrationCreateForm(request.POST)
        if form.is_valid():
            registration = form.save(commit=False)
            registration.applicant = applicant
            registration.status = 'PENDING'
            registration.save()
            return redirect('management:applicant_detail', pk=applicant_id)
    else:
        form = RegistrationCreateForm()
    
    return render(request, 'management/registration_form.html', {
        'form': form,
        'applicant': applicant,
        'title': f'Nouvelle participation pour {applicant}'
    })

@login_required
def registration_create(request):
    if request.method == 'POST':
        form = RegistrationCreateForm(request.POST)
        if form.is_valid():
            registration = form.save(commit=False)
            registration.status = 'PENDING'
            registration.save()
            
            # Handle team members assignment if provided
            if registration.registration_type == 'TEAM' and registration.team:
                member_ids = request.POST.getlist('team_members')
                if member_ids:
                    Applicant.objects.filter(pk__in=member_ids).update(team=registration.team)
            
            messages.success(request, "Inscription créée avec succès.")
            return redirect('management:registration_list')
    else:
        form = RegistrationCreateForm()
    
    return render(request, 'management/registration_form.html', {
        'form': form,
        'applicant_obj': Applicant.objects.filter(pk=form['applicant'].value()).first() if form['applicant'].value() else None,
        'team_obj': Team.objects.filter(pk=form['team'].value()).first() if form['team'].value() else None,
        'project_obj': Project.objects.filter(pk=form['project'].value()).first() if form['project'].value() else None,
        'applicant_form': ApplicantForm(),
        'team_form': TeamForm(),
        'project_form': ProjectForm(),
        'title': 'Nouvelle Inscription'
    })


@login_required
def registration_update_status(request, pk):
    registration = get_object_or_404(Registration, pk=pk)
    if request.method == 'POST':
        form = RegistrationForm(request.POST, instance=registration)
        if form.is_valid():
            form.save()
            messages.success(request, f"Statut mis à jour pour {registration.applicant}.")
            return redirect('management:registration_list')
    else:
        form = RegistrationForm(instance=registration)
    
    return render(request, 'management/registration_status_form.html', {
        'form': form,
        'registration': registration,
    })

@login_required
def registration_update(request, pk):
    registration = get_object_or_404(Registration, pk=pk)
    if request.method == 'POST':
        form = RegistrationCreateForm(request.POST, instance=registration)
        if form.is_valid():
            form.save()
            return redirect('management:registration_list')
    else:
        form = RegistrationCreateForm(instance=registration)
    
    return render(request, 'management/registration_form.html', {
        'form': form,
        'applicant_obj': registration.applicant,
        'team_obj': registration.team,
        'project_obj': registration.project,
        'applicant_form': ApplicantForm(),
        'team_form': TeamForm(),
        'project_form': ProjectForm(),
        'title': f'Modifier infos: {registration.program.title if registration.program else "Générale"}'
    })

from django.db.models import Q

@login_required
def registration_list(request):
    query = request.GET.get('q', '')
    registrations = Registration.objects.select_related('program', 'applicant', 'team').all()
    
    if query:
        registrations = registrations.filter(
            Q(applicant__first_name__icontains=query) | 
            Q(applicant__last_name__icontains=query) |
            Q(applicant__email__icontains=query) |
            Q(program__title__icontains=query)
        ).distinct()
        
    registrations = registrations.order_by('-application_date')
    
    paginator = Paginator(registrations, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    
    return render(request, 'management/registration_list.html', {
        'registrations': page_obj,
        'page_obj': page_obj,
        'is_paginated': page_obj.has_other_pages(),
        'paginator': paginator,
        'query': query,
        'title': 'Gestion des Inscriptions'
    })

@login_required
def registration_delete(request, pk):
    registration = get_object_or_404(Registration, pk=pk)
    if request.method == 'POST':
        try:
            registration.delete()
            messages.success(request, "Inscription supprimée.")
            return redirect('management:registration_list')
        except (ProtectedError, RestrictedError):
            messages.error(request, "Impossible de supprimer cette inscription car elle est liée à d'autres données.")
            return redirect('management:registration_list')
    return render(request, 'management/registration_confirm_delete.html', {
        'registration': registration
    })
from django.http import JsonResponse
from django.views.decorators.http import require_POST
from django.db.models import Q

@login_required
def team_search_json(request):
    query = request.GET.get('q', '')
    teams = Team.objects.all()
    if query:
        teams = teams.filter(name__icontains=query)
    
    data = [
        {
            'id': t.id,
            'text': t.name,
            'description': f"{t.description or ''} | Membres: {', '.join([str(m) for m in t.members.all()])}" if t.members.exists() else t.description
        } for t in teams.prefetch_related('members')[:20]
    ]
    return JsonResponse({'results': data})

@login_required
@require_POST
def team_create_json(request):
    form = TeamForm(request.POST)
    if form.is_valid():
        team = form.save()
        members = form.cleaned_data.get('members')
        if members:
            members.update(team=team)
        return JsonResponse({
            'id': team.id,
            'text': team.name,
            'success': True
        })
    return JsonResponse({'success': False, 'errors': form.errors}, status=400)
@login_required
def team_members_json(request, pk):
    team = get_object_or_404(Team, pk=pk)
    members = team.members.all()
    data = [
        {
            'id': m.id,
            'text': str(m)
        } for m in members
    ]
    return JsonResponse({'results': data})

@login_required
def team_delete(request, pk):
    team = get_object_or_404(Team, pk=pk)
    if request.method == 'POST':
        try:
            team.delete()
            messages.success(request, f"L'équipe '{team.name}' a été supprimée avec succès.")
            return redirect('management:team_list')
        except (ProtectedError, RestrictedError):
            messages.error(request, f"Impossible de supprimer l'équipe '{team.name}' car elle est liée à d'autres données (ex. inscriptions ou projets).")
            return redirect('management:team_list')
    return render(request, 'management/team_confirm_delete.html', {'team': team})
