import { beforeEach, describe, expect, it, mock } from "bun:test";
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import SlackChannel, { DEFAULT_FORWARD_TIMEOUT_MS, parseForwardTimeoutMs } from "./index.ts";
import { checkPermissions, loadPermissionConfig, parseIdList } from "./permissions.ts";
import { ConversationQueue } from './runtime.ts';
import type { PermissionConfig, PermissionResult, UserInfo } from "./types.ts";

// ── Helpers ─────────────────────────────────────────────────────────────────

function emptyPermissions(): PermissionConfig {
  return {
    allowedChannels: new Set(),
    allowedUsers: new Set(),
    blockedUsers: new Set(),
  };
}

function testUser(overrides: Partial<UserInfo> = {}): UserInfo {
  return {
    userId: "U12345",
    teamId: "T12345",
    channelId: "C12345",
    username: "testuser",
    ...overrides,
  };
}

function withSecretFile(envKey: string, value: string, run: () => void): void {
  const original = Bun.env[envKey];
  const dir = mkdtempSync(join(tmpdir(), "openpalm-channel-test-"));
  const path = join(dir, envKey.toLowerCase());
  writeFileSync(path, `${value}\n`);
  try {
    Bun.env[envKey] = path;
    run();
  } finally {
    if (original === undefined) delete Bun.env[envKey];
    else Bun.env[envKey] = original;
    rmSync(dir, { recursive: true, force: true });
  }
}

function deferred(): { promise: Promise<void>; resolve: () => void } {
  let resolve = () => {};
  const promise = new Promise<void>((r) => {
    resolve = r;
  });
  return { promise, resolve };
}

type MockClient = {
  chat: {
    postMessage: ReturnType<typeof mock>;
    update: ReturnType<typeof mock>;
  };
  conversations: {
    open: ReturnType<typeof mock>;
  };
  users: {
    info: ReturnType<typeof mock>;
  };
  views: {
    open: ReturnType<typeof mock>;
    publish: ReturnType<typeof mock>;
  };
};

function createMockClient(): MockClient {
  return {
    chat: {
      postMessage: mock(async () => ({ ts: "1234567890.123456" })),
      update: mock(async () => ({})),
    },
    conversations: {
      open: mock(async () => ({ channel: { id: "D123" } })),
    },
    users: {
      info: mock(async ({ user }: { user: string }) => ({ user: { name: user } })),
    },
    views: {
      open: mock(async () => ({})),
      publish: mock(async () => ({})),
    },
  };
}

type MockSay = ReturnType<typeof mock>;

function createMockSay(): MockSay {
  return mock(async () => ({}));
}

beforeEach(() => {
  delete Bun.env.SLACK_FORWARD_TIMEOUT_MS;
});

// ── Forward timeout parsing ──────────────────────────────────────────────────

describe("parseForwardTimeoutMs", () => {
  it("uses default when value is missing", () => {
    expect(parseForwardTimeoutMs(undefined)).toBe(DEFAULT_FORWARD_TIMEOUT_MS);
  });

  it("uses default when value is invalid, zero, or negative", () => {
    expect(parseForwardTimeoutMs("nope")).toBe(DEFAULT_FORWARD_TIMEOUT_MS);
    expect(parseForwardTimeoutMs("0")).toBe(DEFAULT_FORWARD_TIMEOUT_MS);
    expect(parseForwardTimeoutMs("-1")).toBe(DEFAULT_FORWARD_TIMEOUT_MS);
  });

  it("uses the configured positive value", () => {
    expect(parseForwardTimeoutMs("12345")).toBe(12345);
  });
});

// ── parseIdList ─────────────────────────────────────────────────────────────

describe("parseIdList", () => {
  it("returns empty set for undefined", () => {
    expect(parseIdList(undefined).size).toBe(0);
  });

  it("returns empty set for empty string", () => {
    expect(parseIdList("").size).toBe(0);
  });

  it("returns empty set for whitespace-only", () => {
    expect(parseIdList("   ").size).toBe(0);
  });

  it("splits comma-separated values", () => {
    const result = parseIdList("a,b,c");
    expect(result.size).toBe(3);
    expect(result.has("a")).toBe(true);
    expect(result.has("b")).toBe(true);
    expect(result.has("c")).toBe(true);
  });

  it("trims whitespace", () => {
    const result = parseIdList("  a , b , c  ");
    expect(result.has("a")).toBe(true);
    expect(result.has("b")).toBe(true);
    expect(result.has("c")).toBe(true);
  });

  it("filters empty entries", () => {
    const result = parseIdList("a,,b,,,c");
    expect(result.size).toBe(3);
  });

  it("handles single value", () => {
    const result = parseIdList("U12345");
    expect(result.size).toBe(1);
    expect(result.has("U12345")).toBe(true);
  });

  it("deduplicates repeated IDs", () => {
    const result = parseIdList("id1,id1,id1");
    expect(result.size).toBe(1);
  });

  it("filters entries from trailing commas", () => {
    const result = parseIdList("id1,,id2,");
    expect(result.size).toBe(2);
    expect(result.has("id1")).toBe(true);
    expect(result.has("id2")).toBe(true);
  });
});

// ── checkPermissions ────────────────────────────────────────────────────────

