import {
    ActionRowBuilder,
    ButtonBuilder,
    ButtonStyle,
    CategoryChannel,
    ChannelType,
    PermissionFlagsBits,
    SlashCommandBuilder,
    SlashCommandStringOption,
    SlashCommandUserOption,
    type ButtonInteraction,
    type ChatInputCommandInteraction,
} from "discord.js";

export let slashCommands = [
    {
        slashCommand: new SlashCommandBuilder()
            .setName("new")
            .setDescription("Create a new CTF")
            .addStringOption(
                new SlashCommandStringOption()
                    .setName("name")
                    .setDescription("Name for the new CTF")
                    .setRequired(true)
            ),
        handler: newCtf,
    },
    {
        slashCommand: new SlashCommandBuilder()
            .setName("archive")
            .setDescription("Make this CTF category read-only for everyone"),
        handler: archiveCtf,
    },
    {
        slashCommand: new SlashCommandBuilder()
            .setName("add")
            .setDescription("Add a user to this CTF category")
            .addUserOption(
                new SlashCommandUserOption()
                    .setName("user")
                    .setDescription("The user to add")
                    .setRequired(true)
            ),
        handler: addToCtf,
    },
    {
        slashCommand: new SlashCommandBuilder()
            .setName("remove")
            .setDescription("Remove a user from this CTF category")
            .addUserOption(
                new SlashCommandUserOption()
                    .setName("user")
                    .setDescription("The user to remove")
                    .setRequired(true)
            ),
        handler: removeFromCtf,
    },
];

export let buttonCommands = {
    join: {
        prefix: "ctf-category:",
        handler: handleJoinCtfButton,
    },
} as const;

async function newCtf(interaction: ChatInputCommandInteraction) {
    if (!interaction.guild) {
        await interaction.reply({
            content: "This command can only be used inside a server.",
            flags: "Ephemeral",
        });
        return;
    }

    let name = interaction.options.getString("name", true);
    await interaction.deferReply({ flags: "Ephemeral" });

    let category = await interaction.guild.channels.create({
        name,
        type: ChannelType.GuildCategory,
        permissionOverwrites: [
            {
                id: interaction.guild.roles.everyone,
                deny: [PermissionFlagsBits.ViewChannel],
            }
        ],
    });

    await Promise.all([
        await interaction.guild.channels.create({
            name: "info",
            type: ChannelType.GuildText,
            parent: category.id,
            position: 1,
        }),
        await interaction.guild.channels.create({
            name: "general",
            type: ChannelType.GuildText,
            parent: category.id,
            position: 2,
        }),
        await interaction.guild.channels.create({
            name: "challs",
            type: ChannelType.GuildForum,
            parent: category.id,
            position: 3,
        }),
    ]);

    let commandChannel = (interaction.channelId && await interaction.guild.channels.fetch(interaction.channelId));

    if (!commandChannel || !commandChannel.isTextBased())
        throw new Error("Wth is this channel?");

    await commandChannel.send({
        components: [
            new ActionRowBuilder<ButtonBuilder>().addComponents(
                new ButtonBuilder()
                    .setCustomId(`${buttonCommands.join.prefix}${category.id}`)
                    .setLabel(`Join ${name}`)
                    .setStyle(ButtonStyle.Primary),
            ),
        ],
    });

    await interaction.editReply(
        `Created ${category.name}.`,
    );
}

async function archiveCtf(interaction: ChatInputCommandInteraction) {
    if (!interaction.guild) {
        await interaction.reply({
            content: "This command can only be used inside a server.",
            flags: "Ephemeral",
        });
        return;
    }

    let category = await getCategory(interaction);

    let everyoneRoleId = interaction.guild.roles.everyone.id;

    await category.permissionOverwrites.edit(everyoneRoleId, {
        ViewChannel: true,
        ReadMessageHistory: true,
        SendMessages: false,
        SendMessagesInThreads: false,
        CreatePublicThreads: false,
        CreatePrivateThreads: false,
    });

    await Promise.all(
        category.permissionOverwrites.cache
            .filter(overwrite => overwrite.id !== everyoneRoleId)
            .map(overwrite => category.permissionOverwrites.delete(overwrite.id))
    );

    await interaction.reply({
        content: `Updated ${category.name}: @everyone can read, (mostly) no-one can write.`,
        flags: "Ephemeral",
    });
}

