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

export const handlePinCommand = async (message: Message) => {
  if (message.author.bot) return;

  if (!message.content.startsWith("uma!pin")) return;

  const application = await message.client.application?.fetch();
  const ownerId = application?.owner?.id;

  if (message.author.id !== ownerId) return;

  const parameters = message.content.split(" ");

  if (parameters.length < 2) {
    await replyWithCleanup(
      message,
      "❌ Usage: `uma!pin <message_id> [message_id2] [message_id3] ...` or `uma!pin <channel_id> <message_id> [message_id2] ...`",
    );

    return;
  }

  let targetChannel = message.channel;
  let messageIds: string[] = [];
  const firstParameter = parameters[1];

  if (/^\d{17,19}$/.test(firstParameter)) {
    const potentialChannel = message.client.channels.cache.get(firstParameter);

    if (potentialChannel && potentialChannel.isTextBased()) {
      targetChannel = potentialChannel;
      messageIds = parameters.slice(2);
    } else {
      messageIds = parameters.slice(1);
    }
  } else {
    messageIds = parameters.slice(1);
  }

  if (messageIds.length === 0) {
    await replyWithCleanup(
      message,
      "❌ Please provide at least one message ID.",
    );

    return;
  }

  for (const messageId of messageIds)
    if (!/^\d{17,19}$/.test(messageId)) {
      await replyWithCleanup(
        message,
        "❌ Invalid message ID format. Please provide valid Discord message IDs.",
      );

      return;
    }

  try {
    const results: {
      success: boolean;
      messageId: string;
      action: string;
      error?: string;
    }[] = [];

    for (const messageId of messageIds) {
      try {
        const targetMessage = await targetChannel.messages.fetch(messageId);

        if (!targetMessage) {
          results.push({
            success: false,
            messageId,
            action: "fetch",
            error: "Message not found",
          });

          continue;
        }

        if (targetMessage.pinned) {
          await targetMessage.unpin();
          results.push({
            success: true,
            messageId,
            action: "unpin",
          });
        } else {
          await targetMessage.pin();
          results.push({
            success: true,
            messageId,
            action: "pin",
          });
        }
      } catch (error) {
        console.error(`Error processing message ${messageId}:`, error);
        results.push({
          success: false,
          messageId,
          action: "process",
          error: error instanceof Error ? error.message : "Unknown error",
        });
      }
    }

    await message.delete();

    const successCount = results.filter((r) => r.success).length;
    const failCount = results.filter((r) => !r.success).length;
    let resultMessage = `📌 Processed ${results.length} message(s):\n`;

    resultMessage += `✅ ${successCount} successful, ❌ ${failCount} failed\n\n`;

    for (const result of results)
      if (result.success) {
        resultMessage += `✅ ${result.messageId}: ${result.action}ned\n`;
      } else {
        resultMessage += `❌ ${result.messageId}: ${result.error}\n`;
      }

    if (targetChannel.isTextBased()) {
      const replyMessage = await (targetChannel as any).send(resultMessage);

      setTimeout(async () => {
        try {
          await replyMessage.delete();
        } catch (error) {
          console.error("Failed to delete result message:", error);
        }
      }, 10000);
    }
  } catch (error) {
    console.error("Error pinning message:", error);

    if (
      error instanceof Error &&
      error.message.includes("Missing Permissions")
    ) {
      await replyWithCleanup(
        message,
        "❌ Missing permissions to pin messages in this channel.",
      );
    } else if (
      error instanceof Error &&
      error.message.includes("Maximum number of pins")
    ) {
      await replyWithCleanup(
        message,
        "❌ Channel has reached maximum number of pinned messages (50). Unpin another message first.",
      );
    } else {
      await replyWithCleanup(
        message,
        "❌ Failed to pin the message. Message ID may be invalid.",
      );
    }
  }
};