from functools import partial

import disnake
from disnake import CategoryChannel, PermissionOverwrite, TextChannel
from disnake.ext import commands
import logging

from orochi import http
from orochi.config import Config
from orochi.models import Game, GameState, Player, RoundVote, Vote, Round, RoundRoom, Room

bot = commands.Bot(command_prefix='!')


@bot.event
async def on_ready():
    config: Config = bot.config
    logger = bot.logger

    if config.guild is None:
        config.save()
        logger.error("The guild ID is missing")
        exit(1)

    guild = await bot.fetch_guild(config.guild)

    if not guild:
        logger.error("Unknown guild.")
        exit(1)

    if config.vote_category is None:
        category = await guild.create_category("Votes")
        config.vote_category = category.id
        config.save()

    if config.secret_category is None:
        category = await guild.create_category("Conversation⋅s secrète⋅s")
        config.secret_category = category.id
        config.save()

    vote_category: CategoryChannel = await guild.fetch_channel(config.vote_category)
    if vote_category is None:
        config.vote_category = None
        return await on_ready()

    secret_category: CategoryChannel = await guild.fetch_channel(config.secret_category)
    if secret_category is None:
        config.secret_category = None
        return await on_ready()

    await vote_category.set_permissions(
        guild.default_role, overwrite=PermissionOverwrite(read_message_history=False, read_messages=False)
    )

    await secret_category.set_permissions(
        guild.default_role, overwrite=PermissionOverwrite(read_message_history=False, read_messages=False)
    )

    for i, player in enumerate(Config.PLAYERS):
        player_id = player.lower()
        if player_id not in config.vote_channels:
            channel: TextChannel = await vote_category.create_text_channel(player_id)
            config.vote_channels[player_id] = channel.id
            config.save()

        channel: TextChannel = await guild.fetch_channel(config.vote_channels[player_id])
        if channel is None:
            del config.vote_channels[player_id]
            return await on_ready()

        await channel.edit(name=player_id, category=vote_category, position=i)
        await channel.set_permissions(
            guild.default_role, overwrite=PermissionOverwrite(read_message_history=False, read_messages=False)
        )

        if player_id not in config.player_roles:
            role = await guild.create_role(name=player)
            config.player_roles[player_id] = role.id
            config.save()

        guild = await bot.fetch_guild(guild.id)  # update roles
        role = guild.get_role(config.player_roles[player_id])
        if role is None:
            del config.player_roles[player_id]
            config.save()
            return await on_ready()

        await channel.set_permissions(
            role, overwrite=PermissionOverwrite(read_message_history=True, read_messages=True)
        )

    game = Game.load()
    if not game:
        game = Game()
        for player in config.PLAYERS:
            game.register_player(player, config.vote_channels[player.lower()])
        game.save()

    # Update private channel id if necessary
    for player in list(game.players.values()):
        if player.private_channel_id != config.vote_channels[player.name.lower()]:
            game.register_player(player.name, config.vote_channels[player.name.lower()])
            game.save()

    # Setup first round if not exists
    if not game.rounds:
        game.rounds.append(game.default_first_round())
        game.save()

    if not config.telepathy_channel:
        channel: TextChannel = await secret_category.create_text_channel("bigbrain")
        config.telepathy_channel = channel.id
        config.save()

    telepathy_channel: TextChannel = await guild.fetch_channel(config.telepathy_channel)
    if not telepathy_channel:
        config.telepathy_channel = None
        return await on_ready()

    await telepathy_channel.edit(name="bigbrain", category=secret_category, position=0,
                                 topic="Échanges télépathiques")
    await telepathy_channel.set_permissions(
        guild.default_role, overwrite=PermissionOverwrite(read_message_history=False, read_messages=False)
    )
    delphine = guild.get_role(config.player_roles['delphine'])
    philia = guild.get_role(config.player_roles['philia'])
    await telepathy_channel.set_permissions(
        delphine, overwrite=PermissionOverwrite(read_message_history=True, read_messages=True)
    )
    await telepathy_channel.set_permissions(
        philia, overwrite=PermissionOverwrite(read_message_history=True, read_messages=True)
    )

    if not config.brother_channel:
        channel: TextChannel = await secret_category.create_text_channel("doliprane")
        config.brother_channel = channel.id
        config.save()

    brother_channel: TextChannel = await guild.fetch_channel(config.brother_channel)
    if not brother_channel:
        config.brother_channel = None
        return await on_ready()

    await brother_channel.edit(name="doliprane", category=secret_category, position=1,
                               topic="Des voix dans la tête ...")
    await brother_channel.set_permissions(
        guild.default_role, overwrite=PermissionOverwrite(read_message_history=False, read_messages=False)
    )
    await brother_channel.set_permissions(
        philia, overwrite=PermissionOverwrite(read_message_history=True, read_messages=True)
    )

    brother_channel_webhook = None
    if config.brother_channel_webhook is not None:
        try:
            brother_channel_webhook = await bot.fetch_webhook(config.brother_channel_webhook)
        except disnake.HTTPException | disnake.NotFound | disnake.Forbidden:
            pass
    if brother_channel_webhook is None:
        brother_channel_webhook = await brother_channel.create_webhook(name="???")
        config.brother_channel_webhook = brother_channel_webhook.id
        config.save()

    if not config.backdoor_channel:
        channel: TextChannel = await secret_category.create_text_channel("backdoor")
        config.backdoor_channel = channel.id
        config.save()

    backdoor_channel: TextChannel = await guild.fetch_channel(config.backdoor_channel)
    if not backdoor_channel:
        config.backdoor_channel = None
        return await on_ready()

    await backdoor_channel.edit(name="backdoor", category=secret_category, position=2,
                                topic="Panel d'administrati0n du jeu")
    await backdoor_channel.set_permissions(
        guild.default_role, overwrite=PermissionOverwrite(read_message_history=False, read_messages=False)
    )
    dan = guild.get_role(config.player_roles['dan'])
    await backdoor_channel.set_permissions(
        dan, overwrite=PermissionOverwrite(read_message_history=True, read_messages=True)
    )

    if not config.sisters_channel:
        channel: TextChannel = await secret_category.create_text_channel("sista")
        config.sisters_channel = channel.id
        config.save()

    sisters_channel: TextChannel = await guild.fetch_channel(config.sisters_channel)
    if not sisters_channel:
        config.sisters_channel = None
        return await on_ready()

    await sisters_channel.edit(name="sista", category=secret_category, position=3,
                               topic="Discussions vestimentaires")
    await sisters_channel.set_permissions(
        guild.default_role, overwrite=PermissionOverwrite(read_message_history=False, read_messages=False)
    )
    nona = guild.get_role(config.player_roles['nona'])
    ennea = guild.get_role(config.player_roles['ennea'])
    await sisters_channel.set_permissions(
        nona, overwrite=PermissionOverwrite(read_message_history=True, read_messages=True)
    )
    await sisters_channel.set_permissions(
        ennea, overwrite=PermissionOverwrite(read_message_history=True, read_messages=True)
    )

    config.save()


