import { Message } from "discord.js";
import prisma from "./prisma";
import { logUnexpectedDiscordAPIError } from "../utilities";

export class EmojiUsageTracker {
  static async trackEmojiUsage(message: Message): Promise<void> {
    if (!message.guild) return;

    try {
      const guildId = message.guild.id;
      const customEmojiRegex = /<a?:(\w+):(\d+)>/g;
      const matches = message.content.matchAll(customEmojiRegex);

      for (const match of matches) {
        const emojiName = match[1];
        const emojiId = match[2];
        const emoji = message.guild.emojis.cache.get(emojiId);

        if (!emoji) continue;

        await this.recordEmojiUsage(guildId, emojiId, emojiName);
      }

      if (message.reactions.cache.size > 0)
        for (const reaction of message.reactions.cache.values()) {
          const emoji = reaction.emoji;

          if (emoji.id && message.guild.emojis.cache.has(emoji.id))
            await this.recordEmojiUsage(
              guildId,
              emoji.id,
              emoji.name || "unknown",
            );
        }
    } catch (error) {
      logUnexpectedDiscordAPIError(error);
    }
  }

  static async trackStickerUsage(message: Message): Promise<void> {
    if (!message.guild) return;

    try {
      const guildId = message.guild.id;

      for (const sticker of message.stickers.values())
        if (sticker.guildId === guildId)
          await this.recordStickerUsage(guildId, sticker.id, sticker.name);
    } catch (error) {
      logUnexpectedDiscordAPIError(error);
    }
  }

  private static async recordEmojiUsage(
    guildId: string,
    emojiId: string,
    emojiName: string,
  ): Promise<void> {
    try {
      const existing = await prisma.emojiUsage.findUnique({
        where: {
          guildId_emojiId: {
            guildId,
            emojiId,
          },
        },
      });

      if (existing) {
        await prisma.emojiUsage.update({
          where: {
            guildId_emojiId: {
              guildId,
              emojiId,
            },
          },
          data: {
            usageCount: existing.usageCount + 1,
            lastUsed: new Date(),
          },
        });
      } else {
        await prisma.emojiUsage.create({
          data: {
            guildId,
            emojiId,
            emojiName,
            usageCount: 1,
            firstUsed: new Date(),
            lastUsed: new Date(),
          },
        });
      }
    } catch (error) {
      logUnexpectedDiscordAPIError(error);
    }
  }

  private static async recordStickerUsage(
    guildId: string,
    stickerId: string,
    stickerName: string,
  ): Promise<void> {
    try {
      const existing = await prisma.stickerUsage.findUnique({
        where: {
          guildId_stickerId: {
            guildId,
            stickerId,
          },
        },
      });

      if (existing) {
        await prisma.stickerUsage.update({
          where: {
            guildId_stickerId: {
              guildId,
              stickerId,
            },
          },
          data: {
            usageCount: existing.usageCount + 1,
            lastUsed: new Date(),
          },
        });
      } else {
        await prisma.stickerUsage.create({
          data: {
            guildId,
            stickerId,
            stickerName,
            usageCount: 1,
            firstUsed: new Date(),
            lastUsed: new Date(),
          },
        });
      }
    } catch (error) {
      logUnexpectedDiscordAPIError(error);
    }
  }

  static async getEmojiStats(guildId: string, limit: number = 50) {
    try {
      return await prisma.emojiUsage.findMany({
        where: { guildId },
        orderBy: { usageCount: "desc" },
        take: limit,
      });
    } catch (error) {
      logUnexpectedDiscordAPIError(error);

      return [];
    }
  }

  static async getStickerStats(guildId: string, limit: number = 50) {
    try {
      return await prisma.stickerUsage.findMany({
        where: { guildId },
        orderBy: { usageCount: "desc" },
        take: limit,
      });
    } catch (error) {
      logUnexpectedDiscordAPIError(error);

      return [];
    }
  }

  // static async cleanupDeletedAssets(guildId: string): Promise<void> {
  //   try {
  //   } catch (error) {
  //     logUnexpectedDiscordAPIError(error);
  //   }
  // }
}