describe("checkPermissions", () => {
  it("allows when all lists are empty", () => {
    const result = checkPermissions(emptyPermissions(), testUser());
    expect(result.allowed).toBe(true);
    expect(result.reason).toBeUndefined();
  });

  it("blocks a blocked user", () => {
    const config = { ...emptyPermissions(), blockedUsers: new Set(["U12345"]) };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(false);
    expect(result.reason).toBe("user_blocked");
  });

  it("blocked takes precedence over allowed", () => {
    const config: PermissionConfig = {
      allowedChannels: new Set(),
      allowedUsers: new Set(["U12345"]),
      blockedUsers: new Set(["U12345"]),
    };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(false);
    expect(result.reason).toBe("user_blocked");
  });

  it("allows user in allowedUsers", () => {
    const config = { ...emptyPermissions(), allowedUsers: new Set(["U12345"]) };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(true);
  });

  it("denies user not in allowedUsers", () => {
    const config = { ...emptyPermissions(), allowedUsers: new Set(["U99999"]) };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(false);
    expect(result.reason).toBe("user_not_allowed");
  });

  it("allows user in allowed channel", () => {
    const config = { ...emptyPermissions(), allowedChannels: new Set(["C12345"]) };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(true);
  });

  it("denies user not in allowed channel", () => {
    const config = { ...emptyPermissions(), allowedChannels: new Set(["C99999"]) };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(false);
    expect(result.reason).toBe("channel_not_allowed");
  });

  it("allows when no channel provided and channels unrestricted", () => {
    const result = checkPermissions(emptyPermissions(), testUser({ channelId: "" }));
    expect(result.allowed).toBe(true);
  });

  it("denies when channel required but empty", () => {
    const config = { ...emptyPermissions(), allowedChannels: new Set(["C12345"]) };
    const result = checkPermissions(config, testUser({ channelId: "" }));
    expect(result.allowed).toBe(false);
  });

  it("denies user with empty userId when users are restricted", () => {
    const config = { ...emptyPermissions(), allowedUsers: new Set(["U12345"]) };
    const result = checkPermissions(config, testUser({ userId: "" }));
    expect(result.allowed).toBe(false);
    expect(result.reason).toBe("user_not_allowed");
  });

  it("checks both user and channel restrictions", () => {
    const config: PermissionConfig = {
      allowedChannels: new Set(["C12345"]),
      allowedUsers: new Set(["U12345"]),
      blockedUsers: new Set(),
    };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(true);
  });

  it("fails if user matches but channel does not", () => {
    const config: PermissionConfig = {
      allowedChannels: new Set(["C99999"]),
      allowedUsers: new Set(["U12345"]),
      blockedUsers: new Set(),
    };
    const result = checkPermissions(config, testUser());
    expect(result.allowed).toBe(false);
    expect(result.reason).toBe("channel_not_allowed");
  });
});

// ── loadPermissionConfig ────────────────────────────────────────────────────

describe("loadPermissionConfig", () => {
  it("loads from env vars", () => {
    const config = loadPermissionConfig({
      SLACK_ALLOWED_CHANNELS: "C1,C2",
      SLACK_ALLOWED_USERS: "U1",
      SLACK_BLOCKED_USERS: "U99",
    });
    expect(config.allowedChannels.size).toBe(2);
    expect(config.allowedUsers.size).toBe(1);
    expect(config.blockedUsers.size).toBe(1);
  });

  it("returns empty sets when env vars missing", () => {
    const config = loadPermissionConfig({});
    expect(config.allowedChannels.size).toBe(0);
    expect(config.allowedUsers.size).toBe(0);
    expect(config.blockedUsers.size).toBe(0);
  });

  it("handles whitespace in env values", () => {
    const config = loadPermissionConfig({
      SLACK_ALLOWED_CHANNELS: " C1 , C2 ",
    });
    expect(config.allowedChannels.has("C1")).toBe(true);
    expect(config.allowedChannels.has("C2")).toBe(true);
  });
});

// ── ConversationQueue ───────────────────────────────────────────────────────

