/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */

import { AutoRouter } from "itty-router";
import { InteractionResponseType, InteractionType } from "discord-interactions";
import {
  HOT_COMMAND,
  ROLEPLAY_COMMAND,
  NSFW_COMMAND,
  TOP_COMMAND,
  COMPLAIN_COMMAND,
  APPEAL_COMMAND,
  COLOURS_COMMAND,
  ROLEPLAY_VERIFY_COMMAND,
  TOGGLE_PRIVILEGED_ACCESS_COMMAND,
  ROLE_COMMAND,
} from "./discord/commands";
import {
  getCutePost,
  getRoleplayPost,
  getNSFWPost,
  getTopPost,
} from "./reddit.ts";
import type { TimePeriod } from "./discord/types.ts";
import type { Environment, DiscordEmbed } from "./discord/interfaces.ts";
import {
  createPostEmbed,
  createComplaintEmbed,
  createAppealEmbed,
  createRoleDistributionEmbed,
} from "./discord/embeds.ts";
import { JSONResponse } from "./discord/responses.ts";
import { verifyDiscordRequest } from "./discord/verification.ts";
import {
  CENTRAL_GUILD_ID,
  ROLEPLAY_GUILD_ID,
  COLOR_ROLE_IDS,
  CENTRAL_STAFF_ROLES,
  CENTRAL_PRIVILEGED_ACCESS_ROLE_ID,
  ROLEPLAY_ADMINISTRATOR_ROLE_ID,
} from "../shared";

const router = AutoRouter();
const COMPLAINT_CHANNEL_ID = "1415868433714778204";
const APPEAL_CHANNEL_ID = "1420340807931531385";
const VERIFIED_ROLEPLAY_ROLE_ID = "1418311833303122021";
const ROLE_MANAGER_ROLE_ID = "1410993207608873070";
const ART_MEDIA_ROLE_ID = "1410333831281643630";
const ROLEPLAY_NSFW_ROLE_ID = "1418391675050528879";
const OWNER_ROLE_ID = "1406422617765712095";
const ADMINISTRATOR_ROLE_ID = "1406422617765712094";
const MODERATOR_ROLE_ID = "1406422617765712093";
const TRIAL_MODERATOR_ROLE_ID = "1406422617724026910";

const ALLOWED_ROLE_IDS: readonly string[] = [
  MODERATOR_ROLE_ID,
  TRIAL_MODERATOR_ROLE_ID,
  "1436486313770483812", // Probationary Staff
  "1411116123302400010", // Reddit Moderator
  "1410993207608873070", // Minecraft Server Staff
  "1416917764546756618", // Quote Curator
  "1419243376938582057", // Event Planner
  "1423510107685261354", // Moderation Team Staging
  "1428143899712426084", // Tracen Academy Joint Staff
  "1417624486345179187", // Top Buddy of the Month
  "1435764652591022144", // Staff
  "1425706904478289928", // Removed from Privileged Access
  "1435760220805660713", // Removed from Vent Access
  "1423213971422580736", // Privileged Access
  "1410333831281643630", // Art & Media NSFW
  "1418391675050528879", // Roleplay NSFW
  "1410328679392743476", // Ambassador

  // Tracen Academy
  "1434710765604049027", // Certified Trainer
  "1428173099270148173", // Race Planner
  "1423919137335545961", // Event Planner
  "1423919137335545967", // Moderator
  "1423919137335545966", // Trial Moderator
  "1438031082048979124", // Staff
  "1423919137335545960", // Moderation Team Staging
  "1423919137335545965", // Reddit Moderator
];

