import { Type } from "@sinclair/typebox";

import { parseReplyDirectives } from "../../auto-reply/reply/reply-directives.js";
import type { ClawdbotConfig } from "../../config/config.js";
import { loadConfig } from "../../config/config.js";
import { listEnabledDiscordAccounts } from "../../discord/accounts.js";
import {
  type MessagePollResult,
  type MessageSendResult,
  sendMessage,
  sendPoll,
} from "../../infra/outbound/message.js";
import { resolveMessageProviderSelection } from "../../infra/outbound/provider-selection.js";
import { resolveMSTeamsCredentials } from "../../msteams/token.js";
import { normalizeAccountId } from "../../routing/session-key.js";
import { listEnabledSlackAccounts } from "../../slack/accounts.js";
import { listEnabledTelegramAccounts } from "../../telegram/accounts.js";
import type { AnyAgentTool } from "./common.js";
import {
  createActionGate,
  jsonResult,
  readNumberParam,
  readStringArrayParam,
  readStringParam,
} from "./common.js";
import { handleDiscordAction } from "./discord-actions.js";
import { handleSlackAction } from "./slack-actions.js";
import { handleTelegramAction } from "./telegram-actions.js";
import { handleWhatsAppAction } from "./whatsapp-actions.js";

const AllMessageActions = [
  "send",
  "poll",
  "react",
  "reactions",
  "read",
  "edit",
  "delete",
  "pin",
  "unpin",
  "list-pins",
  "permissions",
  "thread-create",
  "thread-list",
  "thread-reply",
  "search",
  "sticker",
  "member-info",
  "role-info",
  "emoji-list",
  "emoji-upload",
  "sticker-upload",
  "role-add",
  "role-remove",
  "channel-info",
  "channel-list",
  "voice-status",
  "event-list",
  "event-create",
  "timeout",
  "kick",
  "ban",
];


const MessageToolCommonSchema = {
  provider: Type.Optional(Type.String()),
  media: Type.Optional(Type.String()),
  buttons: Type.Optional(
    Type.Array(
      Type.Array(
        Type.Object({
          text: Type.String(),
          callback_data: Type.String(),
        }),
      ),
      {
        description: "Telegram inline keyboard buttons (array of button rows)",
      },
    ),
  ),
  messageId: Type.Optional(Type.String()),
  replyTo: Type.Optional(Type.String()),
  threadId: Type.Optional(Type.String()),
  accountId: Type.Optional(Type.String()),
  dryRun: Type.Optional(Type.Boolean()),
  bestEffort: Type.Optional(Type.Boolean()),
  gifPlayback: Type.Optional(Type.Boolean()),
  emoji: Type.Optional(Type.String()),
  remove: Type.Optional(Type.Boolean()),
  limit: Type.Optional(Type.Number()),
  before: Type.Optional(Type.String()),
  after: Type.Optional(Type.String()),
  around: Type.Optional(Type.String()),
  pollQuestion: Type.Optional(Type.String()),
  pollOption: Type.Optional(Type.Array(Type.String())),
  pollDurationHours: Type.Optional(Type.Number()),
  pollMulti: Type.Optional(Type.Boolean()),
  channelId: Type.Optional(Type.String()),
  channelIds: Type.Optional(Type.Array(Type.String())),
  guildId: Type.Optional(Type.String()),
  userId: Type.Optional(Type.String()),
  authorId: Type.Optional(Type.String()),
  authorIds: Type.Optional(Type.Array(Type.String())),
  roleId: Type.Optional(Type.String()),
  roleIds: Type.Optional(Type.Array(Type.String())),
  emojiName: Type.Optional(Type.String()),
  stickerId: Type.Optional(Type.Array(Type.String())),
  stickerName: Type.Optional(Type.String()),
  stickerDesc: Type.Optional(Type.String()),
  stickerTags: Type.Optional(Type.String()),
  threadName: Type.Optional(Type.String()),
  autoArchiveMin: Type.Optional(Type.Number()),
  query: Type.Optional(Type.String()),
  eventName: Type.Optional(Type.String()),
  eventType: Type.Optional(Type.String()),
  startTime: Type.Optional(Type.String()),
  endTime: Type.Optional(Type.String()),
  desc: Type.Optional(Type.String()),
  location: Type.Optional(Type.String()),
  durationMin: Type.Optional(Type.Number()),
  until: Type.Optional(Type.String()),
  reason: Type.Optional(Type.String()),
  deleteDays: Type.Optional(Type.Number()),
  includeArchived: Type.Optional(Type.Boolean()),
  participant: Type.Optional(Type.String()),
  fromMe: Type.Optional(Type.Boolean()),
  gatewayUrl: Type.Optional(Type.String()),
  gatewayToken: Type.Optional(Type.String()),
  timeoutMs: Type.Optional(Type.Number()),
};

