const { SlashCommandBuilder, ActionRowBuilder, StringSelectMenuBuilder, ChannelType } = require('discord.js');
const SlashBuild = require('../../utils/slash');
const embed = require('../../utils/embed');
const utils = require('../../utils/utils');

module.exports = new SlashBuild(
  new SlashCommandBuilder()
    .setName('test')
    .setDescription('Setup, edit, or delete AutoMod rules')
    .addSubcommand(subcommand =>
      subcommand.setName('setup')
        .setDescription('Setup AutoMod system'))
    .addSubcommand(subcommand =>
      subcommand.setName('edit')
        .setDescription('Edit an existing AutoMod rule'))
    .addSubcommand(subcommand =>
      subcommand.setName('delete')
        .setDescription('Delete an existing AutoMod rule')),
  async (interaction) => {
    const { guild, options } = interaction;
    const sub = options.getSubcommand();

    switch (sub) {
      case 'setup':
        const setupEmbed = embed.infos({ content: 'Select the type of rule you want to setup.' });

        const ruleSelectMenu = new StringSelectMenuBuilder()
          .setCustomId('select-rule')
          .setPlaceholder('Select a rule type')
          .addOptions([
            { label: 'Flagged Words', value: 'flagged-words' },
            { label: 'Spam Messages', value: 'spam-messages' },
            { label: 'Mention Spam', value: 'mention-spam' },
            { label: 'Keyword', value: 'keyword' }
          ]);

        const actionRow = new ActionRowBuilder().addComponents(ruleSelectMenu);

        await utils.editOrReply(interaction, { embeds: [setupEmbed], components: [actionRow] });

        // Collecting the interaction
        const filter = i => i.customId === 'select-rule' && i.user.id === interaction.user.id;
        const collector = interaction.channel.createMessageComponentCollector({ filter, time: 60000 });

        collector.on('collect', async i => {
          const selectedRule = i.values[0];
          await i.deferUpdate();

          await promptForLogChannel(interaction, selectedRule);
        });

        break;

      case 'edit':
        const editEmbed = embed.infos({ content: 'Please enter the ID of the rule you want to edit.' });

        await utils.editOrReply(interaction, { embeds: [editEmbed] });

        const filterEdit = response => response.author.id === interaction.user.id;
        const collectedEdit = await interaction.channel.awaitMessages({ filter: filterEdit, max: 1, time: 60000, errors: ['time'] }).catch(() => null);

        if (collectedEdit && collectedEdit.first()) {
          const ruleId = collectedEdit.first().content;

          await promptForEditOptions(interaction, ruleId);
        } else {
          await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'No input received within the time limit.' })], ephemeral: true });
        }

        break;

      case 'delete':
        const deleteEmbed = embed.infos({ content: 'Delete AutoMod rule feature is under development.' });
        await utils.editOrReply(interaction, { embeds: [deleteEmbed], ephemeral: true });
        // Implement delete functionality here
        break;
    }
  },
  {
    permissions: {
      user: ['ManageGuild'],
      client: ['ManageGuild']
    }
  }
);

async function promptForLogChannel(interaction, ruleType) {
  const channels = interaction.guild.channels.cache.filter(channel => channel.type === ChannelType.GuildText);
  
  const channelOptions = channels.map(channel => ({
    label: channel.name,
    value: channel.id
  }));

  const logChannelEmbed = embed.infos({ content: 'Select the channel where AutoMod should send logs.' });
  const channelSelectMenu = new StringSelectMenuBuilder()
    .setCustomId('select-log-channel')
    .setPlaceholder('Select a log channel')
    .addOptions(channelOptions);

  const actionRow = new ActionRowBuilder().addComponents(channelSelectMenu);
  await utils.editOrReply(interaction, { embeds: [logChannelEmbed], components: [actionRow] });

  const filter = i => i.customId === 'select-log-channel' && i.user.id === interaction.user.id;
  const collector = interaction.channel.createMessageComponentCollector({ filter, time: 60000 });

  collector.on('collect', async i => {
    const selectedChannelId = i.values[0];
    const logChannel = interaction.guild.channels.cache.get(selectedChannelId);
    await i.deferUpdate();
      
          console.log('Selected log channel:', logChannel);

    if (logChannel) {
      switch (ruleType) {
        case 'flagged-words':
          await setupFlaggedWordsRule(interaction, logChannel);
          break;
        case 'spam-messages':
          await setupSpamMessagesRule(interaction, logChannel);
          break;
        case 'mention-spam':
          await promptForMentionSpamOptions(interaction, logChannel);
          break;
        case 'keyword':
          await promptForKeywordOptions(interaction, logChannel);
          break;
      }
    }
  });
}

async function setupFlaggedWordsRule(interaction, logChannel) {
  console.log('Creating flagged words rule with log channel:', logChannel);
  const rule = await interaction.guild.autoModerationRules.create({
    name: `Block profanity, sexual content, and slurs by Atoms' AutoMod.`,
    creatorId: interaction.user.id,
    enabled: true,
    eventType: 1,
    triggerType: 4,
    triggerMetadata: { presets: [1, 2, 3] },
    actions: [{ type: 1, metadata: { channel: logChannel, durationSeconds: 10, customMessage: `This message was prevented by Atoms' AutoMod.` } }]
  }).catch(async err => {
    console.log(err);
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'An error occurred while creating the AutoMod rule.' })] });
  });

  if (rule) {
    await utils.editOrReply(interaction, { embeds: [embed.success({ content: 'AutoMod rule successfully created.' })] });
  }
}

