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')
        .addStringOption(option =>
          option.setName('ruleid')
            .setDescription('The ID of the rule to edit')
            .setRequired(true))
    )
    .addSubcommand((subcommand) =>
      subcommand
        .setName('delete')
        .setDescription('Delete an existing AutoMod rule')
        .addStringOption(option =>
          option.setName('ruleid')
            .setDescription('The ID of the rule to delete')
            .setRequired(true))
    ),
  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 ruleId = interaction.options.getString('ruleid');
  await promptForEditDetails(interaction, ruleId);
}

async function handleDelete(interaction) {
  const ruleId = interaction.options.getString('ruleid');
  await deleteRule(interaction, ruleId);
}

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, or click the "Keep Current" button to retain the current value${isEdit ? ' (' + currentMaxMentions + ')' : ''}.` });

  const actionRow = new ActionRowBuilder().addComponents(
    new ButtonBuilder().setCustomId('keep-current').setLabel('Keep Current').setStyle(ButtonStyle.Primary)
  );

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

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

  collector.on('collect', async (i) => {
    let maxMentions;
    if (i.customId === 'keep-current') {
      maxMentions = currentMaxMentions;
    } else {
      const response = await utils.collectMessage(interaction, {
        prompt: 'Enter the maximum number of mentions allowed per message:',
        time: 120000,
      });

      if (response) {
        maxMentions = parseInt(response.content, 10);
      } else {
        return;
      }
    }

    await i.deferUpdate();
    await setupMentionSpamRule(interaction, timeout, logChannel, maxMentions, isEdit);
  });
}

async function setupMentionSpamRule(interaction, timeout, logChannel, maxMentions, isEdit) {
  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.BlockMessage },
        {
          type: AutoModerationActionType.Timeout,
          metadata: { durationSeconds: timeout },
        },
        { 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 promptForKeywordOptions(interaction, timeout, logChannel, isEdit, currentKeywords = null) {
  const keywordEmbed = embed.infos({ 
    content: `Please enter the keywords to be flagged, separated by commas, or click the "Keep Current" button to retain the current value${isEdit && currentKeywords ? ' (' + currentKeywords.join(', ') + ')' : ''}.` 
  });

  const actionRow = new ActionRowBuilder().addComponents(
    new ButtonBuilder().setCustomId('keep-current').setLabel('Keep Current').setStyle(ButtonStyle.Primary)
  );

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

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

  collector.on('collect', async (i) => {
    let keywords;
    if (i.customId === 'keep-current') {
      keywords = currentKeywords;
    } else {
      const response = await utils.collectMessage(interaction, {
        prompt: 'Enter the keywords to be flagged, separated by commas:',
        time: 120000,
      });

      if (response) {
        keywords = response.content.split(',').map(kw => kw.trim());
      } else {
        return;
      }
    }

    await i.deferUpdate();
    await setupKeywordRule(interaction, timeout, logChannel, keywords, isEdit);
  });
}

async function setupKeywordRule(interaction, timeout, logChannel, keywords, isEdit) {
  try {
    const rule = await interaction.guild.autoModerationRules.create({
      name: `Flag keywords by Atoms' AutoMod.`,
      creatorId: interaction.user.id,
      enabled: true,
      eventType: 1,
      triggerType: 1,
      triggerMetadata: { keywordFilter: keywords },
      actions: [
        { type: AutoModerationActionType.BlockMessage },
        {
          type: AutoModerationActionType.Timeout,
          metadata: { durationSeconds: timeout },
        },
        { 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 rule = await interaction.guild.autoModerationRules.fetch(ruleId);
  if (!rule) {
    await interaction.reply({ content: `Rule with ID ${ruleId} not found.`, ephemeral: true });
    return;
  }

  const ruleType = rule.triggerType === 1 ? 'keyword' :
                   rule.triggerType === 3 ? 'mention-spam' :
                   rule.triggerType === 4 ? 'flagged-words' : 'spam-messages';

  if (['mention-spam', 'keyword'].includes(ruleType)) {
    await promptForTimeout(interaction, ruleType, true, rule.actions.find(action => action.type === AutoModerationActionType.Timeout)?.metadata.durationSeconds || 0);
  } else {
    await promptForLogChannel(interaction, ruleType, 0, true, rule.actions.find(action => action.type === AutoModerationActionType.SendAlertMessage)?.metadata.channel || null);
  }
}

async function editRule(interaction, { keywords, maxMentions, timeout, logChannel, ruleId }) {
  try {
    const rule = await interaction.guild.autoModerationRules.fetch(ruleId);
    if (!rule) {
      await interaction.reply({ content: `Rule with ID ${ruleId} not found.`, ephemeral: true });
      return;
    }

    await rule.edit({
      triggerMetadata: {
        keywordFilter: keywords,
        mentionTotalLimit: maxMentions,
      },
      actions: [
        {
          type: AutoModerationActionType.BlockMessage,
          metadata: { customMessage: `This message was prevented by Atoms' AutoMod.` },
        },
        { type: AutoModerationActionType.SendAlertMessage, metadata: { channel: logChannel } },
        ...(timeout ? [{ type: AutoModerationActionType.Timeout, metadata: { durationSeconds: timeout } }] : []),
      ],
    });

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

async function deleteRule(interaction, ruleId) {
  try {
    const rule = await interaction.guild.autoModerationRules.fetch(ruleId);
    if (!rule) {
      await utils.editOrReply(interaction, { content: `Rule with ID ${ruleId} not found.`});
      return;
    }

    await rule.delete();

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

function handleRuleCreationError(interaction, err) {
 if (err.code === 20012) {
    utils.editOrReply(interaction, {
      embeds: [embed.error({ content: 'Maximum number of rules reached (10).' })],
      components: [],
    });
  } else {
    console.error(err);
  }
}