import random
import string
from django.db.models.signals import post_save, pre_delete
from django.dispatch import receiver
from django.conf import settings
from tournaments.models.unregistered_player import UnregisteredPlayer
from django.utils import timezone

from .models import Club, FailedApiCall, CustomUser, Log, TeamRegistration, PlayerRegistration, UnregisteredTeam, UnregisteredPlayer
import requests
from tournaments.services.email_service import TournamentEmailService
from tournaments.models import PlayerDataSource

def generate_unique_code():
    characters = string.ascii_lowercase + string.digits
    while True:
        code = ''.join(random.sample(characters, 3))
        if not Club.objects.filter(broadcast_code=code).exists():
            return code

@receiver(post_save, sender=Club)
def assign_unique_code(sender, instance, created, **kwargs):
    if created and not instance.broadcast_code:
        instance.broadcast_code = generate_unique_code()
        instance.save()

DISCORD_FAILED_CALLS_WEBHOOK_URL = 'https://discord.com/api/webhooks/1248191778134163486/sSoTL6cULCElWr2YFwyllsg7IXxHcCx_YMDJA_cUHtVUU4WOfN-5M7drCJuwNBBfAk9a'
DISCORD_LOGS_WEBHOOK_URL = 'https://discord.com/api/webhooks/1257987637449588736/TtOUwzYgSlQH2d3Ps7SfIKRcFALQVa3hfkC-j9K4_UAcWtsfiw4v8NUPbnX2_ZPOYzuv'

@receiver(post_save, sender=FailedApiCall)
def notify_discord_on_create(sender, instance, created, **kwargs):
    notify_object_creation_on_discord(created, instance, DISCORD_FAILED_CALLS_WEBHOOK_URL)

# @receiver(post_save, sender=CustomUser)
# def notify_user_creation_on_discord(sender, instance, created, **kwargs):
#     notify_object_creation_on_discord(created, instance, DISCORD_LOGS_WEBHOOK_URL)

@receiver(post_save, sender=Log)
def notify_log_creation_on_discord(sender, instance, created, **kwargs):
    notify_object_creation_on_discord(created, instance, DISCORD_LOGS_WEBHOOK_URL)

# WARNING: using this method requires the instance to have a discord_string method
def notify_object_creation_on_discord(created, instance, webhook_url):
    if created:
        default_db_engine = settings.DATABASES['default']['ENGINE']
        if default_db_engine != 'django.db.backends.sqlite3':
            site_name = settings.SITE_NAME
            message = f'{site_name} > New {instance.__class__.__name__} created: {instance.discord_string()}'
            send_discord_message(webhook_url, message)

def send_discord_message(webhook_url, content):
    data = {
        "content": content
    }
    response = requests.post(webhook_url, json=data)
    if response.status_code != 204:
        raise ValueError(
            f'Error sending message to Discord webhook: {response.status_code}, {response.text}'
        )

@receiver(pre_delete, sender=TeamRegistration)
def unregister_team(sender, instance, **kwargs):
    team_registration = instance
    tournament=instance.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(
            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(
        captain,
        tournament,
        other_player
    )