describe("ConversationQueue", () => {
  it("runs task immediately when not processing", async () => {
    const queue = new ConversationQueue();
    let ran = false;
    const result = await queue.runOrQueue("key1", {
      run: async () => {
        ran = true;
      },
    });
    expect(result).toBe("started");
    expect(ran).toBe(true);
  });

  it("queues task when already processing", async () => {
    const queue = new ConversationQueue();
    const order: number[] = [];
    const blocker = deferred();

    const firstPromise = queue.runOrQueue("key1", {
      run: async () => {
        order.push(1);
        await blocker.promise;
      },
    });

    const secondResult = await queue.runOrQueue("key1", {
      run: async () => {
        order.push(2);
      },
    });

    expect(secondResult).toBe("queued");
    blocker.resolve();
    await firstPromise;
    await new Promise((r) => setTimeout(r, 50));
    expect(order).toEqual([1, 2]);
  });

  it("calls onQueued when task is queued", async () => {
    const queue = new ConversationQueue();
    let queuedCalled = false;
    const blocker = deferred();

    queue.runOrQueue("key1", {
      run: async () => {
        await blocker.promise;
      },
    });

    await queue.runOrQueue("key1", {
      onQueued: async () => {
        queuedCalled = true;
      },
      run: async () => {},
    });

    expect(queuedCalled).toBe(true);
    blocker.resolve();
  });

  it("clear drops queued tasks", async () => {
    const queue = new ConversationQueue();
    const blocker = deferred();

    queue.runOrQueue("key1", {
      run: async () => {
        await blocker.promise;
      },
    });

    queue.runOrQueue("key1", { run: async () => {} });
    queue.runOrQueue("key1", { run: async () => {} });

    const dropped = queue.clear("key1");
    expect(dropped).toBe(2);

    blocker.resolve();
  });

  it("isProcessing returns correct state", async () => {
    const queue = new ConversationQueue();
    expect(queue.isProcessing("key1")).toBe(false);

    const blocker = deferred();

    queue.runOrQueue("key1", {
      run: async () => {
        await blocker.promise;
      },
    });

    expect(queue.isProcessing("key1")).toBe(true);
    blocker.resolve();
  });

  it("queuedCount tracks pending tasks", async () => {
    const queue = new ConversationQueue();
    const blocker = deferred();

    queue.runOrQueue("key1", {
      run: async () => {
        await blocker.promise;
      },
    });

    expect(queue.queuedCount("key1")).toBe(0);

    queue.runOrQueue("key1", { run: async () => {} });
    expect(queue.queuedCount("key1")).toBe(1);

    queue.runOrQueue("key1", { run: async () => {} });
    expect(queue.queuedCount("key1")).toBe(2);

    blocker.resolve();
  });

  it("cleans up state after all tasks complete", async () => {
    const queue = new ConversationQueue();
    await queue.runOrQueue("key1", { run: async () => {} });
    expect(queue.isProcessing("key1")).toBe(false);
    expect(queue.queuedCount("key1")).toBe(0);
  });

  it("clear returns 0 for unknown session key", () => {
    const queue = new ConversationQueue();
    expect(queue.clear("nonexistent")).toBe(0);
  });

  it("runs queued work sequentially (FIFO)", async () => {
    const queue = new ConversationQueue();
    const blocker = deferred();
    const events: string[] = [];

    const first = queue.runOrQueue("s1", {
      run: async () => {
        events.push("first:start");
        await blocker.promise;
        events.push("first:end");
      },
    });

    const second = queue.runOrQueue("s1", {
      onQueued: async () => {
        events.push("second:queued");
      },
      run: async () => {
        events.push("second:run");
      },
    });

    expect(await second).toBe("queued");
    expect(queue.queuedCount("s1")).toBe(1);

    blocker.resolve();
    expect(await first).toBe("started");

    await Bun.sleep(0);
    expect(events).toEqual(["first:start", "second:queued", "first:end", "second:run"]);
    expect(queue.isProcessing("s1")).toBe(false);
  });

  it("drops queued work when cleared", async () => {
    const queue = new ConversationQueue();
    const blocker = deferred();
    const events: string[] = [];

    const first = queue.runOrQueue("s1", {
      run: async () => {
        events.push("first:start");
        await blocker.promise;
        events.push("first:end");
      },
    });

    await queue.runOrQueue("s1", {
      run: async () => {
        events.push("second:run");
      },
    });

    expect(queue.clear("s1")).toBe(1);

    blocker.resolve();
    await first;
    await Bun.sleep(0);

    expect(events).toEqual(["first:start", "first:end"]);
    expect(queue.queuedCount("s1")).toBe(0);
  });
});

// ── SlackChannel class ──────────────────────────────────────────────────────

describe("SlackChannel", () => {
  it("has correct name", () => {
    const channel = new SlackChannel();
    expect(channel.name).toBe("slack");
  });

  it("handleRequest returns null (Socket Mode, no HTTP inbound)", () => {
    const channel = new SlackChannel();
    const req = new Request("http://localhost/test", { method: "POST" });
    return channel.handleRequest(req).then((result) => {
      expect(result).toBeNull();
    });
  });

  it("health endpoint returns correct service name", async () => {
    const channel = new SlackChannel();
    Object.defineProperty(channel, "secret", { value: "test-secret" });
    const handler = channel.createFetch();
    const resp = await handler(new Request("http://localhost/health"));
    expect(resp.status).toBe(200);
    const body = (await resp.json()) as Record<string, unknown>;
    expect(body.ok).toBe(true);
    expect(body.service).toBe("channel-slack");
  });

  it("health endpoint responds to any host header", async () => {
    const channel = new SlackChannel();
    Object.defineProperty(channel, "secret", { value: "test-secret" });
    const handler = channel.createFetch();
    const resp = await handler(new Request("http://127.0.0.1:8185/health"));
    expect(resp.status).toBe(200);
  });

  it("returns 404 for non-POST requests", async () => {
    const channel = new SlackChannel();
    Object.defineProperty(channel, "secret", { value: "test-secret" });
    const handler = channel.createFetch();
    const resp = await handler(new Request("http://localhost/message", { method: "GET" }));
    expect(resp.status).toBe(404);
  });

  it("returns 404 for unknown paths", async () => {
    const channel = new SlackChannel();
    Object.defineProperty(channel, "secret", { value: "test-secret" });
    const handler = channel.createFetch();
    const resp = await handler(new Request("http://localhost/nope"));
    expect(resp.status).toBe(404);
  });

  it("botToken reads from SLACK_BOT_TOKEN_FILE", () => {
    withSecretFile("SLACK_BOT_TOKEN_FILE", "slack-bot-token", () => {
      const channel = new SlackChannel();
      expect(channel.botToken).toBe("slack-bot-token");
    });
  });

  it("appToken reads from SLACK_APP_TOKEN_FILE", () => {
    withSecretFile("SLACK_APP_TOKEN_FILE", "slack-app-token", () => {
      const channel = new SlackChannel();
      expect(channel.appToken).toBe("slack-app-token");
    });
  });

  it("inherits port from env or defaults to 8080", () => {
    const channel = new SlackChannel();
    expect(typeof channel.port).toBe("number");
  });

  it("inherits guardianUrl from env or defaults", () => {
    const channel = new SlackChannel();
    expect(typeof channel.guardianUrl).toBe("string");
    expect(channel.guardianUrl).toContain("guardian");
  });

  it("secret resolves from PRINCIPAL_SECRET_FILE", () => {
    withSecretFile("PRINCIPAL_SECRET_FILE", "channel-secret", () => {
      const channel = new SlackChannel();
      expect(channel.secret).toBe("channel-secret");
    });
  });
});