function buildMessageToolSchemaFromActions(
  actions: string[],
  options: { includeButtons: boolean },
) {
  const props: Record<string, unknown> = { ...MessageToolCommonSchema };
  if (!options.includeButtons) delete props.buttons;

  const schemas: Array<ReturnType<typeof Type.Object>> = [];
  if (actions.includes("send")) {
    schemas.push(
      Type.Object({
        action: Type.Literal("send"),
        to: Type.String(),
        message: Type.String(),
        ...props,
      }),
    );
  }

  const nonSendActions = actions.filter((action) => action !== "send");
  if (nonSendActions.length > 0) {
    schemas.push(
      Type.Object({
        action: Type.Union(
          nonSendActions.map((action) => Type.Literal(action)),
        ),
        to: Type.Optional(Type.String()),
        message: Type.Optional(Type.String()),
        ...props,
      }),
    );
  }

  return schemas.length === 1 ? schemas[0] : Type.Union(schemas);
}

const MessageToolSchema = buildMessageToolSchemaFromActions(AllMessageActions, {
  includeButtons: true,
});

type MessageToolOptions = {
  agentAccountId?: string;
  config?: ClawdbotConfig;
  /** Current channel ID for auto-threading (Slack). */
  currentChannelId?: string;
  /** Current thread timestamp for auto-threading (Slack). */
  currentThreadTs?: string;
  /** Reply-to mode for Slack auto-threading. */
  replyToMode?: "off" | "first" | "all";
  /** Mutable ref to track if a reply was sent (for "first" mode). */
  hasRepliedRef?: { value: boolean };
};

function hasTelegramInlineButtons(cfg: ClawdbotConfig): boolean {
  const caps = new Set<string>();
  for (const entry of cfg.telegram?.capabilities ?? []) {
    const trimmed = String(entry).trim();
    if (trimmed) caps.add(trimmed.toLowerCase());
  }
  const accounts = cfg.telegram?.accounts;
  if (accounts && typeof accounts === "object") {
    for (const account of Object.values(accounts)) {
      const accountCaps = (account as { capabilities?: unknown })?.capabilities;
      if (!Array.isArray(accountCaps)) continue;
      for (const entry of accountCaps) {
        const trimmed = String(entry).trim();
        if (trimmed) caps.add(trimmed.toLowerCase());
      }
    }
  }
  return caps.has("inlinebuttons");
}