const sendComplaintToChannel = async (
  environment: Environment,
  embed: DiscordEmbed,
): Promise<boolean> => {
  const url = `https://discord.com/api/v10/channels/${COMPLAINT_CHANNEL_ID}/messages`;

  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bot ${environment.DISCORD_TOKEN}`,
      },
      body: JSON.stringify({
        embeds: [embed],
      }),
    });

    return response.ok;
  } catch (error) {
    console.error("Error sending complaint to channel:", error);

    return false;
  }
};

const sendAppealToChannel = async (
  environment: Environment,
  embed: DiscordEmbed,
): Promise<boolean> => {
  const url = `https://discord.com/api/v10/channels/${APPEAL_CHANNEL_ID}/messages`;

  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bot ${environment.DISCORD_TOKEN}`,
      },
      body: JSON.stringify({
        embeds: [embed],
      }),
    });

    return response.ok;
  } catch (error) {
    console.error("Error sending appeal to channel:", error);

    return false;
  }
};

const fetchRoleDistribution = async (
  environment: Environment,
  guildID: string,
): Promise<Array<{ name: string; count: number }>> => {
  const roleData: Array<{ name: string; count: number }> = [];

  try {
    const guildResponse = await fetch(
      `https://discord.com/api/v10/guilds/${guildID}`,
      {
        headers: {
          Authorization: `Bot ${environment.DISCORD_TOKEN}`,
        },
      },
    );

    if (!guildResponse.ok) {
      console.error(
        "Failed to fetch guild data:",
        guildResponse.status,
        guildResponse.statusText,
      );

      const errorText = await guildResponse.text();

      console.error("Error details:", errorText);

      return roleData;
    }

    const guild = await guildResponse.json();

    for (const roleID of COLOR_ROLE_IDS) {
      const role = guild.roles?.find((r: any) => r.id === roleID);

      if (role) {
        roleData.push({
          name: role.name,
          count: 0,
        });
      } else {
        console.log(`Role not found: ${roleID}`);
      }
    }

    let after = "";
    let hasMore = true;
    let batchCount = 0;
    const maxBatches = 10;

    while (hasMore && batchCount < maxBatches) {
      const membersResponse = await fetch(
        `https://discord.com/api/v10/guilds/${guildID}/members?limit=1000${after ? `&after=${after}` : ""}`,
        {
          headers: {
            Authorization: `Bot ${environment.DISCORD_TOKEN}`,
          },
        },
      );

      if (membersResponse.status === 429) {
        const retryAfter = membersResponse.headers.get("Retry-After");
        const resetAfter = membersResponse.headers.get(
          "X-RateLimit-Reset-After",
        );
        const scope = membersResponse.headers.get("X-RateLimit-Scope");

        console.log(
          `Rate limited! Scope: ${scope}, Retry-After: ${retryAfter}, Reset-After: ${resetAfter}`,
        );

        const delayMs = Math.max(
          retryAfter ? parseFloat(retryAfter) * 1000 : 0,
          resetAfter ? parseFloat(resetAfter) * 1000 : 0,
        );

        if (delayMs > 0) {
          console.log(`Waiting ${delayMs}ms before retry ...`);

          await new Promise((resolve) => setTimeout(resolve, delayMs));

          continue;
        }
      }

      if (!membersResponse.ok) {
        console.error(
          "Failed to fetch members:",
          membersResponse.status,
          membersResponse.statusText,
        );

        const errorText = await membersResponse.text();

        console.error("Members error details:", errorText);

        break;
      }

      const remaining = membersResponse.headers.get("X-RateLimit-Remaining");
      const resetAfter = membersResponse.headers.get("X-RateLimit-Reset-After");

      if (remaining === "0" && resetAfter) {
        console.log(`Rate limit bucket empty, waiting ${resetAfter}s...`);

        await new Promise((resolve) =>
          setTimeout(resolve, parseFloat(resetAfter) * 1000),
        );
      }

      const members = await membersResponse.json();

      for (const member of members)
        for (const roleId of member.roles || []) {
          const roleIndex = COLOR_ROLE_IDS.indexOf(roleId);

          if (roleIndex !== -1) roleData[roleIndex].count++;
        }

      hasMore = members.length === 1000;

      if (hasMore && members.length > 0)
        after = members[members.length - 1].user.id;

      batchCount += 1;
    }

    roleData.sort((a, b) => b.count - a.count);
  } catch (error) {
    console.error("Error fetching role distribution:", error);
  }

  return roleData;
};

router.get("/", (_request: Request, environment: Environment) => {
  return new Response(`👋 ${environment.DISCORD_APPLICATION_ID}`);
});