// ── Message handling behavior ───────────────────────────────────────────────

describe("DM message handling", () => {
  it("ignores bot messages (bot_id present)", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response(JSON.stringify({ answer: "hi" }), { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      { user: "U123", channel: "D123", text: "hello", ts: "1.1", channel_type: "im", bot_id: "B123" },
      say,
      client,
    );

    expect(forward).not.toHaveBeenCalled();
    expect(say).not.toHaveBeenCalled();
  });

  it("ignores messages with subtype", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response("{}", { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      { user: "U123", channel: "D123", text: "hello", ts: "1.1", channel_type: "im", subtype: "message_changed" },
      say,
      client,
    );

    expect(forward).not.toHaveBeenCalled();
  });

  it("ignores empty text", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response("{}", { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      { user: "U123", channel: "D123", text: "   ", ts: "1.1", channel_type: "im" },
      say,
      client,
    );

    expect(forward).not.toHaveBeenCalled();
  });

  it("ignores own messages (bot self-reply guard)", async () => {
    const channel = new SlackChannel();
    Object.assign(channel, { botUserId: "BSELF" });
    const forward = mock(async () => new Response("{}", { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      { user: "BSELF", channel: "D123", text: "echo", ts: "1.1", channel_type: "im" },
      say,
      client,
    );

    expect(forward).not.toHaveBeenCalled();
    expect(say).not.toHaveBeenCalled();
  });

  it("ignores non-DM messages (channel_type !== 'im')", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response("{}", { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      { user: "U123", channel: "C123", text: "hello", ts: "1.1", channel_type: "channel" },
      say,
      client,
    );

    expect(forward).not.toHaveBeenCalled();
  });

  it("forwards DM to guardian and replies in thread", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "Hi there!" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      { user: "U123", channel: "D123", text: "hello bot", ts: "1.1", channel_type: "im", team: "T1" },
      say,
      client,
    );

    expect(forward).toHaveBeenCalledTimes(1);
    expect(forward.mock.calls[0]?.[0]).toMatchObject({
      userId: "slack:U123",
      text: "hello bot",
    });
    // Thinking message posted, then updated with response
    expect(client.chat.postMessage.mock.calls[0][0]).toMatchObject({
      channel: "D123",
      text: ":hourglass: Processing your request...",
      thread_ts: "1.1",
    });
    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "D123",
      ts: "1234567890.123456",
      text: "Hi there!",
    });
  });

  it("uses thread_ts for session key when in a DM thread", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "reply" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      {
        user: "U123",
        channel: "D123",
        text: "follow up",
        ts: "2.2",
        thread_ts: "1.1",
        channel_type: "im",
        team: "T1",
      },
      say,
      client,
    );

    expect(forward.mock.calls[0]?.[0].metadata).toMatchObject({
      sessionKey: "slack:thread:D123:1.1",
    });
  });

  it("denies blocked user in DM", async () => {
    const channel = new SlackChannel();
    Object.assign(channel, {
      permissions: {
        allowedChannels: new Set<string>(),
        allowedUsers: new Set<string>(),
        blockedUsers: new Set(["U123"]),
      },
    });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onMessage: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onMessage(
      { user: "U123", channel: "D123", text: "hello", ts: "1.1", channel_type: "im" },
      say,
      client,
    );

    expect(say).toHaveBeenCalledWith({
      text: "You do not have permission to use this bot.",
      thread_ts: "1.1",
    });
    expect(client.chat.postMessage).not.toHaveBeenCalled();
  });
});

// ── App mention handling ────────────────────────────────────────────────────

