import { decorators as d, IPluginOptions } from "knub";
import { ZeppelinPlugin, trimPluginDescription } from "./ZeppelinPlugin";
import { Embed, EmbedBase, GuildChannel, Message, TextChannel } from "eris";
import {
  errorMessage,
  getUrlsInString,
  messageLink,
  noop,
  successMessage,
  TDeepPartialProps,
  tNullable,
  tDeepPartial,
  UnknownUser,
  EMPTY_CHAR,
} from "../utils";
import path from "path";
import moment from "moment-timezone";
import { GuildSavedMessages } from "../data/GuildSavedMessages";
import { SavedMessage } from "../data/entities/SavedMessage";
import * as t from "io-ts";
import { GuildStarboardMessages } from "../data/GuildStarboardMessages";
import { StarboardMessage } from "../data/entities/StarboardMessage";
import { GuildStarboardReactions } from "../data/GuildStarboardReactions";

const StarboardOpts = t.type({
  channel_id: t.string,
  stars_required: t.number,
  star_emoji: tNullable(t.array(t.string)),
  enabled: tNullable(t.boolean),
});
type TStarboardOpts = t.TypeOf<typeof StarboardOpts>;

const ConfigSchema = t.type({
  boards: t.record(t.string, StarboardOpts),
  can_migrate: t.boolean,
});
type TConfigSchema = t.TypeOf<typeof ConfigSchema>;

const PartialConfigSchema = tDeepPartial(ConfigSchema);

const defaultStarboardOpts: Partial<TStarboardOpts> = {
  star_emoji: ["⭐"],
  enabled: true,
};

export class StarboardPlugin extends ZeppelinPlugin<TConfigSchema> {
  public static pluginName = "starboard";
  public static configSchema = ConfigSchema;

  public static pluginInfo = {
    prettyName: "Starboard",
    description: trimPluginDescription(`
      This plugin allows you to set up starboards on your server. Starboards are like user voted pins where messages with enough reactions get immortalized on a "starboard" channel.
    `),
    configurationGuide: trimPluginDescription(`
      ### Note on emojis
      To specify emoji in the config, you need to use the emoji's "raw form".
      To obtain this, post the emoji with a backslash in front of it.
      
      - Example with a default emoji: "\:star:" => "⭐"
      - Example with a custom emoji: "\:mrvnSmile:" => "<:mrvnSmile:543000534102310933>"

      ### Basic starboard
      Any message on the server that gets 5 star reactions will be posted into the starboard channel (604342689038729226).
      
      ~~~yml
      starboard:
        config:
          boards:
            basic:
              channel_id: "604342689038729226"
              stars_required: 5
      ~~~
      
      ### Custom star emoji
      This is identical to the basic starboard above, but accepts two emoji: the regular star and a custom :mrvnSmile: emoji
      
      ~~~yml
      starboard:
        config:
          boards:
            basic:
              channel_id: "604342689038729226"
              star_emoji: ["⭐", "<:mrvnSmile:543000534102310933>"]
              stars_required: 5
      ~~~
      
      ### Limit starboard to a specific channel
      This is identical to the basic starboard above, but only works from a specific channel (473087035574321152).
      
      ~~~yml
      starboard:
        config:
          boards:
            basic:
              enabled: false # The starboard starts disabled and is then enabled in a channel override below
              channel_id: "604342689038729226"
              stars_required: 5
        overrides:
          - channel: "473087035574321152"
            config:
              boards:
                basic:
                  enabled: true
      ~~~
    `),
  };

  protected savedMessages: GuildSavedMessages;
  protected starboardMessages: GuildStarboardMessages;
  protected starboardReactions: GuildStarboardReactions;

  private onMessageDeleteFn;

  public static getStaticDefaultOptions(): IPluginOptions<TConfigSchema> {
    return {
      config: {
        can_migrate: false,
        boards: {},
      },

      overrides: [
        {
          level: ">=100",
          config: {
            can_migrate: true,
          },
        },
      ],
    };
  }

  protected static preprocessStaticConfig(config: t.TypeOf<typeof PartialConfigSchema>) {
    if (config.boards) {
      for (const [name, opts] of Object.entries(config.boards)) {
        config.boards[name] = Object.assign({}, defaultStarboardOpts, config.boards[name]);
      }
    }

    return config;
  }

