Slack Integration

const reactionAddedCallback = async ({
  event,
  logger,
  client,
}: AllMiddlewareArgs & SlackEventMiddlewareArgs<"reaction_added">) => {
  // Only respond to gtm-feedback emoji
  if (event.reaction !== "gtm-feedback") {
    return;
  }

  const { item, user } = event;
  const channel = item.channel;
  const message_ts = item.ts;

  // Determine thread context
  let thread_ts = null;
  const messageInfo = await client.conversations.history({
    channel,
    latest: message_ts,
    limit: 1,
    inclusive: true,
  });

  if (messageInfo.ok && messageInfo.messages?.[0]?.thread_ts) {
    thread_ts = messageInfo.messages[0].thread_ts;
  }

  // Trigger feedback workflow
  const response = await fetch(`${appUrl}/api/slack/reaction`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      channel,
      message_ts,
      thread_ts,
      user_id: user,
    }),
  });

  // Confirm to user
  await client.chat.postEphemeral({
    channel,
    user,
    thread_ts,
    text: response.ok 
      ? "Taking a look..." 
      : "❌ Failed to process feedback. Please try again.",
  });
};

export const unfurlCallback = async ({
  event,
  logger,
  client,
  body,
}: AllMiddlewareArgs & SlackEventMiddlewareArgs<"link_shared">) => {
  const isExternalChannel = body?.is_ext_shared_channel ?? false;
  const metadata: EntityMetadata[] = [];

  for (const link of event.links) {
    const parsed = parseGtmFeedbackUrl(link.url);
    
    if (!parsed.type) continue;

    // Fetch entity data
    const response = await fetch(
      `${appUrl}/api/slack/object?type=${parsed.type}&slug=${parsed.slug}`
    );
    const { data } = await response.json();

    // Create appropriate metadata based on entity type
    if (data.type === "feedback") {
      metadata.push(
        createFeedbackEntityMetadata(data, link.url, parsed.slug)
      );
    }
    // ... other entity types
  }

  // Unfurl with Work Objects metadata
  await client.chat.unfurl({
    channel: event.channel,
    ts: event.message_ts,
    metadata: { entities: metadata },
  });
};

export const requestApprovalCallback = async ({
  action,
  ack,
  client,
  body,
}: AllMiddlewareArgs & SlackActionMiddlewareArgs<BlockButtonAction>) => {
  await ack();

  // Parse action value: request_approval:channel:ts:action
  const [, channel, message_ts, actionType] = action.value.split(":");
  const approved = actionType === "approve";

  // Update message to remove buttons
  await client.chat.update({
    channel: body.channel?.id || channel,
    ts: body.message?.ts || message_ts,
    blocks: [
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: approved 
            ? "✅ *Approved* - Creating request..."
            : "❌ *Ignored*",
        },
      },
    ],
  });

  // Resume workflow hook
  await fetch(`${appUrl}/api/workflow-hook/resume`, {
    method: "POST",
    body: JSON.stringify({ 
      token: `request_approval:${channel}:${message_ts}`,
      approved 
    }),
  });
};