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

const ruleTypes = [
  { label: 'Flagged Words', value: 'flagged-words' },
  { label: 'Spam Messages', value: 'spam-messages' },
  { label: 'Mention Spam', value: 'mention-spam' },
  { label: 'Keyword', value: 'keyword' },
];

const timeoutOptions = [
  { label: 'No timeout', value: '0' },
  { label: '60 seconds', value: '60' },
  { label: '5 minutes', value: '300' },
  { label: '10 minutes', value: '600' },
  { label: '1 hour', value: '3600' },
  { label: '1 day', value: '86400' },
  { label: '1 week', value: '604800' },
];

module.exports = new SlashBuild(
  new SlashCommandBuilder()
    .setName('automod')
    .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();

    if (sub === 'setup') {
      await handleSetup(interaction);
    } else if (sub === 'edit') {
      await handleEdit(interaction);
    } else if (sub === 'delete') {
      await handleDelete(interaction);
    }
  },
  {
    permissions: {
      user: ['ManageGuild'],
      client: ['ManageGuild'],
    },
  }
);

async function handleSetup(interaction) {
  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(ruleTypes);

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

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

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

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

    if (['mention-spam', 'keyword'].includes(selectedRule)) {
      await promptForTimeout(interaction, selectedRule, false);
    } else {
      await promptForLogChannel(interaction, selectedRule, 0, false);
    }
  });
}

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

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

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

  if (collectedEdit && collectedEdit.first()) {
    const ruleId = collectedEdit.first().content;
    await promptForEditDetails(interaction, ruleId);
  } else {
    await utils.editOrReply(interaction, {
      embeds: [embed.error({ content: 'No input received within the time limit.' })],
    });
  }
}

async function handleDelete(interaction) {
  const deleteEmbed = embed.infos({ content: 'Please enter the ID of the rule you want to delete.' });

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

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

  if (collectedDelete && collectedDelete.first()) {
    const ruleId = collectedDelete.first().content;
    await deleteRule(interaction, ruleId);
  } else {
    await utils.editOrReply(interaction, {
      embeds: [embed.error({ content: 'No input received within the time limit.' })],
    });
  }
}

async function promptForTimeout(interaction, ruleType, isEdit, currentTimeout = null) {
  const timeoutEmbed = embed.infos({ content: 'Please select the timeout duration.' });

  const timeoutSelectMenu = new StringSelectMenuBuilder()
    .setCustomId('select-timeout')
    .setPlaceholder('Select a timeout duration')
    .addOptions(
      isEdit
        ? timeoutOptions.concat({ label: 'Keep current', value: 'keep' })
        : timeoutOptions
    );

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

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

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

  collector.on('collect', async (i) => {
    const timeout = i.values[0] === 'keep' ? currentTimeout : parseInt(i.values[0], 10);
    await i.deferUpdate();
    await promptForLogChannel(interaction, ruleType, timeout, isEdit);
  });
}

async function promptForLogChannel(interaction, ruleType, timeout, isEdit, currentLogChannel = null) {
  const logChannelEmbed = embed.infos({ content: 'Please select a log channel for AutoMod actions.' });

  const channelSelectMenu = new StringSelectMenuBuilder()
    .setCustomId('select-log-channel')
    .setPlaceholder('Select a log channel')
    .addOptions(
      interaction.guild.channels.cache
        .filter((channel) => channel.type === ChannelType.GuildText)
        .map((channel) => ({ label: channel.name, value: channel.id }))
        .concat(isEdit ? { label: 'Keep current', value: 'keep' } : [])
    );

  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: 120000 });

  collector.on('collect', async (i) => {
    const selectedChannel = i.values[0] === 'keep' ? currentLogChannel : i.values[0];
    await i.deferUpdate();

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

async function setupFlaggedWordsRule(interaction, logChannel) {
  try {
    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: AutoModerationActionType.BlockMessage,
          metadata: { customMessage: `This message was prevented by Atoms' AutoMod.` },
        },
        { type: AutoModerationActionType.SendAlertMessage, metadata: { channel: logChannel } },
      ],
    });

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