@bot.command(help="Sauvegarde la partie")
@commands.has_permissions(administrator=True)
async def save(ctx: commands.Context, filename: str | None = None):
    Game.INSTANCE.save(filename)
    await ctx.reply("La partie a été sauvegardée.")


@bot.command(help="Recharger la partie")
@commands.has_permissions(administrator=True)
async def load(ctx: commands.Context, filename: str | None = None):
    game = Game.load(filename)
    if not game:
        return await ctx.reply("Une erreur est survenue : le fichier n'existe pas ?")
    await ctx.reply("La partie a été rechargée.")


@bot.command(help="Envoyer un message en tant qu'Orochi.")
@commands.has_permissions(administrator=True)
async def send(ctx: commands.Context, *, message: str):
    await ctx.message.delete()
    await ctx.send(message)


@bot.command(help="Supprime les derniers messages.")
@commands.has_permissions(administrator=True)
async def clear(ctx: commands.Context, limit: int = 100):
    await ctx.channel.purge(limit=limit)


@bot.command(help="Envoyer un message à Philia par la pensée en tant que Brother.")
@commands.has_permissions(administrator=True)
async def brother(ctx: commands.Context, *, message: str):
    webhook = await bot.fetch_webhook(bot.config.brother_channel_webhook)
    await webhook.send(message)
    await ctx.message.reply("Message envoyé.")