describe("app mention handling", () => {
  it("responds to app_mention and replies in thread", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "mentioned!" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAppMention: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAppMention(
      { user: "U123", channel: "C456", text: "hey bot help me", ts: "1.1", team: "T1" },
      say,
      client,
    );

    expect(forward).toHaveBeenCalledTimes(1);
    // Thinking message posted, then updated with response
    expect(client.chat.postMessage.mock.calls[0][0]).toMatchObject({
      channel: "C456",
      text: ":hourglass: Processing your request...",
      thread_ts: "1.1",
    });
    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "C456",
      ts: "1234567890.123456",
      text: "mentioned!",
    });
  });

  it("ignores empty text in app_mention", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response("{}", { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAppMention: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAppMention(
      { user: "U123", channel: "C456", text: "", ts: "1.1" },
      say,
      client,
    );

    expect(forward).not.toHaveBeenCalled();
  });

  it("strips bot mention from text", async () => {
    const channel = new SlackChannel();
    Object.assign(channel, { botUserId: "B999" });
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "ok" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAppMention: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAppMention(
      { user: "U123", channel: "C456", text: "<@B999> help me please", ts: "1.1", team: "T1" },
      say,
      client,
    );

    expect(forward.mock.calls[0]?.[0].text).toBe("help me please");
  });

  it("replies 'Please provide a message' when mention-only (no text after strip)", async () => {
    const channel = new SlackChannel();
    Object.assign(channel, { botUserId: "B999" });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAppMention: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAppMention(
      { user: "U123", channel: "C456", text: "<@B999>", ts: "1.1", team: "T1" },
      say,
      client,
    );

    expect(say).toHaveBeenCalledWith({
      text: "Please provide a message.",
      thread_ts: "1.1",
    });
  });

  it("uses existing thread_ts for threaded mentions", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "threaded!" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAppMention: (event: Record<string, unknown>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAppMention(
      { user: "U123", channel: "C456", text: "question", ts: "2.2", thread_ts: "1.1", team: "T1" },
      say,
      client,
    );

    expect(forward.mock.calls[0]?.[0].metadata).toMatchObject({
      sessionKey: "slack:thread:C456:1.1",
    });
    // Thinking message posted in thread, then updated with response
    expect(client.chat.postMessage.mock.calls[0][0]).toMatchObject({
      channel: "C456",
      text: ":hourglass: Processing your request...",
      thread_ts: "1.1",
    });
    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "C456",
      ts: "1234567890.123456",
      text: "threaded!",
    });
  });
});

// ── Slash command: /clear ───────────────────────────────────────────────────

describe("/clear command", () => {
  it("forwards clearSession request with session metadata", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response(JSON.stringify({ ok: true }), { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();

    await (channel as unknown as {
      onClearCommand: (cmd: Record<string, string>, say: MockSay) => Promise<void>;
    }).onClearCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "" },
      say,
    );

    expect(forward).toHaveBeenCalledTimes(1);
    expect(forward.mock.calls[0]?.[0]).toMatchObject({
      userId: "slack:U123",
      text: "clear session",
      metadata: {
        command: "clear",
        channelId: "C456",
        teamId: "T1",
        username: "tester",
        clearSession: true,
      },
    });
    expect(forward.mock.calls[0]?.[2]).toBe(DEFAULT_FORWARD_TIMEOUT_MS);
    expect(say).toHaveBeenCalledWith({ text: "Conversation cleared." });
  });

  it("reports dropped queued follow-ups", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response(JSON.stringify({ ok: true }), { status: 200 }));
    Object.assign(channel, { forward });

    // Pre-populate the queue
    const queue = new ConversationQueue();
    const blocker = deferred();
    queue.runOrQueue("slack:channel:C456:user:U123", { run: async () => { await blocker.promise; } });
    queue.runOrQueue("slack:channel:C456:user:U123", { run: async () => {} });
    Object.assign(channel, { conversationQueue: queue });

    const say = createMockSay();

    await (channel as unknown as {
      onClearCommand: (cmd: Record<string, string>, say: MockSay) => Promise<void>;
    }).onClearCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "" },
      say,
    );

    expect(say).toHaveBeenCalledWith({ text: "Conversation cleared. Dropped queued follow-ups." });
    blocker.resolve();
  });

  it("handles guardian error gracefully", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => { throw new Error("network failure"); });
    Object.assign(channel, { forward });

    const say = createMockSay();

    await (channel as unknown as {
      onClearCommand: (cmd: Record<string, string>, say: MockSay) => Promise<void>;
    }).onClearCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "" },
      say,
    );

    expect(say).toHaveBeenCalledWith({ text: "Could not clear this conversation right now." });
  });

  it("denies blocked user", async () => {
    const channel = new SlackChannel();
    Object.assign(channel, {
      permissions: {
        allowedChannels: new Set<string>(),
        allowedUsers: new Set<string>(),
        blockedUsers: new Set(["U123"]),
      },
    });
    const forward = mock(async () => new Response("{}", { status: 200 }));
    Object.assign(channel, { forward });

    const say = createMockSay();

    await (channel as unknown as {
      onClearCommand: (cmd: Record<string, string>, say: MockSay) => Promise<void>;
    }).onClearCommand(
      { user_id: "U123", user_name: "blocked", team_id: "T1", channel_id: "C456", text: "" },
      say,
    );

    expect(say).toHaveBeenCalledWith({ text: "You do not have permission to use this bot." });
    expect(forward).not.toHaveBeenCalled();
  });

  it("handles non-ok guardian response", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response("{}", { status: 500 }));
    Object.assign(channel, { forward });

    const say = createMockSay();

    await (channel as unknown as {
      onClearCommand: (cmd: Record<string, string>, say: MockSay) => Promise<void>;
    }).onClearCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "" },
      say,
    );

    expect(say).toHaveBeenCalledWith({ text: "Could not clear this conversation right now." });
  });
});

