from django.contrib import messages
from django.utils import timezone
from ..models import PlayerRegistration, UnregisteredTeam, UnregisteredPlayer
from ..models.player_enums import PlayerDataSource
from ..services.email_service import TournamentEmailService

class TournamentUnregistrationService:
    def __init__(self, request, tournament):
        self.request = request
        self.tournament = tournament
        self.player_registration = None
        self.other_player = None

    def can_unregister(self):
        if not self.tournament.is_unregistration_possible():
            messages.error(self.request, "Le désistement n'est plus possible pour ce tournoi.")
            return False

        if not self.request.user.licence_id:
            messages.error(self.request,
                "Vous ne pouvez pas vous désinscrire car vous n'avez pas de numéro de licence associé.")
            return False

        return True

    def process_unregistration(self):
        if not self._find_player_registration():
            messages.error(self.request,
                "La désincription a échouée. Veuillez contacter le juge-arbitre.")
            return False

        self._delete_registered_team()
        self._cleanup_session()
        return True

    def _find_player_registration(self):
        self.player_registration = PlayerRegistration.objects.filter(
            licence_id__startswith=self.request.user.licence_id,
            team_registration__tournament_id=self.tournament.id,
        ).first()

        if self.player_registration:
            team_registration = self.player_registration.team_registration
            self.other_player = team_registration.get_other_player(self.player_registration)
            return True
        return False

    def _delete_registered_team(self):
        team_registration = self.player_registration.team_registration
        tournament=team_registration.tournament

        print("Unregistering team from tournament")
        unregistered_team = UnregisteredTeam.objects.create(
            tournament=tournament,
            unregistration_date=timezone.now(),
        )

        captain = None
        other_player = None
        for player in team_registration.playerregistration_set.all():
            if player.captain is True:
                captain = player
            else:
                other_player = player
            UnregisteredPlayer.objects.create(
                unregistered_team=unregistered_team,
                first_name=player.first_name,
                last_name=player.last_name,
                licence_id=player.licence_id,
            )

        first_waiting_list_team = tournament.first_waiting_list_team()

        if first_waiting_list_team:
            waiting_captain = None
            waiting_other_player = None
            for player in first_waiting_list_team.playerregistration_set.all():
                if player.captain is True:
                    waiting_captain = player
                else:
                    waiting_other_player = player

            if waiting_captain and waiting_captain.source is not PlayerDataSource.ONLINE_REGISTRATION and not waiting_captain.email:
                return

            TournamentEmailService.send_out_of_waiting_list_confirmation(
                self.request,
                waiting_captain,
                tournament,
                waiting_other_player
            )



        if captain and captain.source is not PlayerDataSource.ONLINE_REGISTRATION and not captain.email:
            return

        TournamentEmailService.send_unregistration_confirmation(
            self.request,
            captain,
            tournament,
            other_player
        )


        team_registration.delete()

    def _cleanup_session(self):
        self.request.session['team_registration'] = []
        self.request.session.modified = True