  protected getStarboardOptsForStarboardChannel(starboardChannel): TStarboardOpts[] {
    const config = this.getConfigForChannel(starboardChannel);

    const configs = Object.values(config.boards).filter(opts => opts.channel_id === starboardChannel.id);
    configs.forEach(cfg => {
      if (cfg.enabled == null) cfg.enabled = defaultStarboardOpts.enabled;
      if (cfg.star_emoji == null) cfg.star_emoji = defaultStarboardOpts.star_emoji;
      if (cfg.stars_required == null) cfg.stars_required = defaultStarboardOpts.stars_required;
    });

    return configs;
  }

  onLoad() {
    this.savedMessages = GuildSavedMessages.getGuildInstance(this.guildId);
    this.starboardMessages = GuildStarboardMessages.getGuildInstance(this.guildId);
    this.starboardReactions = GuildStarboardReactions.getGuildInstance(this.guildId);

    this.onMessageDeleteFn = this.onMessageDelete.bind(this);
    this.savedMessages.events.on("delete", this.onMessageDeleteFn);
  }

  onUnload() {
    this.savedMessages.events.off("delete", this.onMessageDeleteFn);
  }

  /**
   * When a reaction is added to a message, check if there are any applicable starboards and if the reactions reach
   * the required threshold. If they do, post the message in the starboard channel.
   */
  @d.event("messageReactionAdd")
  @d.lock("starboardReaction")
  async onMessageReactionAdd(msg: Message, emoji: { id: string; name: string }, userId: string) {
    if (!msg.author) {
      // Message is not cached, fetch it
      try {
        msg = await msg.channel.getMessage(msg.id);
      } catch (e) {
        // Sometimes we get this event for messages we can't fetch with getMessage; ignore silently
        return;
      }
    }

    // No self-votes!
    if (msg.author.id === userId) return;

    const user = await this.resolveUser(userId);
    if (user instanceof UnknownUser) return;
    if (user.bot) return;

    const config = this.getConfigForMemberIdAndChannelId(userId, msg.channel.id);
    const applicableStarboards = Object.values(config.boards)
      .filter(board => board.enabled)
      // Can't star messages in the starboard channel itself
      .filter(board => board.channel_id !== msg.channel.id)
      // Matching emoji
      .filter(board => {
        return board.star_emoji.some((boardEmoji: string) => {
          if (emoji.id) {
            // Custom emoji
            const customEmojiMatch = boardEmoji.match(/^<?:.+?:(\d+)>?$/);
            if (customEmojiMatch) {
              return customEmojiMatch[1] === emoji.id;
            }

            return boardEmoji === emoji.id;
          } else {
            // Unicode emoji
            return emoji.name === boardEmoji;
          }
        });
      });

    for (const starboard of applicableStarboards) {
      // Save reaction into the database
      await this.starboardReactions.createStarboardReaction(msg.id, userId).catch(noop);

      // If the message has already been posted to this starboard, we don't need to do anything else
      const starboardMessages = await this.starboardMessages.getMatchingStarboardMessages(starboard.channel_id, msg.id);
      if (starboardMessages.length > 0) continue;

      const reactions = await this.starboardReactions.getAllReactionsForMessageId(msg.id);
      const reactionsCount = reactions.length;
      if (reactionsCount >= starboard.stars_required) {
        await this.saveMessageToStarboard(msg, starboard.channel_id);
      }
    }
  }

  @d.event("messageReactionRemove")
  async onStarboardReactionRemove(msg: Message, emoji: { id: string; name: string }, userId: string) {
    await this.starboardReactions.deleteStarboardReaction(msg.id, userId);
  }

  @d.event("messageReactionRemoveAll")
  async onMessageReactionRemoveAll(msg: Message) {
    await this.starboardReactions.deleteAllStarboardReactionsForMessageId(msg.id);
  }