// ── Slash command: /ask ─────────────────────────────────────────────────────

describe("/ask command", () => {
  it("replies with usage when text is empty", async () => {
    const channel = new SlackChannel();
    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAskCommand: (cmd: Record<string, string>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAskCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "" },
      say,
      client,
    );

    expect(say).toHaveBeenCalledWith({ text: "Usage: `/ask <message>`" });
  });

  it("posts thinking message, forwards to guardian, updates with answer", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "Here is my answer" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAskCommand: (cmd: Record<string, string>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAskCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "what is AI?" },
      say,
      client,
    );

    // Should post thinking message
    expect(client.chat.postMessage).toHaveBeenCalledWith({
      channel: "C456",
      text: `:hourglass: Processing your request...`,
    });

    // Should update thinking message with answer
    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "C456",
      ts: "1234567890.123456",
      text: "Here is my answer",
    });

    // Should have forwarded to guardian
    expect(forward).toHaveBeenCalledTimes(1);
    expect(forward.mock.calls[0]?.[0]).toMatchObject({
      userId: "slack:U123",
      text: "what is AI?",
      metadata: {
        command: "ask",
        teamId: "T1",
        username: "tester",
      },
    });
    expect(forward.mock.calls[0]?.[2]).toBe(DEFAULT_FORWARD_TIMEOUT_MS);
  });

  it("uses configured SLACK_FORWARD_TIMEOUT_MS for guardian forwarding", async () => {
    Bun.env.SLACK_FORWARD_TIMEOUT_MS = "4321";
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "Here is my answer" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAskCommand: (cmd: Record<string, string>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAskCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "what is AI?" },
      say,
      client,
    );

    expect(forward.mock.calls[0]?.[2]).toBe(4321);
  });

  it("updates thinking message with error on guardian failure", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => new Response("{}", { status: 500 }));
    Object.assign(channel, { forward });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAskCommand: (cmd: Record<string, string>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAskCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "test" },
      say,
      client,
    );

    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "C456",
      ts: "1234567890.123456",
      text: "Error: Guardian returned status 500",
    });
  });

  it("denies blocked user", async () => {
    const channel = new SlackChannel();
    Object.assign(channel, {
      permissions: {
        allowedChannels: new Set<string>(),
        allowedUsers: new Set<string>(),
        blockedUsers: new Set(["U123"]),
      },
    });

    const say = createMockSay();
    const client = createMockClient();

    await (channel as unknown as {
      onAskCommand: (cmd: Record<string, string>, say: MockSay, client: MockClient) => Promise<void>;
    }).onAskCommand(
      { user_id: "U123", user_name: "blocked", team_id: "T1", channel_id: "C456", text: "hello" },
      say,
      client,
    );

    expect(say).toHaveBeenCalledWith({ text: "You do not have permission to use this bot." });
    expect(client.chat.postMessage).not.toHaveBeenCalled();
  });
});

// ── Slash command: /help ────────────────────────────────────────────────────

describe("/help command", () => {
  it("denies blocked user", async () => {
    const channel = new SlackChannel();
    Object.assign(channel, {
      permissions: {
        allowedChannels: new Set<string>(),
        allowedUsers: new Set<string>(),
        blockedUsers: new Set(["U123"]),
      },
    });

    const say = createMockSay();

    await (channel as unknown as {
      onHelpCommand: (cmd: Record<string, string>, say: MockSay) => Promise<void>;
    }).onHelpCommand(
      { user_id: "U123", user_name: "blocked", team_id: "T1", channel_id: "C456", text: "" },
      say,
    );

    expect(say).toHaveBeenCalledWith({ text: "You do not have permission to use this bot." });
  });

  it("lists available commands", async () => {
    const channel = new SlackChannel();
    const say = createMockSay();

    await (channel as unknown as {
      onHelpCommand: (cmd: Record<string, string>, say: MockSay) => Promise<void>;
    }).onHelpCommand(
      { user_id: "U123", user_name: "tester", team_id: "T1", channel_id: "C456", text: "" },
      say,
    );

    expect(say).toHaveBeenCalledTimes(1);
    const text = say.mock.calls[0]?.[0]?.text as string;
    expect(text).toContain("/ask");
    expect(text).toContain("/clear");
    expect(text).toContain("/help");
    expect(text).toContain("mention me");
    expect(text).toContain("DM");
  });
});

// ── Shortcuts, modal submissions, and App Home ─────────────────────────────