async function setupSpamMessagesRule(interaction, logChannel) {
  try {
    const rule = await interaction.guild.autoModerationRules.create({
      name: `Prevent spam messages by Atoms' AutoMod.`,
      creatorId: interaction.user.id,
      enabled: true,
      eventType: 1,
      triggerType: 5,
      actions: [
        { type: AutoModerationActionType.BlockMessage },
        { type: AutoModerationActionType.SendAlertMessage, metadata: { channel: logChannel } },
      ],
    });

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

async function promptForMentionSpamOptions(interaction, timeout, logChannel, isEdit, currentMaxMentions = null) {
  const mentionSpamEmbed = embed.infos({ content: `Please enter the maximum number of mentions allowed per message${isEdit ? ' or type "Keep" to retain the current value (' + currentMaxMentions + ')' : ''}.` });

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

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

  if (collected && collected.first()) {
    const input = collected.first().content;
    const maxMentions = input.toLowerCase() === 'keep' && isEdit ? currentMaxMentions : parseInt(input, 10);

    if (!isNaN(maxMentions)) {
      if (isEdit) {
        await editMentionSpamRule(interaction, maxMentions, timeout, logChannel);
      } else {
        await setupMentionSpamRule(interaction, maxMentions, timeout, logChannel);
      }
    } else {
      await utils.editOrReply(interaction, {
        embeds: [embed.error({ content: 'Invalid number. Please enter a valid number of mentions.' })],
      });
    }
  } else {
    await utils.editOrReply(interaction, {
      embeds: [embed.error({ content: 'No input received within the time limit.' })],
    });
  }
}

async function promptForKeywordOptions(interaction, timeout, logChannel, isEdit, currentKeyword = null) {
  const keywordEmbed = embed.infos({ content: `Please enter the keyword or phrase you want to block${isEdit ? ' or type "Keep" to retain the current keyword (' + currentKeyword + ')' : ''}.` });

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

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

  if (collected && collected.first()) {
    const input = collected.first().content;
    const keyword = input.toLowerCase() === 'keep' && isEdit ? currentKeyword : input;

    if (keyword) {
      if (isEdit) {
        await editKeywordRule(interaction, keyword, timeout, logChannel);
      } else {
        await setupKeywordRule(interaction, keyword, timeout, logChannel);
      }
    } else {
      await utils.editOrReply(interaction, {
        embeds: [embed.error({ content: 'Invalid input. Please enter a valid keyword or phrase.' })],
      });
    }
  } else {
    await utils.editOrReply(interaction, {
      embeds: [embed.error({ content: 'No input received within the time limit.' })],
    });
  }
}

async function setupMentionSpamRule(interaction, maxMentions, timeout, logChannel) {
  try {
    const rule = await interaction.guild.autoModerationRules.create({
      name: `Prevent mention spam by Atoms' AutoMod.`,
      creatorId: interaction.user.id,
      enabled: true,
      eventType: 1,
      triggerType: 3,
      triggerMetadata: { mentionTotalLimit: maxMentions },
      actions: [
        {
          type: AutoModerationActionType.Timeout,
          metadata: { durationSeconds: timeout, customMessage: `This message was prevented by Atoms' AutoMod.` },
        },
        { type: AutoModerationActionType.SendAlertMessage, metadata: { channel: logChannel } },
      ],
    });

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

async function setupKeywordRule(interaction, keyword, timeout, logChannel) {
  try {
    const rule = await interaction.guild.autoModerationRules.create({
      name: `Block keyword: "${keyword}" by Atoms' AutoMod.`,
      creatorId: interaction.user.id,
      enabled: true,
      eventType: 1,
      triggerType: 1,
      triggerMetadata: { keywordFilter: [keyword] },
      actions: [
        {
          type: AutoModerationActionType.Timeout,
          metadata: { durationSeconds: timeout, customMessage: `This message was prevented by Atoms' AutoMod.` },
        },
        { type: AutoModerationActionType.SendAlertMessage, metadata: { channel: logChannel } },
      ],
    });

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

async function promptForEditDetails(interaction, ruleId) {
  const existingRule = await interaction.guild.autoModerationRules.fetch(ruleId);
  if (!existingRule) {
    await utils.editOrReply(interaction, {
      embeds: [embed.error({ content: 'No rule found with the provided ID.' })],
    });
    return;
  }

  const ruleType = getRuleTypeFromExistingRule(existingRule);
  const currentTimeout = existingRule.actions.find((action) => action.type === AutoModerationActionType.Timeout)?.metadata?.durationSeconds || null;
  const currentLogChannel = existingRule.actions.find((action) => action.type === AutoModerationActionType.SendAlertMessage)?.metadata?.channel || null;
  const currentKeyword = ruleType === 'keyword' ? existingRule.triggerMetadata.keywordFilter[0] : null;
  const currentMaxMentions = ruleType === 'mention-spam' ? existingRule.triggerMetadata.mentionTotalLimit : null;

  if (['mention-spam', 'keyword'].includes(ruleType)) {
    if (ruleType === 'mention-spam') {
      await promptForMentionSpamOptions(interaction, currentTimeout, currentLogChannel, true, currentMaxMentions);
    } else if (ruleType === 'keyword') {
      await promptForKeywordOptions(interaction, currentTimeout, currentLogChannel, true, currentKeyword);
    }
  } else {
    await promptForLogChannel(interaction, ruleType, currentTimeout, true, currentLogChannel);
  }
}

function getRuleTypeFromExistingRule(rule) {
  switch (rule.triggerType) {
    case 1:
      return 'keyword';
    case 3:
      return 'mention-spam';
    case 4:
      return 'flagged-words';
    case 5:
      return 'spam-messages';
    default:
      return 'unknown';
  }
}

async function editMentionSpamRule(interaction, maxMentions, timeout, logChannel) {
  try {
    const ruleId = interaction.options.getString('ruleId');
    const rule = await interaction.guild.autoModerationRules.edit(ruleId, {
      triggerMetadata: { mentionTotalLimit: maxMentions },
      actions: [
        {
          type: AutoModerationActionType.Timeout,
          metadata: { durationSeconds: timeout, customMessage: `This message was prevented by Atoms' AutoMod.` },
        },
        { type: AutoModerationActionType.SendAlertMessage, metadata: { channel: logChannel } },
      ],
    });

    if (rule) {
      await utils.editOrReply(interaction, {
        embeds: [embed.success({ content: 'AutoMod rule successfully edited.' })],
        components: [],
      });
    }
  } catch (err) {
    handleRuleCreationError(interaction, err);
  }
}

async function editKeywordRule(interaction, keyword, timeout, logChannel) {
  try {
    const ruleId = interaction.options.getString('ruleId');
    const rule = await interaction.guild.autoModerationRules.edit(ruleId, {
      triggerMetadata: { keywordFilter: [keyword] },
      actions: [
        {
          type: AutoModerationActionType.Timeout,
          metadata: { durationSeconds: timeout, customMessage: `This message was prevented by Atoms' AutoMod.` },
        },
        { type: AutoModerationActionType.SendAlertMessage, metadata: { channel: logChannel } },
      ],
    });

    if (rule) {
      await utils.editOrReply(interaction, {
        embeds: [embed.success({ content: 'AutoMod rule successfully edited.' })],
        components: [],
      });
    }
  } catch (err) {
    handleRuleCreationError(interaction, err);
  }
}

async function deleteRule(interaction, ruleId) {
  try {
    await interaction.guild.autoModerationRules.delete(ruleId);
    await utils.editOrReply(interaction, {
      embeds: [embed.success({ content: 'AutoMod rule successfully deleted.' })],
      components: [],
    });
  } catch (err) {
    handleRuleCreationError(interaction, err);
  }
}

function handleRuleCreationError(interaction, err) {
  if (err.message.includes('Maximum number of rules reached')) {
    utils.editOrReply(interaction, {
      embeds: [embed.error({ content: 'You have reached the maximum number of rules for this guild.' })],
    });
  } else {
    console.log(err);
    utils.editOrReply(interaction, {
      embeds: [embed.error({ content: `An error occurred: ${err.message}` })],
    });
  }
}