worker.js

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    if (request.method !== "POST") {
      return new Response("Method not allowed", { status: 405 });
    }

    // --- 1. HANDLE SLACK EVENTS (Reactions & URL Verification) ---
    if (url.pathname === "/events") {
      const body = await request.json();

      if (body.type === "url_verification") {
        return new Response(body.challenge, { status: 200 });
      }

      if (body.event && body.event.type === "reaction_added") {
        const { reaction, item, user } = body.event;

        // Replace with your Slack admin ID
        const ADMIN_ID = "ADMIN_USER_ID";

        if (user === ADMIN_ID) {
          const historyReq = await fetch(
            `https://slack.com/api/conversations.replies?channel=${item.channel}&ts=${item.ts}&limit=1`,
            {
              headers: { Authorization: `Bearer ${env.SLACK_BOT_TOKEN}` }
            }
          );

          const historyRes = await historyReq.json();

          if (historyRes.ok && historyRes.messages[0]) {
            const messageText = historyRes.messages[0].text || "";
            const targetChannelId = messageText.match(/C[A-Z0-9]{7,}/)?.[0];

            if (reaction === "large_green_circle" && targetChannelId) {
              await fetch("https://slack.com/api/conversations.join", {
                method: "POST",
                headers: {
                  Authorization: `Bearer ${env.SLACK_BOT_TOKEN}`,
                  "Content-Type": "application/json"
                },
                body: JSON.stringify({ channel: targetChannelId })
              });

              const archiveReq = await fetch(
                "https://slack.com/api/conversations.archive",
                {
                  method: "POST",
                  headers: {
                    Authorization: `Bearer ${env.SLACK_BOT_TOKEN}`,
                    "Content-Type": "application/json"
                  },
                  body: JSON.stringify({ channel: targetChannelId })
                }
              );

              const archiveRes = await archiveReq.json();

              await fetch("https://slack.com/api/chat.postMessage", {
                method: "POST",
                headers: {
                  Authorization: `Bearer ${env.SLACK_BOT_TOKEN}`,
                  "Content-Type": "application/json"
                },
                body: JSON.stringify({
                  channel: item.channel,
                  text: archiveRes.ok
                    ? `✅ Channel archived.`
                    : `❌ Failed: ${archiveRes.error}`
                })
              });
            } else if (reaction === "red_circle") {
              await fetch("https://slack.com/api/chat.postMessage", {
                method: "POST",
                headers: {
                  Authorization: `Bearer ${env.SLACK_BOT_TOKEN}`,
                  "Content-Type": "application/json"
                },
                body: JSON.stringify({
                  channel: item.channel,
                  text: "❌ Archive request cancelled."
                })
              });
            }
          }
        }
      }

      return new Response("OK", { status: 200 });
    }

    // --- 2. HANDLE SLASH COMMANDS ---
    const formData = await request.formData();

    const userId = formData.get("user_id");
    const currentChannelId = formData.get("channel_id");
    const textInput = formData.get("text")?.trim().toLowerCase();

    const ADMIN_ID = "ADMIN_USER_ID";

    let slackResponse = {};

    switch (url.pathname) {
      case "/clear":
        const histReq = await fetch(
          `https://slack.com/api/conversations.history?channel=${currentChannelId}&limit=50`,
          {
            headers: { Authorization: `Bearer ${env.SLACK_BOT_TOKEN}` }
          }
        );

        const histRes = await histReq.json();

        if (!histRes.ok) {
          slackResponse = {
            response_type: "ephemeral",
            text: `Error fetching history`
          };
        } else {
          const isClearAll = textInput === "all";

          if (isClearAll && userId !== ADMIN_ID) {
            slackResponse = {
              response_type: "ephemeral",
              text: "Only admins can use `/clear all`."
            };
          } else {
            let deletedCount = 0;

            for (const msg of histRes.messages) {
              if (isClearAll || msg.user === userId) {
                await fetch("https://slack.com/api/chat.delete", {
                  method: "POST",
                  headers: {
                    Authorization: `Bearer ${env.SLACK_BOT_TOKEN}`,
                    "Content-Type": "application/json"
                  },
                  body: JSON.stringify({
                    channel: currentChannelId,
                    ts: msg.ts
                  })
                });

                deletedCount++;
              }
            }

            slackResponse = {
              response_type: "ephemeral",
              text: isClearAll
                ? `Channel cleared (${deletedCount} messages).`
                : `Cleared ${deletedCount} of your messages.`
            };
          }
        }

        break;

      case "/stafflist":
        slackResponse = {
          response_type: "ephemeral",
          blocks: [
            {
              type: "section",
              text: {
                type: "mrkdwn",
                text: "*Staff list available internally.*"
              }
            },
            {
              type: "actions",
              elements: [
                {
                  type: "button",
                  text: { type: "plain_text", text: "View Staff List" },
                  url: "https://example.com/internal/staff",
                  style: "primary"
                }
              ]
            }
          ]
        };
        break;

      case "/website":
        slackResponse = {
          response_type: "ephemeral",
          blocks: [
            {
              type: "section",
              text: {
                type: "mrkdwn",
                text: "Visit the company website:"
              }
            },
            {
              type: "actions",
              elements: [
                {
                  type: "button",
                  text: { type: "plain_text", text: "Open Website" },
                  url: "https://example.com",
                  style: "primary"
                }
              ]
            }
          ]
        };
        break;

      default:
        return new Response("Not Found", { status: 404 });
    }

    return new Response(JSON.stringify(slackResponse), {
      headers: { "Content-Type": "application/json" }
    });
  }
};