describe("shortcut and modal handlers", () => {
  it("opens Ask OpenPalm modal from global shortcut", async () => {
    const channel = new SlackChannel();
    const client = createMockClient();

    await (channel as unknown as {
      onGlobalShortcut: (shortcut: Record<string, unknown>, client: MockClient) => Promise<void>;
    }).onGlobalShortcut(
      {
        trigger_id: "trigger-1",
        user: { id: "U123" },
        team: { id: "T1" },
      },
      client,
    );

    expect(client.views.open).toHaveBeenCalledTimes(1);
    const args = client.views.open.mock.calls[0]?.[0];
    expect(args.trigger_id).toBe("trigger-1");
    expect(args.view.callback_id).toBe("ask_openpalm_modal");
  });

  it("opens prefilled modal from message shortcut", async () => {
    const channel = new SlackChannel();
    const client = createMockClient();

    await (channel as unknown as {
      onMessageShortcut: (shortcut: Record<string, unknown>, client: MockClient) => Promise<void>;
    }).onMessageShortcut(
      {
        trigger_id: "trigger-2",
        user: { id: "U123" },
        team: { id: "T1" },
        channel: { id: "C456" },
        message: { ts: "1710000000.000001", text: "Please summarize this" },
      },
      client,
    );

    const args = client.views.open.mock.calls[0]?.[0];
    expect(args.view.blocks[0].element.initial_value).toContain("Please summarize this");
    expect(args.view.private_metadata).toContain("message-shortcut");
    expect(args.view.private_metadata).toContain("C456");
  });

  it("handles modal submission from message shortcut using thread session", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "modal answer" }), { status: 200 }),
    );
    Object.assign(channel, { forward });
    const client = createMockClient();

    await (channel as unknown as {
      onAskModalSubmission: (
        body: Record<string, unknown>,
        view: Record<string, unknown>,
        client: MockClient,
      ) => Promise<void>;
    }).onAskModalSubmission(
      {
        user: { id: "U123", username: "tester" },
        team: { id: "T1" },
      },
      {
        private_metadata: JSON.stringify({
          source: "message-shortcut",
          channelId: "C456",
          threadTs: "1710000000.000001",
          teamId: "T1",
        }),
        state: {
          values: {
            ask_openpalm_prompt_block: {
              ask_openpalm_prompt_action: {
                value: "use this context",
              },
            },
          },
        },
      },
      client,
    );

    expect(forward).toHaveBeenCalledTimes(1);
    expect(forward.mock.calls[0]?.[0]).toMatchObject({
      userId: "slack:U123",
      text: "use this context",
    });
    expect(forward.mock.calls[0]?.[0].metadata.sessionKey).toBe("slack:thread:C456:1710000000.000001");
    expect(client.chat.postMessage.mock.calls[0]?.[0]).toMatchObject({
      channel: "C456",
      thread_ts: "1710000000.000001",
    });
  });

  it("handles modal submission from global shortcut via DM channel", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "dm modal answer" }), { status: 200 }),
    );
    Object.assign(channel, { forward });
    const client = createMockClient();

    await (channel as unknown as {
      onAskModalSubmission: (
        body: Record<string, unknown>,
        view: Record<string, unknown>,
        client: MockClient,
      ) => Promise<void>;
    }).onAskModalSubmission(
      {
        user: { id: "U999", username: "tester" },
        team: { id: "T1" },
      },
      {
        private_metadata: JSON.stringify({ source: "global-shortcut", teamId: "T1" }),
        state: {
          values: {
            ask_openpalm_prompt_block: {
              ask_openpalm_prompt_action: {
                value: "question from modal",
              },
            },
          },
        },
      },
      client,
    );

    expect(client.conversations.open).toHaveBeenCalledWith({ users: "U999" });
    expect(forward).toHaveBeenCalledTimes(1);
    expect(forward.mock.calls[0]?.[0].metadata.sessionKey).toBe("slack:dm:U999");
  });
});

describe("app home", () => {
  it("publishes Home tab content on app_home_opened", async () => {
    const channel = new SlackChannel();
    const client = createMockClient();

    await (channel as unknown as {
      onAppHomeOpened: (event: Record<string, unknown>, client: MockClient) => Promise<void>;
    }).onAppHomeOpened(
      { user: "U123" },
      client,
    );

    expect(client.views.publish).toHaveBeenCalledTimes(1);
    const payload = client.views.publish.mock.calls[0]?.[0];
    expect(payload.user_id).toBe("U123");
    expect(payload.view.type).toBe("home");
  });
});

// ── Conversation runner ─────────────────────────────────────────────────────