async function addToCtf(interaction: ChatInputCommandInteraction) {
    if (!interaction.guild) {
        await interaction.reply({
            content: "This command can only be used inside a server.",
            flags: "Ephemeral",
        });
        return;
    }

    let user = interaction.options.getUser("user", true);
    let category = await getCategory(interaction);

    let member = await interaction.guild.members.fetch(interaction.user.id);
    let permissions = category.permissionsFor(member);

    if (!permissions?.has(PermissionFlagsBits.ManageChannels)) {
        await interaction.reply({
            content: `You don't have permission to update permissions in ${category.name}.`,
            flags: "Ephemeral",
        });
        return;
    }

    await category.permissionOverwrites.edit(user, {
        ViewChannel: true,
        SendMessages: true,
    });

    await interaction.reply({
        content: `Granted ${user} access to ${category.name}.`,
        flags: "Ephemeral",
    });
}

async function removeFromCtf(interaction: ChatInputCommandInteraction) {
    if (!interaction.guild) {
        await interaction.reply({
            content: "This command can only be used inside a server.",
            flags: "Ephemeral",
        });
        return;
    }

    let user = interaction.options.getUser("user", true);
    let category = await getCategory(interaction);

    let member = await interaction.guild.members.fetch(interaction.user.id);
    let permissions = category.permissionsFor(member);

    if (!permissions?.has(PermissionFlagsBits.ManageChannels)) {
        await interaction.reply({
            content: `You don't have permission to update permissions in ${category.name}.`,
            flags: "Ephemeral",
        });
        return;
    }

    await category.permissionOverwrites.delete(user.id);

    await interaction.reply({
        content: `Removed ${user} from ${category.name}.`,
        flags: "Ephemeral",
    });
}

async function handleJoinCtfButton(interaction: ButtonInteraction, categoryId: string) {
    if (!interaction.guild) {
        return await interaction.reply({
            content: "This button only works inside a server.",
            flags: "Ephemeral",
        });
    }

    let categoryChannel = await interaction.guild.channels.fetch(categoryId);

    if (!categoryChannel || categoryChannel.type !== ChannelType.GuildCategory) {
        await interaction.reply({
            content: "That category no longer exists.",
            flags: "Ephemeral",
        });
        return;
    }

    await categoryChannel.permissionOverwrites.edit(interaction.user.id, {
        ViewChannel: true,
        SendMessages: true,
    });

    await interaction.reply({
        content: `Granted you access to ${categoryChannel.name}.`,
        flags: "Ephemeral",
    });
}

async function getCategory(interaction: ButtonInteraction | ChatInputCommandInteraction): Promise<CategoryChannel> {
    let errorMsg = "This command can only be used in the `general` or `info` channel of a CTF category.";

    if (!interaction.guild) {
        await interaction.reply({ content: errorMsg, flags: "Ephemeral" });
        throw "done";
    }

    if (!interaction.channel || interaction.channel.type !== ChannelType.GuildText
        || !["general", "info"].includes(interaction.channel.name)
        || !interaction.channel.parentId
    ) {
        await interaction.reply({ content: errorMsg, flags: "Ephemeral" });
        throw "done";
    }

    let category = interaction.channel.parentId && await interaction.guild.channels.fetch(interaction.channel.parentId);
    if (!category || category.type !== ChannelType.GuildCategory) {
        await interaction.reply({ content: errorMsg, flags: "Ephemeral" });
        throw "done";
    }

    let allChannels = await interaction.guild.channels.fetch();
    let categoryChildren = [...allChannels.values()].filter((channel) => {
        return channel !== null && "parentId" in channel && channel.parentId === category.id;
    });

    let info = categoryChildren.find((channel) => channel?.name === "info");
    let general = categoryChildren.find((channel) => channel?.name === "general");
    let challs = categoryChildren.find((channel) => channel?.name === "challs");

    if (
        !info || info.type !== ChannelType.GuildText ||
        !general || general.type !== ChannelType.GuildText ||
        !challs || challs.type !== ChannelType.GuildForum
    ) {
        await interaction.reply({ content: errorMsg, flags: "Ephemeral" });
        throw "done";
    }

    return category;
}