@bot.command(help="Ouvrir les votes")
@commands.has_permissions(administrator=True)
async def open(ctx: commands.Context):
    game: Game = Game.INSTANCE
    current_round = game.rounds[-1]

    if game.state == GameState.VOTING:
        await ctx.reply("Les votes sont déjà ouverts.")
        return
    elif game.state == GameState.RESULTS:
        await ctx.reply("Les votes viennent d'être fermés, merci de démarrer un nouveau tour avec `!prepare`.")
        return

    # Ensure that each room is configured
    for room in current_round.rooms:
        if room is None:
            await ctx.reply("Les salles ne sont pas configurées.")
        if len(list(room.players)) != 3 or not all(player for player in room.players):
            return await ctx.reply(f"La groupe {room.room.value} ne contient pas trois joueurs, "
                                   f"merci de finir sa configuration avec `!setup {room.room.value}`.")

    # Send messages to players
    for room in current_round.rooms:
        votes = list(room.votes)
        for i, vote in enumerate(votes):
            players = list(vote.players)
            other_vote = votes[1 - i]
            for j, player in enumerate(players):
                if player.score <= 0:
                    # Player is dead
                    continue

                other_player = players[1 - j] if len(players) == 2 else None
                view = VoteView(timeout=3600)
                channel_id = player.private_channel_id
                channel = bot.get_channel(channel_id)
                message = "Les votes sont ouverts.\n"
                effective_room = room.room if vote.player2 is not None else room.room.next
                message += f"Vous devez aller voter en salle **{effective_room.value}**.\n"
                if other_player:
                    message += f"Vous êtes allié⋅e avec **{other_player.name}**.\n"
                message += f"Vous affrontez {' et '.join(f'**{adv.name}**' for adv in other_vote.players)}.\n"
                message += "Bonne chance !"
                await channel.send(message)

                await channel.send("Pour voter, utilisez l'un des boutons ci-dessous. Vous pouvez appuyer "
                                   "sur le bouton plusieurs fois, mais seul le premier vote sera enregistré.",
                                   view=view)

    game.state = GameState.VOTING

    await ctx.reply("Les salles de vote sont ouvertes, les joueur⋅se⋅s peuvent désormais voter.")


@bot.command(help="Fermer les votes")
@commands.has_permissions(administrator=True)
async def close(ctx: commands.Context):
    game: Game = Game.INSTANCE
    if game.state != GameState.VOTING:
        await ctx.reply("Les votes ne sont pas ouverts.")
        return

    game.state = GameState.RESULTS

    current_round = game.rounds[-1]
    for room in current_round.rooms:
        for vote in room.votes:
            if vote.vote is None:
                vote.vote = Vote.ALLY
                await ctx.send(f"L'équipe **{' et '.join(player.name for player in vote.players)}** "
                               f"n'a pas voté en salle **{room.room.value}** et s'est alliée par défaut.")
            if vote.swapped:
                vote.vote = Vote.ALLY if vote.vote == Vote.BETRAY else Vote.BETRAY
                await ctx.send(f"L'équipe **{' et '.join(player.name for player in vote.players)}** "
                               f"dans le groupe **{room.room.value}** a vu son vote échangé. "
                               f"Nouveau vote : **{vote.vote.value}**")

    for player in game.players.values():
        channel = bot.get_channel(player.private_channel_id)
        await channel.send("Les votes sont à présent clos ! "
                           "Rendez-vous dans la salle principale pour découvrir les scores.")
        if player.score <= 0:
            if player.name == "Dan":
                await channel.send("Tiens ! Vous êtes m... Vous semblez bien tenir à la piqûre.")
            else:
                await channel.send("Tiens ! Vous êtes morts :)")
        elif player.score >= 9:
            await channel.send("Vous avez plus de 9 points. Vous pouvez désormais passer la porte 9.\n"
                               "Mais ... Attendrez-vous vos camarades ?")

    await ctx.reply("Les votes ont bien été fermés.")
    game.save()


