from django.shortcuts import render, redirect
from django.urls import reverse_lazy
from django.views.generic.edit import CreateView
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.contrib.auth import views as auth_views
from django.db.models import Q
from django.http import JsonResponse
from .forms import InvitationCodeForm, CustomUserCreationForm, CustomUserChangeForm, PlayerCreationForm
from .models import CustomUser, InvitationCode
import uuid

def invitation_code_view(request):
    if request.method == 'POST':
        form = InvitationCodeForm(request.POST)
        if form.is_valid():
            code = form.cleaned_data['code']
            request.session['invitation_code'] = code
            return redirect('register')
    else:
        form = InvitationCodeForm()
    return render(request, 'accounts/invitation_code.html', {'form': form})

def register_view(request):
    invitation_code_str = request.session.get('invitation_code')
    if not invitation_code_str:
        return redirect('invitation_code')

    try:
        invitation_code = InvitationCode.objects.get(code=invitation_code_str)
        if not invitation_code.is_valid():
            # Handle invalid code, maybe redirect with a message
            return redirect('invitation_code')
    except InvitationCode.DoesNotExist:
        return redirect('invitation_code')


    if request.method == 'POST':
        form = CustomUserCreationForm(request.POST)
        if form.is_valid():
            user = form.save(commit=False)
            user.set_password(form.cleaned_data['password'])
            user.save()
            invitation_code.is_active = False
            invitation_code.user = user
            invitation_code.save()
            # Log the user in and redirect to the dashboard
            return redirect('login') # Or wherever you want to redirect after registration
    else:
        form = CustomUserCreationForm()
    return render(request, 'accounts/register.html', {'form': form})

@login_required
def edit_profile(request):
    if request.method == 'POST':
        form = CustomUserChangeForm(request.POST, instance=request.user)
        if form.is_valid():
            form.save()
            return redirect('edit_profile') # Or wherever you want to redirect
    else:
        form = CustomUserChangeForm(instance=request.user)
    return render(request, 'accounts/edit_profile.html', {'form': form})

class HeadCoachCheckMixin(UserPassesTestMixin):
    def test_func(self):
        return self.request.user.is_superuser or self.request.user.coached_teams.exists()

class PlayerCreateView(LoginRequiredMixin, HeadCoachCheckMixin, CreateView):
    model = CustomUser
    form_class = PlayerCreationForm
    template_name = 'accounts/player_form.html'
    success_url = reverse_lazy('dashboard')

    def form_valid(self, form):
        # Create player user
        player = form.save(commit=False)
        player.is_active = False # Player can only login after using invitation code
        player.save()

        # Create invitation code for player
        InvitationCode.objects.create(code=str(uuid.uuid4()), user=player)

        # Handle parents
        for i in ['1', '2']:
            search_identifier = form.cleaned_data.get(f'parent{i}_search')
            new_email = form.cleaned_data.get(f'parent{i}_new')

            if search_identifier:
                import re
                match = re.search(r'\((\w+)\)', search_identifier)
                if match:
                    username = match.group(1)
                    try:
                        parent_user = CustomUser.objects.get(username=username)
                        player.parents.add(parent_user)
                    except CustomUser.DoesNotExist:
                        form.add_error(f'parent{i}_search', 'User not found.')
                else:
                    # if no user is selected from the list, maybe the user typed an email/username directly
                    try:
                        parent_user = CustomUser.objects.get(Q(username=search_identifier) | Q(email=search_identifier))
                        player.parents.add(parent_user)
                    except CustomUser.DoesNotExist:
                        form.add_error(f'parent{i}_search', 'User not found.')
                    except CustomUser.MultipleObjectsReturned:
                        form.add_error(f'parent{i}_search', 'Multiple users found. Please be more specific.')

            elif new_email:
                parent_user, created = CustomUser.objects.get_or_create(email=new_email, defaults={'username': new_email, 'is_active': False})
                InvitationCode.objects.create(code=str(uuid.uuid4()), user=parent_user)
                player.parents.add(parent_user)

        if form.errors:
            return self.form_invalid(form)

        return redirect(self.success_url)

class MyLoginView(auth_views.LoginView):
    def get(self, request, *args, **kwargs):
        if request.user.is_authenticated:
            return redirect('dashboard')
        return super().get(request, *args, **kwargs)

def user_search(request):
    q = request.GET.get('q', '')
    users = CustomUser.objects.filter(last_name__istartswith=q).values('username', 'first_name', 'last_name')
    results = []
    for user in users:
        results.append(f"{user['last_name']}, {user['first_name']} ({user['username']})")
    return JsonResponse(results, safe=False)