function buildMessageActionList(cfg: ClawdbotConfig) {
  const actions = new Set<string>(["send"]);

  const discordAccounts = listEnabledDiscordAccounts(cfg).filter(
    (account) => account.tokenSource !== "none",
  );
  const discordEnabled = discordAccounts.length > 0;
  const discordGate = createActionGate(cfg.discord?.actions);

  const slackAccounts = listEnabledSlackAccounts(cfg).filter(
    (account) => account.botTokenSource !== "none",
  );
  const slackEnabled = slackAccounts.length > 0;
  const isSlackActionEnabled = (key: string, defaultValue = true) => {
    if (!slackEnabled) return false;
    for (const account of slackAccounts) {
      const gate = createActionGate(
        (account.actions ?? cfg.slack?.actions) as Record<
          string,
          boolean | undefined
        >,
      );
      if (gate(key, defaultValue)) return true;
    }
    return false;
  };

  const telegramAccounts = listEnabledTelegramAccounts(cfg).filter(
    (account) => account.tokenSource !== "none",
  );
  const telegramEnabled = telegramAccounts.length > 0;
  const telegramGate = createActionGate(cfg.telegram?.actions);

  const whatsappGate = createActionGate(cfg.whatsapp?.actions);

  const canDiscordReactions = discordEnabled && discordGate("reactions");
  const canSlackReactions = isSlackActionEnabled("reactions");
  const canTelegramReactions = telegramEnabled && telegramGate("reactions");
  const canWhatsAppReactions = cfg.whatsapp ? whatsappGate("reactions") : false;
  const canAnyReactions =
    canDiscordReactions ||
    canSlackReactions ||
    canTelegramReactions ||
    canWhatsAppReactions;
  if (canAnyReactions) actions.add("react");
  if (canDiscordReactions || canSlackReactions) actions.add("reactions");

  const canDiscordMessages = discordEnabled && discordGate("messages");
  const canSlackMessages = isSlackActionEnabled("messages");
  if (canDiscordMessages || canSlackMessages) {
    actions.add("read");
    actions.add("edit");
    actions.add("delete");
  }

  const canDiscordPins = discordEnabled && discordGate("pins");
  const canSlackPins = isSlackActionEnabled("pins");
  if (canDiscordPins || canSlackPins) {
    actions.add("pin");
    actions.add("unpin");
    actions.add("list-pins");
  }

  const msteamsEnabled =
    cfg.msteams?.enabled !== false &&
    Boolean(cfg.msteams && resolveMSTeamsCredentials(cfg.msteams));
  const canDiscordPolls = discordEnabled && discordGate("polls");
  const canWhatsAppPolls = cfg.whatsapp ? whatsappGate("polls") : false;
  if (canDiscordPolls || canWhatsAppPolls || msteamsEnabled)
    actions.add("poll");
  if (discordEnabled && discordGate("permissions")) actions.add("permissions");
  if (discordEnabled && discordGate("threads")) {
    actions.add("thread-create");
    actions.add("thread-list");
    actions.add("thread-reply");
  }
  if (discordEnabled && discordGate("search")) actions.add("search");
  if (discordEnabled && discordGate("stickers")) actions.add("sticker");
  if (
    (discordEnabled && discordGate("memberInfo")) ||
    isSlackActionEnabled("memberInfo")
  ) {
    actions.add("member-info");
  }
  if (discordEnabled && discordGate("roleInfo")) actions.add("role-info");
  if (
    (discordEnabled && discordGate("reactions")) ||
    isSlackActionEnabled("emojiList")
  ) {
    actions.add("emoji-list");
  }
  if (discordEnabled && discordGate("emojiUploads"))
    actions.add("emoji-upload");
  if (discordEnabled && discordGate("stickerUploads"))
    actions.add("sticker-upload");

  const canDiscordRoles = discordEnabled && discordGate("roles", false);
  if (canDiscordRoles) {
    actions.add("role-add");
    actions.add("role-remove");
  }

  if (discordEnabled && discordGate("channelInfo")) {
    actions.add("channel-info");
    actions.add("channel-list");
  }
  if (discordEnabled && discordGate("voiceStatus")) actions.add("voice-status");
  if (discordEnabled && discordGate("events")) {
    actions.add("event-list");
    actions.add("event-create");
  }
  if (discordEnabled && discordGate("moderation", false)) {
    actions.add("timeout");
    actions.add("kick");
    actions.add("ban");
  }

  return Array.from(actions);
}