describe("runConversation", () => {
  it("posts thinking message and updates it with response", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "done" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const client = createMockClient();

    await (channel as unknown as {
      runConversation: (
        client: MockClient, channel: string, threadTs: string,
        userInfo: UserInfo, text: string, sessionKey: string,
      ) => Promise<void>;
    }).runConversation(client, "C123", "1.1", testUser(), "hello", "key1");

    // First call: thinking message
    expect(client.chat.postMessage.mock.calls[0][0]).toMatchObject({
      channel: "C123",
      text: ":hourglass: Processing your request...",
      thread_ts: "1.1",
    });
    // Thinking message updated with response
    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "C123",
      ts: "1234567890.123456",
      text: "done",
    });
    expect(forward.mock.calls[0]?.[2]).toBe(DEFAULT_FORWARD_TIMEOUT_MS);
  });

  it("updates thinking message with error on failure", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () => { throw new Error("timeout"); });
    Object.assign(channel, { forward });

    const client = createMockClient();

    await (channel as unknown as {
      runConversation: (
        client: MockClient, channel: string, threadTs: string,
        userInfo: UserInfo, text: string, sessionKey: string,
      ) => Promise<void>;
    }).runConversation(client, "C123", "1.1", testUser(), "hello", "key1");

    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "C123",
      ts: "1234567890.123456",
      text: "Error: timeout",
    });
  });

  it("continues even when thinking message fails to post", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: "still works" }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const client = createMockClient();
    // First postMessage (thinking) fails, second (response) succeeds
    let callCount = 0;
    client.chat.postMessage = mock(async (args: Record<string, unknown>) => {
      callCount++;
      if (callCount === 1) throw new Error("no permission");
      return { ts: "1234567890.123456" };
    });

    await (channel as unknown as {
      runConversation: (
        client: MockClient, channel: string, threadTs: string,
        userInfo: UserInfo, text: string, sessionKey: string,
      ) => Promise<void>;
    }).runConversation(client, "C123", "1.1", testUser(), "hello", "key1");

    // Should fall back to posting response as new message
    expect(client.chat.postMessage.mock.calls[1][0]).toMatchObject({
      channel: "C123",
      text: "still works",
      thread_ts: "1.1",
    });
    // Should NOT try to update a message that was never posted
    expect(client.chat.update).not.toHaveBeenCalled();
  });

  it("splits long responses into multiple messages", async () => {
    const channel = new SlackChannel();
    const longAnswer = "x".repeat(5000);
    const forward = mock(async () =>
      new Response(JSON.stringify({ answer: longAnswer }), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const client = createMockClient();

    await (channel as unknown as {
      runConversation: (
        client: MockClient, channel: string, threadTs: string,
        userInfo: UserInfo, text: string, sessionKey: string,
      ) => Promise<void>;
    }).runConversation(client, "C123", "1.1", testUser(), "hello", "key1");

    // First call is thinking message, then update replaces it with first chunk,
    // then additional chunks posted as new messages
    const postCalls = client.chat.postMessage.mock.calls;
    // At least thinking message + follow-up chunks
    expect(postCalls.length).toBeGreaterThan(1);
    // Follow-up chunks should be in the thread
    for (let i = 1; i < postCalls.length; i++) {
      expect(postCalls[i][0].thread_ts).toBe("1.1");
    }
  });

  it("returns 'No response received.' when guardian returns no answer", async () => {
    const channel = new SlackChannel();
    const forward = mock(async () =>
      new Response(JSON.stringify({}), { status: 200 }),
    );
    Object.assign(channel, { forward });

    const client = createMockClient();

    await (channel as unknown as {
      runConversation: (
        client: MockClient, channel: string, threadTs: string,
        userInfo: UserInfo, text: string, sessionKey: string,
      ) => Promise<void>;
    }).runConversation(client, "C123", "1.1", testUser(), "hello", "key1");

    expect(client.chat.update).toHaveBeenCalledWith({
      channel: "C123",
      ts: "1234567890.123456",
      text: "No response received.",
    });
  });
});


// ── Utility: stripMention ───────────────────────────────────────────────────

describe("stripMention", () => {
  it("strips bot mention from text", () => {
    const channel = new SlackChannel();
    Object.assign(channel, { botUserId: "B999" });

    const result = (channel as unknown as {
      stripMention: (text: string) => string;
    }).stripMention("<@B999> help me");

    expect(result).toBe("help me");
  });

  it("strips multiple mentions", () => {
    const channel = new SlackChannel();
    Object.assign(channel, { botUserId: "B999" });

    const result = (channel as unknown as {
      stripMention: (text: string) => string;
    }).stripMention("<@B999> do this <@B999>");

    expect(result).toBe("do this");
  });

  it("returns original text when no botUserId", () => {
    const channel = new SlackChannel();

    const result = (channel as unknown as {
      stripMention: (text: string) => string;
    }).stripMention("<@B999> help");

    expect(result).toBe("<@B999> help");
  });

  it("returns original text when no mention present", () => {
    const channel = new SlackChannel();
    Object.assign(channel, { botUserId: "B999" });

    const result = (channel as unknown as {
      stripMention: (text: string) => string;
    }).stripMention("just a regular message");

    expect(result).toBe("just a regular message");
  });
});

// ── Utility: extractUserInfo ────────────────────────────────────────────────

describe("extractUserInfo", () => {
  it("extracts user info from message event", async () => {
    const channel = new SlackChannel();
    const client = createMockClient();

    const result = await (channel as unknown as {
      extractUserInfo: (event: Record<string, unknown>, client: MockClient) => Promise<UserInfo>;
    }).extractUserInfo({
      user: "U123",
      channel: "C456",
      team: "T789",
    }, client);

    expect(result).toEqual({
      userId: "U123",
      teamId: "T789",
      channelId: "C456",
      username: "U123",
    });
  });

  it("handles missing team field", async () => {
    const channel = new SlackChannel();
    const client = createMockClient();

    const result = await (channel as unknown as {
      extractUserInfo: (event: Record<string, unknown>, client: MockClient) => Promise<UserInfo>;
    }).extractUserInfo({
      user: "U123",
      channel: "C456",
    }, client);

    expect(result.teamId).toBe("");
  });
});