@bot.command(help="Préparation du tour suivant")
@commands.has_permissions(administrator=True)
async def prepare(ctx: commands.Context):
    game: Game = Game.INSTANCE
    if game.state != GameState.RESULTS:
        await ctx.reply("Le tour actuel n'est pas terminé.")
        return

    game.state = GameState.PREPARING
    game.rounds.append(Round(
        round=len(game.rounds) + 1,
        room_a=RoundRoom(
            room=Room.A,
            vote1=RoundVote(),
            vote2=RoundVote(),
        ),
        room_b=RoundRoom(
            room=Room.B,
            vote1=RoundVote(),
            vote2=RoundVote(),
        ),
        room_c=RoundRoom(
            room=Room.C,
            vote1=RoundVote(),
            vote2=RoundVote(),
        ),
    ))
    game.save()

    await ctx.reply("Le tour suivant est en préparation. Utilisez `!setup A|B|C` pour paramétrer les groupes A, B ou C. "
                    "Dan peut faire la même chose.")


@bot.command(help="Prévisualisation des combats d'un tour")
@commands.has_any_role('IA', 'Dan')
async def preview(ctx: commands.Context):
    game: Game = Game.INSTANCE
    current_round = game.rounds[-1]
    for room in current_round.rooms:
        await ctx.send(f"Dans la groupe **{room.room.value}**, s'affronteront :\n"
                       f"- **{' et '.join(str(player or '_personne_') for player in room.vote1.players)}** "
                       f"(salle {room.room.next.value})\n"
                       f"- **{' et '.join(str(player or '_personne_') for player in room.vote2.players)}** "
                       f"(salle {room.room.value})")


@bot.command(help="Préparation d'une salle")
@commands.has_any_role('IA', 'Dan')
async def setup(ctx: commands.Context, room: Room):
    game: Game = Game.INSTANCE
    current_round = game.rounds[-1]

    if game.state != GameState.PREPARING:
        return await ctx.reply("Vous ne pouvez pas préparer le groupe avant le tour suivant.")

    await ctx.reply(f"Préparation du groupe {room.value}.")

    match room:
        case Room.A:
            round_room = current_round.room_a
        case Room.B:
            round_room = current_round.room_b
        case _:
            round_room = current_round.room_c

    view = PrepareRoomView(round_room, 0, timeout=300)
    await ctx.send(f"Veuillez choisir qui s'affrontera seul dans le groupe **{room.value}**.", view=view)

    if round_room.vote1.player1 is not None:
        await ctx.send(f"Attention : **{round_room.vote1.player1.name}** est déjà choisie.")


@bot.command(help="Falsification des votes")
@commands.has_permissions(administrator=True)
async def vote(ctx: commands.Context, player_name: str, vote: Vote | None):
    game: Game = Game.INSTANCE
    if game.state != GameState.VOTING:
        return await ctx.reply("Les votes ne sont pas ouverts.")

    for player in game.players.values():
        if player.name.lower() == player_name.lower():
            current_player = player
            break
    else:
        return await ctx.reply("Le joueur n'existe pas.")

    current_round = game.rounds[-1]
    for room in current_round.rooms:
        for v in room.votes:
            if current_player in v.players:
                v.vote = vote

    game.save()
    await ctx.reply(f"Le vote de **{current_player.name}** a bien été falsifié (nouveau vote : *{vote}**).")