function buildMessageToolSchema(cfg: ClawdbotConfig) {
  const actions = buildMessageActionList(cfg);
  const telegramEnabled = listEnabledTelegramAccounts(cfg).some(
    (account) => account.tokenSource !== "none",
  );
  const includeButtons = telegramEnabled && hasTelegramInlineButtons(cfg);
  return buildMessageToolSchemaFromActions(actions, { includeButtons });
}

function resolveAgentAccountId(value?: string): string | undefined {
  const trimmed = value?.trim();
  if (!trimmed) return undefined;
  return normalizeAccountId(trimmed);
}

export function createMessageTool(options?: MessageToolOptions): AnyAgentTool {
  const agentAccountId = resolveAgentAccountId(options?.agentAccountId);
  const schema = options?.config
    ? buildMessageToolSchema(options.config)
    : MessageToolSchema;
  return {
    label: "Message",
    name: "message",
    description:
      "Send messages and provider-specific actions (Discord/Slack/Telegram/WhatsApp/Signal/iMessage/MS Teams).",
    parameters: schema,
    execute: async (_toolCallId, args) => {
      const params = args as Record<string, unknown>;
      const cfg = options?.config ?? loadConfig();
      const action = readStringParam(params, "action", { required: true });
      const providerSelection = await resolveMessageProviderSelection({
        cfg,
        provider: readStringParam(params, "provider"),
      });
      const provider = providerSelection.provider;
      const accountId = readStringParam(params, "accountId") ?? agentAccountId;
      const gateway = {
        url: readStringParam(params, "gatewayUrl", { trim: false }),
        token: readStringParam(params, "gatewayToken", { trim: false }),
        timeoutMs: readNumberParam(params, "timeoutMs"),
        clientName: "agent" as const,
        mode: "agent" as const,
      };
      const dryRun = Boolean(params.dryRun);

      if (action === "send") {
        const to = readStringParam(params, "to", { required: true });
        let message = readStringParam(params, "message", {
          required: true,
          allowEmpty: true,
        });
        const parsed = parseReplyDirectives(message);
        message = parsed.text;
        const mediaUrl =
          readStringParam(params, "media", { trim: false }) ??
          (parsed.mediaUrls?.[0] || parsed.mediaUrl);
        const replyTo =
          readStringParam(params, "replyTo") ?? parsed.replyToId;
        const threadId = readStringParam(params, "threadId");
        const buttons = params.buttons;
        const gifPlayback =
          typeof params.gifPlayback === "boolean" ? params.gifPlayback : false;
        const bestEffort =
          typeof params.bestEffort === "boolean"
            ? params.bestEffort
            : undefined;

        if (dryRun) {
          const result: MessageSendResult = await sendMessage({
            to,
            content: message,
            mediaUrl: mediaUrl || undefined,
            provider: provider || undefined,
            accountId: accountId ?? undefined,
            gifPlayback,
            dryRun,
            bestEffort,
            gateway,
          });
          return jsonResult(result);
        }

        if (provider === "discord") {
          return await handleDiscordAction(
            {
              action: "sendMessage",
              to,
              content: message,
              mediaUrl: mediaUrl ?? undefined,
              replyTo: replyTo ?? undefined,
            },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            {
              action: "sendMessage",
              to,
              content: message,
              mediaUrl: mediaUrl ?? undefined,
              accountId: accountId ?? undefined,
              threadTs: threadId ?? replyTo ?? undefined,
            },
            cfg,
            {
              currentChannelId: options?.currentChannelId,
              currentThreadTs: options?.currentThreadTs,
              replyToMode: options?.replyToMode,
              hasRepliedRef: options?.hasRepliedRef,
            },
          );
        }
        if (provider === "telegram") {
          return await handleTelegramAction(
            {
              action: "sendMessage",
              to,
              content: message,
              mediaUrl: mediaUrl ?? undefined,
              replyToMessageId: replyTo ?? undefined,
              messageThreadId: threadId ?? undefined,
              accountId: accountId ?? undefined,
              buttons,
            },
            cfg,
          );
        }

        const result: MessageSendResult = await sendMessage({
          to,
          content: message,
          mediaUrl: mediaUrl || undefined,
          provider: provider || undefined,
          accountId: accountId ?? undefined,
          gifPlayback,
          dryRun,
          bestEffort,
          gateway,
        });
        return jsonResult(result);
      }

      if (action === "poll") {
        const to = readStringParam(params, "to", { required: true });
        const question = readStringParam(params, "pollQuestion", {
          required: true,
        });
        const options =
          readStringArrayParam(params, "pollOption", { required: true }) ?? [];
        const allowMultiselect =
          typeof params.pollMulti === "boolean" ? params.pollMulti : undefined;
        const durationHours = readNumberParam(params, "pollDurationHours", {
          integer: true,
        });

        if (dryRun) {
          const maxSelections = allowMultiselect
            ? Math.max(2, options.length)
            : 1;
          const result: MessagePollResult = await sendPoll({
            to,
            question,
            options,
            maxSelections,
            durationHours: durationHours ?? undefined,
            provider,
            dryRun,
            gateway,
          });
          return jsonResult(result);
        }

        if (provider === "discord") {
          return await handleDiscordAction(
            {
              action: "poll",
              to,
              question,
              answers: options,
              allowMultiselect,
              durationHours: durationHours ?? undefined,
              content: readStringParam(params, "message"),
            },
            cfg,
          );
        }

        const maxSelections = allowMultiselect
          ? Math.max(2, options.length)
          : 1;
        const result: MessagePollResult = await sendPoll({
          to,
          question,
          options,
          maxSelections,
          durationHours: durationHours ?? undefined,
          provider,
          dryRun,
          gateway,
        });
        return jsonResult(result);
      }

      const resolveChannelId = (label: string) =>
        readStringParam(params, label) ??
        readStringParam(params, "to", { required: true });

      const resolveChatId = (label: string) =>
        readStringParam(params, label) ??
        readStringParam(params, "to", { required: true });

      if (action === "react") {
        const messageId = readStringParam(params, "messageId", {
          required: true,
        });
        const emoji = readStringParam(params, "emoji", { allowEmpty: true });
        const remove =
          typeof params.remove === "boolean" ? params.remove : undefined;
        if (provider === "discord") {
          return await handleDiscordAction(
            {
              action: "react",
              channelId: resolveChannelId("channelId"),
              messageId,
              emoji,
              remove,
            },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            {
              action: "react",
              channelId: resolveChannelId("channelId"),
              messageId,
              emoji,
              remove,
              accountId: accountId ?? undefined,
            },
            cfg,
          );
        }
        if (provider === "telegram") {
          return await handleTelegramAction(
            {
              action: "react",
              chatId: resolveChatId("chatId"),
              messageId,
              emoji,
              remove,
              accountId: accountId ?? undefined,
            },
            cfg,
          );
        }
        if (provider === "whatsapp") {
          return await handleWhatsAppAction(
            {
              action: "react",
              chatJid: resolveChatId("chatJid"),
              messageId,
              emoji,
              remove,
              participant: readStringParam(params, "participant"),
              accountId: accountId ?? undefined,
              fromMe:
                typeof params.fromMe === "boolean" ? params.fromMe : undefined,
            },
            cfg,
          );
        }
        throw new Error(`React is not supported for provider ${provider}.`);
      }

      if (action === "reactions") {
        const messageId = readStringParam(params, "messageId", {
          required: true,
        });
        const limit = readNumberParam(params, "limit", { integer: true });
        if (provider === "discord") {
          return await handleDiscordAction(
            {
              action: "reactions",
              channelId: resolveChannelId("channelId"),
              messageId,
              limit,
            },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            {
              action: "reactions",
              channelId: resolveChannelId("channelId"),
              messageId,
              limit,
              accountId: accountId ?? undefined,
            },
            cfg,
          );
        }
        throw new Error(
          `Reactions are not supported for provider ${provider}.`,
        );
      }

      if (action === "read") {
        const limit = readNumberParam(params, "limit", { integer: true });
        const before = readStringParam(params, "before");
        const after = readStringParam(params, "after");
        const around = readStringParam(params, "around");
        if (provider === "discord") {
          return await handleDiscordAction(
            {
              action: "readMessages",
              channelId: resolveChannelId("channelId"),
              limit,
              before,
              after,
              around,
            },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            {
              action: "readMessages",
              channelId: resolveChannelId("channelId"),
              limit,
              before,
              after,
              accountId: accountId ?? undefined,
            },
            cfg,
          );
        }
        throw new Error(`Read is not supported for provider ${provider}.`);
      }

      if (action === "edit") {
        const messageId = readStringParam(params, "messageId", {
          required: true,
        });
        const message = readStringParam(params, "message", { required: true });
        if (provider === "discord") {
          return await handleDiscordAction(
            {
              action: "editMessage",
              channelId: resolveChannelId("channelId"),
              messageId,
              content: message,
            },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            {
              action: "editMessage",
              channelId: resolveChannelId("channelId"),
              messageId,
              content: message,
              accountId: accountId ?? undefined,
            },
            cfg,
          );
        }
        throw new Error(`Edit is not supported for provider ${provider}.`);
      }

      if (action === "delete") {
        const messageId = readStringParam(params, "messageId", {
          required: true,
        });
        if (provider === "discord") {
          return await handleDiscordAction(
            {
              action: "deleteMessage",
              channelId: resolveChannelId("channelId"),
              messageId,
            },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            {
              action: "deleteMessage",
              channelId: resolveChannelId("channelId"),
              messageId,
              accountId: accountId ?? undefined,
            },
            cfg,
          );
        }
        throw new Error(`Delete is not supported for provider ${provider}.`);
      }

      if (action === "pin" || action === "unpin" || action === "list-pins") {
        const messageId =
          action === "list-pins"
            ? undefined
            : readStringParam(params, "messageId", { required: true });
        const channelId = resolveChannelId("channelId");
        if (provider === "discord") {
          const discordAction =
            action === "pin"
              ? "pinMessage"
              : action === "unpin"
                ? "unpinMessage"
                : "listPins";
          return await handleDiscordAction(
            {
              action: discordAction,
              channelId,
              messageId,
            },
            cfg,
          );
        }
        if (provider === "slack") {
          const slackAction =
            action === "pin"
              ? "pinMessage"
              : action === "unpin"
                ? "unpinMessage"
                : "listPins";
          return await handleSlackAction(
            {
              action: slackAction,
              channelId,
              messageId,
              accountId: accountId ?? undefined,
            },
            cfg,
          );
        }
        throw new Error(`Pins are not supported for provider ${provider}.`);
      }

      if (action === "permissions") {
        if (provider !== "discord") {
          throw new Error(
            `Permissions are only supported for Discord (provider=${provider}).`,
          );
        }
        return await handleDiscordAction(
          {
            action: "permissions",
            channelId: resolveChannelId("channelId"),
          },
          cfg,
        );
      }

      if (action === "thread-create") {
        if (provider !== "discord") {
          throw new Error(
            `Thread create is only supported for Discord (provider=${provider}).`,
          );
        }
        const name = readStringParam(params, "threadName", { required: true });
        const messageId = readStringParam(params, "messageId");
        const autoArchiveMinutes = readNumberParam(params, "autoArchiveMin", {
          integer: true,
        });
        return await handleDiscordAction(
          {
            action: "threadCreate",
            channelId: resolveChannelId("channelId"),
            name,
            messageId,
            autoArchiveMinutes,
          },
          cfg,
        );
      }

      if (action === "thread-list") {
        if (provider !== "discord") {
          throw new Error(
            `Thread list is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const channelId = readStringParam(params, "channelId");
        const includeArchived =
          typeof params.includeArchived === "boolean"
            ? params.includeArchived
            : undefined;
        const before = readStringParam(params, "before");
        const limit = readNumberParam(params, "limit", { integer: true });
        return await handleDiscordAction(
          {
            action: "threadList",
            guildId,
            channelId,
            includeArchived,
            before,
            limit,
          },
          cfg,
        );
      }

      if (action === "thread-reply") {
        if (provider !== "discord") {
          throw new Error(
            `Thread reply is only supported for Discord (provider=${provider}).`,
          );
        }
        let content = readStringParam(params, "message", { required: true });
        const parsed = parseReplyDirectives(content);
        content = parsed.text;
        const mediaUrl =
          readStringParam(params, "media", { trim: false }) ??
          (parsed.mediaUrls?.[0] || parsed.mediaUrl);
        const replyTo =
          readStringParam(params, "replyTo") ?? parsed.replyToId;
        return await handleDiscordAction(
          {
            action: "threadReply",
            channelId: resolveChannelId("channelId"),
            content,
            mediaUrl: mediaUrl ?? undefined,
            replyTo: replyTo ?? undefined,
          },
          cfg,
        );
      }

      if (action === "search") {
        if (provider !== "discord") {
          throw new Error(
            `Search is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const query = readStringParam(params, "query", { required: true });
        const channelId = readStringParam(params, "channelId");
        const channelIds = readStringArrayParam(params, "channelIds");
        const authorId = readStringParam(params, "authorId");
        const authorIds = readStringArrayParam(params, "authorIds");
        const limit = readNumberParam(params, "limit", { integer: true });
        return await handleDiscordAction(
          {
            action: "searchMessages",
            guildId,
            content: query,
            channelId,
            channelIds,
            authorId,
            authorIds,
            limit,
          },
          cfg,
        );
      }

      if (action === "sticker") {
        if (provider !== "discord") {
          throw new Error(
            `Sticker send is only supported for Discord (provider=${provider}).`,
          );
        }
        const stickerIds =
          readStringArrayParam(params, "stickerId", {
            required: true,
            label: "sticker-id",
          }) ?? [];
        const content = readStringParam(params, "message");
        return await handleDiscordAction(
          {
            action: "sticker",
            to: readStringParam(params, "to", { required: true }),
            stickerIds,
            content,
          },
          cfg,
        );
      }

      if (action === "member-info") {
        const userId = readStringParam(params, "userId", { required: true });
        if (provider === "discord") {
          const guildId = readStringParam(params, "guildId", {
            required: true,
          });
          return await handleDiscordAction(
            { action: "memberInfo", guildId, userId },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            { action: "memberInfo", userId, accountId: accountId ?? undefined },
            cfg,
          );
        }
        throw new Error(
          `Member info is not supported for provider ${provider}.`,
        );
      }

      if (action === "role-info") {
        if (provider !== "discord") {
          throw new Error(
            `Role info is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        return await handleDiscordAction({ action: "roleInfo", guildId }, cfg);
      }

      if (action === "emoji-list") {
        if (provider === "discord") {
          const guildId = readStringParam(params, "guildId", {
            required: true,
          });
          return await handleDiscordAction(
            { action: "emojiList", guildId },
            cfg,
          );
        }
        if (provider === "slack") {
          return await handleSlackAction(
            { action: "emojiList", accountId: accountId ?? undefined },
            cfg,
          );
        }
        throw new Error(
          `Emoji list is not supported for provider ${provider}.`,
        );
      }

      if (action === "emoji-upload") {
        if (provider !== "discord") {
          throw new Error(
            `Emoji upload is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const name = readStringParam(params, "emojiName", { required: true });
        const mediaUrl = readStringParam(params, "media", {
          required: true,
          trim: false,
        });
        const roleIds = readStringArrayParam(params, "roleIds");
        return await handleDiscordAction(
          {
            action: "emojiUpload",
            guildId,
            name,
            mediaUrl,
            roleIds,
          },
          cfg,
        );
      }

      if (action === "sticker-upload") {
        if (provider !== "discord") {
          throw new Error(
            `Sticker upload is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const name = readStringParam(params, "stickerName", { required: true });
        const description = readStringParam(params, "stickerDesc", {
          required: true,
        });
        const tags = readStringParam(params, "stickerTags", { required: true });
        const mediaUrl = readStringParam(params, "media", {
          required: true,
          trim: false,
        });
        return await handleDiscordAction(
          {
            action: "stickerUpload",
            guildId,
            name,
            description,
            tags,
            mediaUrl,
          },
          cfg,
        );
      }

      if (action === "role-add" || action === "role-remove") {
        if (provider !== "discord") {
          throw new Error(
            `Role changes are only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const userId = readStringParam(params, "userId", { required: true });
        const roleId = readStringParam(params, "roleId", { required: true });
        const discordAction = action === "role-add" ? "roleAdd" : "roleRemove";
        return await handleDiscordAction(
          { action: discordAction, guildId, userId, roleId },
          cfg,
        );
      }

      if (action === "channel-info") {
        if (provider !== "discord") {
          throw new Error(
            `Channel info is only supported for Discord (provider=${provider}).`,
          );
        }
        const channelId = readStringParam(params, "channelId", {
          required: true,
        });
        return await handleDiscordAction(
          { action: "channelInfo", channelId },
          cfg,
        );
      }

      if (action === "channel-list") {
        if (provider !== "discord") {
          throw new Error(
            `Channel list is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        return await handleDiscordAction(
          { action: "channelList", guildId },
          cfg,
        );
      }

      if (action === "voice-status") {
        if (provider !== "discord") {
          throw new Error(
            `Voice status is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const userId = readStringParam(params, "userId", { required: true });
        return await handleDiscordAction(
          { action: "voiceStatus", guildId, userId },
          cfg,
        );
      }

      if (action === "event-list") {
        if (provider !== "discord") {
          throw new Error(
            `Event list is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        return await handleDiscordAction({ action: "eventList", guildId }, cfg);
      }

      if (action === "event-create") {
        if (provider !== "discord") {
          throw new Error(
            `Event create is only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const name = readStringParam(params, "eventName", { required: true });
        const startTime = readStringParam(params, "startTime", {
          required: true,
        });
        const endTime = readStringParam(params, "endTime");
        const description = readStringParam(params, "desc");
        const channelId = readStringParam(params, "channelId");
        const location = readStringParam(params, "location");
        const entityType = readStringParam(params, "eventType");
        return await handleDiscordAction(
          {
            action: "eventCreate",
            guildId,
            name,
            startTime,
            endTime,
            description,
            channelId,
            location,
            entityType,
          },
          cfg,
        );
      }

      if (action === "timeout" || action === "kick" || action === "ban") {
        if (provider !== "discord") {
          throw new Error(
            `Moderation actions are only supported for Discord (provider=${provider}).`,
          );
        }
        const guildId = readStringParam(params, "guildId", { required: true });
        const userId = readStringParam(params, "userId", { required: true });
        const durationMinutes = readNumberParam(params, "durationMin", {
          integer: true,
        });
        const until = readStringParam(params, "until");
        const reason = readStringParam(params, "reason");
        const deleteMessageDays = readNumberParam(params, "deleteDays", {
          integer: true,
        });
        const discordAction = action as "timeout" | "kick" | "ban";
        return await handleDiscordAction(
          {
            action: discordAction,
            guildId,
            userId,
            durationMinutes,
            until,
            reason,
            deleteMessageDays,
          },
          cfg,
        );
      }

      throw new Error(`Unknown action: ${action}`);
    },
  };
}