router.post("/", async (request: Request, environment: Environment) => {
  const { isValid, interaction } = await server.verifyDiscordRequest(
    request,
    environment,
  );

  if (!isValid || !interaction)
    return new Response("Bad request signature.", { status: 401 });

  if (interaction.type === InteractionType.PING)
    return new JSONResponse({
      type: InteractionResponseType.PONG,
    });

  if (interaction.type === InteractionType.APPLICATION_COMMAND) {
    switch (interaction.data.name.toLowerCase()) {
      case HOT_COMMAND.name.toLowerCase(): {
        try {
          const post = await getCutePost();
          const embed = createPostEmbed(post);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              embeds: [embed],
            },
          });
        } catch (error) {
          console.error("Error in hot command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ No posts found. Try again later!",
              flags: 64,
            },
          });
        }
      }

      case ROLEPLAY_COMMAND.name.toLowerCase(): {
        try {
          const post = await getRoleplayPost();
          const embed = createPostEmbed(post);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              embeds: [embed],
            },
          });
        } catch (error) {
          console.error("Error in roleplay command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ No roleplay posts found. Try again later!",
              flags: 64,
            },
          });
        }
      }

      case NSFW_COMMAND.name.toLowerCase(): {
        if (!interaction.channel_id || !interaction.channel?.nsfw) {
          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ This command can only be used in NSFW channels.",
              flags: 64,
            },
          });
        }

        try {
          const post = await getNSFWPost();
          const embed = createPostEmbed(post);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              embeds: [embed],
            },
          });
        } catch (error) {
          console.error("Error in NSFW command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ No NSFW posts found. Try again later!",
              flags: 64,
            },
          });
        }
      }

      case TOP_COMMAND.name.toLowerCase(): {
        try {
          const time =
            (interaction.data.options?.[0]?.value as TimePeriod) || "day";
          const post = await getTopPost(time);
          const embed = createPostEmbed(post);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              embeds: [embed],
            },
          });
        } catch (error) {
          console.error("Error in top command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ No top posts found. Try again later!",
              flags: 64,
            },
          });
        }
      }

      case COMPLAIN_COMMAND.name.toLowerCase(): {
        try {
          const complaintMessage = interaction.data.options?.[0]
            ?.value as string;

          if (!complaintMessage)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content: "❌ Please provide a message for your complaint.",
                flags: 64,
              },
            });

          const complainant = {
            username:
              interaction.member?.user?.username ||
              interaction.user?.username ||
              "Unknown",
            id:
              interaction.member?.user?.id || interaction.user?.id || "Unknown",
            avatar:
              interaction.member?.user?.avatar || interaction.user?.avatar,
          };
          const isDM = !interaction.guild_id;
          const complaintEmbed = createComplaintEmbed(
            complaintMessage,
            complainant,
            Date.now(),
            isDM,
          );
          const success = await sendComplaintToChannel(
            environment,
            complaintEmbed,
          );

          if (success) {
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content: "✅ Your complaint has been submitted successfully!",
                flags: 64,
              },
            });
          } else {
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Failed to submit your complaint. Please try again later.",
                flags: 64,
              },
            });
          }
        } catch (error) {
          console.error("Error in complain command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ An error occurred while processing your complaint.",
              flags: 64,
            },
          });
        }
      }

      case APPEAL_COMMAND.name.toLowerCase(): {
        try {
          const appealMessage = interaction.data.options?.[0]?.value as string;

          if (!appealMessage)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content: "❌ Please provide a message for your appeal.",
                flags: 64,
              },
            });

          const appellant = {
            username:
              interaction.member?.user?.username ||
              interaction.user?.username ||
              "Unknown",
            id:
              interaction.member?.user?.id || interaction.user?.id || "Unknown",
            avatar:
              interaction.member?.user?.avatar || interaction.user?.avatar,
          };
          const isDM = !interaction.guild_id;
          const appealEmbed = createAppealEmbed(
            appealMessage,
            appellant,
            Date.now(),
            isDM,
          );
          const success = await sendAppealToChannel(environment, appealEmbed);

          if (success) {
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "✅ Your appeal has been submitted successfully! A moderator will follow up with you soon.",
                flags: 64,
              },
            });
          } else {
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Failed to submit your appeal. Please try again later.",
                flags: 64,
              },
            });
          }
        } catch (error) {
          console.error("Error in appeal command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ An error occurred while processing your appeal.",
              flags: 64,
            },
          });
        }
      }

      case COLOURS_COMMAND.name.toLowerCase(): {
        try {
          if (!interaction.guild_id)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content: "❌ This command can only be used in server channels.",
                flags: 64,
              },
            });

          const roleDistribution = await fetchRoleDistribution(
            environment,
            CENTRAL_GUILD_ID,
          );

          if (roleDistribution.length === 0)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Unable to fetch role distribution data. The bot may not have permission to read member lists or the server may not be accessible.",
                flags: 64,
              },
            });

          const topRoles = roleDistribution.slice(0, 25);
          const embed = createRoleDistributionEmbed(topRoles);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              embeds: [embed],
            },
          });
        } catch (error) {
          console.error("Error in colours command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ An error occurred while fetching role distribution.",
              flags: 64,
            },
          });
        }
      }

      case ROLEPLAY_VERIFY_COMMAND.name.toLowerCase(): {
        try {
          const member = interaction.member;
          const hasAdminPermission =
            member?.permissions && (parseInt(member.permissions) & 0x8) === 0x8;
          const hasManagerRole = member?.roles?.includes(ROLE_MANAGER_ROLE_ID);

          if (!hasAdminPermission && !hasManagerRole)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ You don't have permission to use this command. Only administrators and role managers can use this command.",
                flags: 64,
              },
            });

          const action = interaction.data.options?.[0]?.value as string;
          const targetUserID = interaction.data.options?.[1]?.value as string;

          if (!action || !targetUserID)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Missing required parameters. Please provide both action and user.",
                flags: 64,
              },
            });

          const guild = await fetch(
            `https://discord.com/api/v10/guilds/${CENTRAL_GUILD_ID}/members/${targetUserID}`,
            {
              headers: {
                Authorization: `Bot ${environment.DISCORD_TOKEN}`,
              },
            },
          );

          if (!guild.ok)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Unable to fetch user information. The user may not be in this server.",
                flags: 64,
              },
            });

          const targetMember = await guild.json();
          const currentRoles = targetMember.roles || [];
          const hasRole = currentRoles.includes(VERIFIED_ROLEPLAY_ROLE_ID);
          let newRoles = [...currentRoles];
          let actionTaken = "";

          switch (action) {
            case "add":
              if (hasRole)
                return new JSONResponse({
                  type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
                  data: {
                    content:
                      "❌ The user already has the verified roleplay role.",
                    flags: 64,
                  },
                });

              newRoles.push(VERIFIED_ROLEPLAY_ROLE_ID);

              actionTaken = "added";

              break;

            case "remove":
              if (!hasRole)
                return new JSONResponse({
                  type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
                  data: {
                    content:
                      "❌ The user doesn't have the verified roleplay role.",
                    flags: 64,
                  },
                });

              newRoles = newRoles.filter(
                (roleId) => roleId !== VERIFIED_ROLEPLAY_ROLE_ID,
              );
              actionTaken = "removed";

              break;

            case "toggle":
              if (hasRole) {
                newRoles = newRoles.filter(
                  (roleId) => roleId !== VERIFIED_ROLEPLAY_ROLE_ID,
                );
                actionTaken = "removed";
              } else {
                newRoles.push(VERIFIED_ROLEPLAY_ROLE_ID);

                actionTaken = "added";
              }

              break;

            default:
              return new JSONResponse({
                type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
                data: {
                  content:
                    "❌ Invalid action. Please use 'add', 'remove', or 'toggle'.",
                  flags: 64,
                },
              });
          }

          const updateResponse = await fetch(
            `https://discord.com/api/v10/guilds/${CENTRAL_GUILD_ID}/members/${targetUserID}`,
            {
              method: "PATCH",
              headers: {
                Authorization: `Bot ${environment.DISCORD_TOKEN}`,
                "Content-Type": "application/json",
              },
              body: JSON.stringify({
                roles: newRoles,
              }),
            },
          );

          if (!updateResponse.ok) {
            console.error(
              "Failed to update user roles:",
              await updateResponse.text(),
            );

            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Failed to update user roles. The bot may not have sufficient permissions.",
                flags: 64,
              },
            });
          }

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: `✅ Successfully ${actionTaken} the verified roleplay role for <@${targetUserID}>.`,
            },
          });
        } catch (error) {
          console.error("Error in roleplay-verify command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ An error occurred while managing the role.",
              flags: 64,
            },
          });
        }
      }

      case TOGGLE_PRIVILEGED_ACCESS_COMMAND.name.toLowerCase(): {
        try {
          const member = interaction.member;
          const hasAdminPermission =
            member?.permissions && (parseInt(member.permissions) & 0x8) === 0x8;
          const hasStaffRole = member?.roles?.some((roleId) =>
            CENTRAL_STAFF_ROLES.includes(roleId as any),
          );

          if (!hasAdminPermission && !hasStaffRole)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ You don't have permission to use this command. Only staff members or server owner can use this command.",
                flags: 64,
              },
            });

          const targetUserID = interaction.data.options?.[0]?.value as string;

          if (!targetUserID)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content: "❌ Please provide a target user.",
                flags: 64,
              },
            });

          const guild = await fetch(
            `https://discord.com/api/v10/guilds/${CENTRAL_GUILD_ID}/members/${targetUserID}`,
            {
              headers: {
                Authorization: `Bot ${environment.DISCORD_TOKEN}`,
              },
            },
          );

          if (!guild.ok)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Unable to fetch user information. The user may not be in this server.",
                flags: 64,
              },
            });

          const targetMember = await guild.json();
          const currentRoles = targetMember.roles || [];
          const hasRole = currentRoles.includes(
            CENTRAL_PRIVILEGED_ACCESS_ROLE_ID,
          );
          let newRoles = [...currentRoles];

          if (hasRole) {
            newRoles = newRoles.filter(
              (roleId) => roleId !== CENTRAL_PRIVILEGED_ACCESS_ROLE_ID,
            );
          } else {
            newRoles.push(CENTRAL_PRIVILEGED_ACCESS_ROLE_ID);
          }

          const updateResponse = await fetch(
            `https://discord.com/api/v10/guilds/${CENTRAL_GUILD_ID}/members/${targetUserID}`,
            {
              method: "PATCH",
              headers: {
                Authorization: `Bot ${environment.DISCORD_TOKEN}`,
                "Content-Type": "application/json",
              },
              body: JSON.stringify({
                roles: newRoles,
              }),
            },
          );

          if (!updateResponse.ok) {
            console.error(
              "Failed to update user roles:",
              await updateResponse.text(),
            );

            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Failed to update user roles. The bot may not have sufficient permissions.",
                flags: 64,
              },
            });
          }

          const action = hasRole ? "granted" : "revoked";

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: `✅ Successfully ${action} privileged access for <@${targetUserID}>.`,
            },
          });
        } catch (error) {
          console.error("Error in toggle-privileged-access command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ An error occurred while managing the role.",
              flags: 64,
            },
          });
        }
      }

      case ROLE_COMMAND.name.toLowerCase(): {
        try {
          const member = interaction.member;
          const hasAdminPermission =
            member?.permissions && (parseInt(member.permissions) & 0x8) === 0x8;
          const hasOwnerRole = member?.roles?.includes(OWNER_ROLE_ID);
          const hasAdministratorRole = member?.roles?.some((roleId) =>
            [ADMINISTRATOR_ROLE_ID, ROLEPLAY_ADMINISTRATOR_ROLE_ID].includes(
              roleId as any,
            ),
          );

          if (!hasAdminPermission && !hasOwnerRole && !hasAdministratorRole)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ You don't have permission to use this command. Only server administrators can use this command.",
                flags: 64,
              },
            });

          if (!interaction.guild_id)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content: "❌ This command can only be used in server channels.",
                flags: 64,
              },
            });

          const targetUserID = interaction.data.options?.find(
            (option) => option.name === "user",
          )?.value as string;
          const targetRoleID = interaction.data.options?.find(
            (option) => option.name === "role",
          )?.value as string;

          if (!targetUserID || !targetRoleID)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Missing required parameters. Please provide both user and role.",
                flags: 64,
              },
            });

          if (!ALLOWED_ROLE_IDS.includes(targetRoleID))
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ This role is not allowed to be added via this command.",
                flags: 64,
              },
            });

          const guild = await fetch(
            `https://discord.com/api/v10/guilds/${interaction.guild_id}/members/${targetUserID}`,
            {
              headers: {
                Authorization: `Bot ${environment.DISCORD_TOKEN}`,
              },
            },
          );

          if (!guild.ok)
            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Unable to fetch user information. The user may not be in this server.",
                flags: 64,
              },
            });

          const targetMember = await guild.json();
          const currentRoles = (targetMember.roles || []) as string[];
          const hasRole = currentRoles.includes(targetRoleID);
          const newRoles = hasRole
            ? currentRoles.filter((roleId: string) => roleId !== targetRoleID)
            : [...currentRoles, targetRoleID];

          const updateResponse = await fetch(
            `https://discord.com/api/v10/guilds/${interaction.guild_id}/members/${targetUserID}`,
            {
              method: "PATCH",
              headers: {
                "Content-Type": "application/json",
                Authorization: `Bot ${environment.DISCORD_TOKEN}`,
              },
              body: JSON.stringify({
                roles: newRoles,
              }),
            },
          );

          if (!updateResponse.ok) {
            const errorText = await updateResponse.text();

            console.error(
              "Error updating member roles:",
              updateResponse.status,
              errorText,
            );

            return new JSONResponse({
              type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
              data: {
                content:
                  "❌ Failed to update user roles. The bot may not have sufficient permissions.",
                flags: 64,
              },
            });
          }

          const action = hasRole ? "removed" : "added";

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: `✅ Successfully ${action} <@&${targetRoleID}> for <@${targetUserID}>.`,
              flags: 64,
            },
          });
        } catch (error) {
          console.error("Error in role command:", error);

          return new JSONResponse({
            type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
            data: {
              content: "❌ An error occurred while managing the role.",
              flags: 64,
            },
          });
        }
      }

      default:
        return new JSONResponse({ error: "Unknown Type" }, { status: 400 });
    }
  }

  console.error("Unknown Type");

  return new JSONResponse({ error: "Unknown Type" }, { status: 400 });
});

router.all("*", () => new Response("Not Found.", { status: 404 }));

const server = {
  verifyDiscordRequest,
  fetch: router.fetch,
};

export default server;