@bot.command(help="Échange de vote")
@commands.has_any_role('IA', 'Dan')
async def swap(ctx: commands.Context, player_name: str):
    """
    Exchange the vote of the given player.
    """
    game: Game = Game.INSTANCE
    current_round = game.rounds[-1]

    if game.state != GameState.VOTING:
        return await ctx.reply("Les votes ne sont pas ouverts.")

    for player in game.players.values():
        if player.name.lower() == player_name.lower():
            current_player = player
            break
    else:
        return await ctx.reply("Le joueur n'existe pas.")

    for room in current_round.rooms:
        for v in room.votes:
            if current_player in v.players:
                v.swapped ^= True

    game.save()
    await ctx.reply(f"Le vote de **{current_player.name}** a bien été inversé. S'il était déjà inversé, "
                    "alors il est de retour à la normale.")


@bot.command(help="Modification du score d'un bracelet")
@commands.has_any_role('IA', 'Dan')
async def override(ctx: commands.Context, player_name: str, target_score: int):
    """
    Override the score of a given player.
    """
    game: Game = Game.INSTANCE

    if target_score <= 0:
        return await ctx.reply("Le score désiré doit valoir au moins 1.")

    for player in game.players.values():
        if player.name.lower() == player_name.lower():
            current_player = player
            break
    else:
        return await ctx.reply("Le joueur n'existe pas.")

    game.score_overrides[current_player] = target_score

    game.save()
    await ctx.reply(f"Le score de **{current_player.name}** a bien été modifié. "
                    f"Il sera maintenant de **{target_score}**.")


@bot.command(help="Reboot")
@commands.has_permissions(administrator=True)
async def reboot(ctx: commands.Context):
    game: Game = Game.INSTANCE
    for player in game.players.values():
        channel = bot.get_channel(player.private_channel_id)
        await channel.send("REB0OT.")

    game.save('game-prereboot.save')

    game = Game()
    for player in bot.config.PLAYERS:
        game.register_player(player, bot.config.vote_channels[player.lower()])
    game.rounds.append(game.default_first_round())
    game.save()

    await ctx.reply("REB0OT.")


class VoteView(disnake.ui.View):
    @disnake.ui.button(label="S'allier", style=disnake.ButtonStyle.green)
    async def ally(self, button: disnake.ui.Button, interaction: disnake.MessageInteraction):
        if Game.INSTANCE.state != GameState.VOTING:
            return await interaction.response.send_message("Les votes ne sont pas ouverts.", ephemeral=True)

        await interaction.response.send_message("Votre vote a bien été pris en compte.", ephemeral=True)

        await self.vote(interaction, Vote.ALLY)

    @disnake.ui.button(label="Trahir", style=disnake.ButtonStyle.red)
    async def betray(self, button: disnake.ui.Button, interaction: disnake.MessageInteraction):
        if Game.INSTANCE.state != GameState.VOTING:
            return await interaction.response.send_message("Les votes ne sont pas ouverts.", ephemeral=True)

        await interaction.response.send_message("Votre vote a bien été pris en compte.", ephemeral=True)

        await self.vote(interaction, Vote.BETRAY)

    async def vote(self, interaction: disnake.MessageInteraction, vote: Vote) -> None:
        game = Game.INSTANCE
        current_round = game.rounds[-1]
        current_player: Player | None = None
        for player in game.players.values():
            if player.private_channel_id == interaction.channel_id:
                current_player = player
                break

        if current_player.score <= 0 and current_player.name != "Dan":
            return await interaction.send("Vous êtes mort⋅e !")

        current_vote: RoundVote | None = None
        for room in current_round.rooms:
            for v in room.votes:
                if current_player in v.players:
                    current_vote = v
                    break
            else:
                continue
            break

        if current_vote.vote is None:
            current_vote.vote = vote
            game.save()