async function setupSpamMessagesRule(interaction, logChannel) {
  console.log('Creating spam messages rule with log channel:', logChannel);
  const rule = await interaction.guild.autoModerationRules.create({
    name: `Prevent spam messages by Atoms' AutoMod.`,
    creatorId: interaction.user.id,
    enabled: true,
    eventType: 1,
    triggerType: 3,
    actions: [{ type: 1, metadata: { channel: logChannel, durationSeconds: 10, customMessage: `This message was prevented by Atoms' AutoMod.` } }]
  }).catch(async err => {
    console.log(err);
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'An error occurred while creating the AutoMod rule.' })] });
  });

  if (rule) {
    await utils.editOrReply(interaction, { embeds: [embed.success({ content: 'AutoMod rule successfully created.' })] });
  }
}

async function promptForMentionSpamOptions(interaction, logChannel) {
  const mentionSpamEmbed = embed.infos({ content: 'Please enter the number of mentions required to block a message.' });
  await utils.editOrReply(interaction, { embeds: [mentionSpamEmbed] });

  const filter = response => response.author.id === interaction.user.id;
  const collected = await interaction.channel.awaitMessages({ filter, max: 1, time: 60000, errors: ['time'] }).catch(() => null);

  if (collected && collected.first()) {
    const number = parseInt(collected.first().content, 10);

    if (isNaN(number)) {
      await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'Invalid number of mentions provided.' })], ephemeral: true });
    } else {
      await setupMentionSpamRule(interaction, number, logChannel);
    }
  } else {
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'No input received within the time limit.' })], ephemeral: true });
  }
}

async function setupMentionSpamRule(interaction, number, logChannel) {
  console.log('Creating mention spam rule with log channel:', logChannel);
  const rule = await interaction.guild.autoModerationRules.create({
    name: `Prevent spam mentions by Atoms' AutoMod.`,
    creatorId: interaction.user.id,
    enabled: true,
    eventType: 1,
    triggerType: 5,
    triggerMetadata: { mentionTotalLimit: number },
    actions: [{ type: 1, metadata: { channel: logChannel, durationSeconds: 10, customMessage: `This message was prevented by Atoms' AutoMod.` } }]
  }).catch(async err => {
    console.log(err);
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'An error occurred while creating the AutoMod rule.' })] });
  });

  if (rule) {
    await utils.editOrReply(interaction, { embeds: [embed.success({ content: 'AutoMod rule successfully created.' })] });
  }
}

async function promptForKeywordOptions(interaction, logChannel) {
  const keywordEmbed = embed.infos({ content: 'Please enter the keyword you want to block.' });
  await utils.editOrReply(interaction, { embeds: [keywordEmbed] });

  const filter = response => response.author.id === interaction.user.id;
  const collected = await interaction.channel.awaitMessages({ filter, max: 1, time: 60000, errors: ['time'] }).catch(() => null);

  if (collected && collected.first()) {
    const word = collected.first().content;

    await setupKeywordRule(interaction, word, logChannel);
  } else {
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'No input received within the time limit.' })], ephemeral: true });
  }
}

async function setupKeywordRule(interaction, word, logChannel) {
  console.log('Creating keyword rule with log channel:', logChannel);
  const rule = await interaction.guild.autoModerationRules.create({
    name: `Prevent the word ${word} from being used by Atoms' AutoMod.`,
    creatorId: interaction.user.id,
    enabled: true,
    eventType: 1,
    triggerType: 1,
    triggerMetadata: { keywordFilter: [word] },
    actions: [{ type: 1, metadata: { channel: logChannel, durationSeconds: 10, customMessage: `This message was prevented by Atoms' AutoMod.` } }]
  }).catch(async err => {
    console.log(err);
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'An error occurred while creating the AutoMod rule.' })] });
  });

  if (rule) {
    await utils.editOrReply(interaction, { embeds: [embed.success({ content: 'AutoMod rule successfully created.' })] });
  }
}

async function promptForEditOptions(interaction, ruleId) {
  const editOptionsEmbed = embed.infos({ content: 'Please enter the new value for the rule (either a keyword or number of mentions).' });
  await utils.editOrReply(interaction, { embeds: [editOptionsEmbed] });

  const filter = response => response.author.id === interaction.user.id;
  const collected = await interaction.channel.awaitMessages({ filter, max: 1, time: 60000, errors: ['time'] }).catch(() => null);

  if (collected && collected.first()) {
    const newValue = collected.first().content;

    const rule = await interaction.guild.autoModerationRules.fetch(ruleId).catch(async err => {
      console.log(err);
      await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'An error occurred while fetching the AutoMod rule.' })] });
    });

    if (rule) {
      if (rule.triggerType === 1) {
        await updateKeywordRule(interaction, rule, newValue);
      } else if (rule.triggerType === 5) {
        const number = parseInt(newValue, 10);
        if (isNaN(number)) {
          await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'Invalid number of mentions provided.' })], ephemeral: true });
        } else {
          await updateMentionSpamRule(interaction, rule, number);
        }
      }
    }
  } else {
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'No input received within the time limit.' })], ephemeral: true });
  }
}

async function updateKeywordRule(interaction, rule, newValue) {
  await rule.edit({
    triggerMetadata: { keywordFilter: [newValue] }
  }).catch(async err => {
    console.log(err);
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'An error occurred while updating the AutoMod rule.' })] });
  });

  await utils.editOrReply(interaction, { embeds: [embed.success({ content: 'AutoMod rule successfully updated.' })] });
}

async function updateMentionSpamRule(interaction, rule, newValue) {
  await rule.edit({
    triggerMetadata: { mentionTotalLimit: newValue }
  }).catch(async err => {
    console.log(err);
    await utils.editOrReply(interaction, { embeds: [embed.error({ content: 'An error occurred while updating the AutoMod rule.' })] });
  });

  await utils.editOrReply(interaction, { embeds: [embed.success({ content: 'AutoMod rule successfully updated.' })] });
}