const messagesKv = new pylon.KVNamespace('messages');

const MAX_VALUE_LENGTH = 1024 * 8;
const MAX_ENTRIES_PER_KEY = 22;

type Maybe<T> = T | undefined;
type TransactCallback = (arr: Maybe<string[]>) => string[];
type HandlerCallback<T> = (arr: string[], id: T) => string[];

namespace handlers {
  export function wrap<T>(fn: HandlerCallback<T>, id: T): TransactCallback {
    return (arr) => {
      if (!arr) return [];

      return fn(arr, id);
    };
  }

  export function add(arr: string[], id: string): string[] {
    return arr.slice(-(MAX_VALUE_LENGTH / MAX_ENTRIES_PER_KEY)).concat(id);
  }

  export function remove(arr: string[], id: string): string[] {
    return arr.filter((x) => x !== id);
  }

  export function removeAll(arr: string[], ids: string[]): string[] {
    return arr.filter((x) => !ids.includes(x));
  }
}

discord.on(discord.Event.MESSAGE_CREATE, async (message) => {
  await messagesKv.transact<string[]>(message.channelId, handlers.wrap(handlers.add, message.id));
});

discord.on(discord.Event.MESSAGE_DELETE, async (message) => {
  await messagesKv.transact<string[]>(message.channelId, handlers.wrap(handlers.remove, message.id));
});

commands.on(
  {
    name: 'purge',
    filters: discord.command.filters.canManageMessages()
  },
  (args) => ({
    channel: args.guildTextChannel(),
    count: args.number()
  }),
  async (message, { channel, count }) => {
    const messages = await messagesKv
      .get<string[]>(channel.id)
      .then((x) => x?.slice(-count));

    if (!messages) return message.reply('no messages found');

    if (messages.length < 2 || messages.length > 100)
      return message.reply(
        `invalid count (expected >= 2 and <= 100; got=${messages.length})`
      );

    await channel.bulkDeleteMessages(messages);
    await messagesKv.transact<string[]>(channel.id, handlers.wrap(handlers.removeAll, messages));

    await message.reply(`ok, purged ${messages.length} messages..`);
  }
);