class PrepareRoomView(disnake.ui.View):
    def __init__(self, round_room: RoundRoom, player_id: int, *args, **kwargs):
        super().__init__(*args, **kwargs)
        assert 0 <= player_id < 3
        self.round_room = round_room
        self.player_id = player_id

        for player_name in Config.PLAYERS:
            async def choose_player(self, button: disnake.ui.Button, interaction: disnake.MessageInteraction):
                game: Game = Game.INSTANCE
                player = game.players[button.label]
                current_round = game.rounds[-1]
                for room in current_round.rooms:
                    for vote in room.votes:
                        if player in vote.players:
                            replaced_player = None
                            if room == self.round_room:
                                match self.player_id:
                                    case 0:
                                        replaced_player = room.vote1.player1
                                    case 1:
                                        replaced_player = room.vote2.player1
                                    case 2:
                                        replaced_player = room.vote2.player2

                            if replaced_player != player:
                                await interaction.send(
                                    f"Attention : **{player.name}** était déjà attribué⋅e dans le groupe "
                                    f"**{room.room.value}**. Vous devrez probablement la re-configurer.")

                        if vote.player1 == player:
                            vote.player1 = None
                        elif vote.player2 == player:
                            vote.player2 = None

                self.clear_items()
                await interaction.send("Choix bien pris en compte.")
                await interaction.edit_original_message(view=self)
                self.stop()

                match self.player_id:
                    case 0:
                        self.round_room.vote1.player1 = player

                        view = PrepareRoomView(self.round_room, 1, timeout=300)
                        await interaction.send(
                            f"**{player.name}** se battra seul⋅e. Veuillez désormais choisir contre qui "
                            "il ou elle se battra.", view=view)
                        if self.round_room.vote2.player1 is not None:
                            await interaction.send(
                                f"Attention : **{self.round_room.vote2.player1.name}** est déjà choisi⋅e."
                            )
                    case 1:
                        self.round_room.vote2.player1 = player

                        view = PrepareRoomView(self.round_room, 2, timeout=300)
                        await interaction.send(
                            f"**{player.name}** se battra contre **{self.round_room.vote1.player1.name}**. "
                            "Veuillez désormais choisir son partenaire.",
                            view=view)
                        if self.round_room.vote2.player2 is not None:
                            await interaction.send(
                                f"Attention : **{self.round_room.vote2.player2.name}** est déjà choisi⋅e."
                            )
                    case 2:
                        self.round_room.vote2.player2 = player
                        await interaction.send(
                            f"Dans le groupe **{round_room.room.value}**, **{round_room.vote1.player1.name}** "
                            f"(salle {round_room.room.next.value}) "
                            f"affrontera **{round_room.vote2.player1.name}** et **{round_room.vote2.player2.name}** "
                            f"(salle {round_room.room.value}).")
                        await interaction.send(
                            "Vous pouvez redéfinir le groupe tant que le tour n'est pas lancé. "
                            "Utilisez !preview pour un récapitulatif des tours.")

                game.save()

            game: Game = Game.INSTANCE
            current_round = game.rounds[-1]
            for room in current_round.rooms:
                for player in room.players:
                    if player is not None and player.name == player_name:
                        style = disnake.ButtonStyle.danger
                        break
                else:
                    continue
                break
            else:
                style = disnake.ButtonStyle.primary

            button = disnake.ui.Button(style=style, label=player_name)
            button.callback = partial(choose_player, self, button)
            button._view = self
            self.add_item(button)


def run():
    config = Config.load()

    http.run_web_server(config)

    logger = logging.getLogger('discord')
    logger.setLevel(logging.DEBUG)
    handler = logging.FileHandler(filename='../discord.log', encoding='utf-8', mode='w')
    handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s:%(name)s: %(message)s'))
    logger.addHandler(handler)

    bot.config = config
    bot.logger = logger

    bot.run(config.discord_token)