  /**
   * Saves/posts a message to the specified starboard.
   * The message is posted as an embed and image attachments are included as the embed image.
   */
  async saveMessageToStarboard(msg: Message, starboardChannelId: string) {
    const channel = this.guild.channels.get(starboardChannelId);
    if (!channel) return;

    const time = moment(msg.timestamp, "x").format("YYYY-MM-DD [at] HH:mm:ss [UTC]");

    const embed: EmbedBase = {
      footer: {
        text: `#${(msg.channel as GuildChannel).name}`,
      },
      author: {
        name: `${msg.author.username}#${msg.author.discriminator}`,
      },
      timestamp: new Date(msg.timestamp).toISOString(),
    };

    if (msg.author.avatarURL) {
      embed.author.icon_url = msg.author.avatarURL;
    }

    if (msg.content) {
      embed.description = msg.content;
    }

    // Include attachments
    if (msg.attachments.length) {
      const attachment = msg.attachments[0];
      const ext = path
        .extname(attachment.filename)
        .slice(1)
        .toLowerCase();
      if (["jpeg", "jpg", "png", "gif", "webp"].includes(ext)) {
        embed.image = { url: attachment.url };
      }
    }

    // Include any embed images in the original message
    if (msg.embeds.length && msg.embeds[0].image) {
      embed.image = msg.embeds[0].image;
    }

    embed.fields = [{ name: EMPTY_CHAR, value: `[Jump to message](${messageLink(msg)})` }];

    const starboardMessage = await (channel as TextChannel).createMessage({ embed });
    await this.starboardMessages.createStarboardMessage(channel.id, msg.id, starboardMessage.id);
  }

  /**
   * Remove a message from the specified starboard
   */
  async removeMessageFromStarboard(msg: StarboardMessage) {
    await this.bot.deleteMessage(msg.starboard_channel_id, msg.starboard_message_id).catch(noop);
  }

  async removeMessageFromStarboardMessages(starboard_message_id: string, channel_id: string) {
    await this.starboardMessages.deleteStarboardMessage(starboard_message_id, channel_id);
  }

  /**
   * When a message is deleted, also delete it from any starboards it's been posted in.
   * Likewise, if a starboard message (i.e. the bot message in the starboard) is deleted, remove it from the database.
   * This function is called in response to GuildSavedMessages events.
   */
  async onMessageDelete(msg: SavedMessage) {
    // Deleted source message
    const starboardMessages = await this.starboardMessages.getStarboardMessagesForMessageId(msg.id);
    for (const starboardMessage of starboardMessages) {
      this.removeMessageFromStarboard(starboardMessage);
    }

    // Deleted message from the starboard
    const deletedStarboardMessages = await this.starboardMessages.getStarboardMessagesForStarboardMessageId(msg.id);
    if (deletedStarboardMessages.length === 0) return;

    for (const starboardMessage of deletedStarboardMessages) {
      this.removeMessageFromStarboardMessages(
        starboardMessage.starboard_message_id,
        starboardMessage.starboard_channel_id,
      );
    }
  }

  @d.command("starboard migrate_pins", "<pinChannel:channel> <starboardName:string>", {
    extra: {
      info: {
        description:
          "Posts all pins from a channel to the specified starboard. The pins are NOT unpinned automatically.",
      },
    },
  })
  @d.permission("can_migrate")
  async migratePinsCmd(msg: Message, args: { pinChannel: GuildChannel; starboardName: string }) {
    const config = await this.getConfig();
    const starboard = config.boards[args.starboardName];
    if (!starboard) {
      this.sendErrorMessage(msg.channel, "Unknown starboard specified");
      return;
    }

    if (!(args.pinChannel instanceof TextChannel)) {
      this.sendErrorMessage(msg.channel, "Unknown/invalid pin channel id");
      return;
    }

    const starboardChannel = this.guild.channels.get(starboard.channel_id);
    if (!starboardChannel || !(starboardChannel instanceof TextChannel)) {
      this.sendErrorMessage(msg.channel, "Starboard has an unknown/invalid channel id");
      return;
    }

    msg.channel.createMessage(`Migrating pins from <#${args.pinChannel.id}> to <#${starboardChannel.id}>...`);

    const pins = await args.pinChannel.getPins();
    pins.reverse(); // Migrate pins starting from the oldest message

    for (const pin of pins) {
      const existingStarboardMessage = await this.starboardMessages.getMatchingStarboardMessages(
        starboardChannel.id,
        pin.id,
      );
      if (existingStarboardMessage.length > 0) continue;
      await this.saveMessageToStarboard(pin, starboardChannel.id);
    }

    this.sendSuccessMessage(msg.channel, `Pins migrated from <#${args.pinChannel.id}> to <#${starboardChannel.id}>!`);
  }
}