import { afterEach, beforeEach, describe, expect, jest, test } from "bun:test";
import {
  apiClient,
  type ChatChannel,
  type ChatMessage,
  type ChatNotification,
  type ChatStateResponse,
} from "../../../api-client";
import { ApiRequestError } from "../../../api-client/errors";
import { MemoryPluginPersistence as MemoryPersistence } from "../../../test-support/plugin-persistence";
import type { AppNotificationRequest } from "../../../types/plugin";
import { ChatController } from "./controller";
import { SESSION_RETRY_MS } from "./controller/state";

const testControllers = new Set<ChatController>();

function createController(): ChatController {
  const controller = new ChatController();
  testControllers.add(controller);
  return controller;
}

function persistSession(persistence: MemoryPersistence, user: Record<string, unknown> = {}) {
  persistence.setState("session", {
    sessionToken: "token-123",
    user: { id: "u1", username: "vince", ...user },
  }, { schemaVersion: 1 });
}

function chatMessage(input: Pick<ChatMessage, "id" | "content" | "createdAt"> & Partial<ChatMessage>): ChatMessage {
  return { channelId: "everyone", replyToId: null, user: { id: "u1", username: "vince", displayName: "Vince" }, ...input };
}

const TRANSCRIPT_KIND = "channel-transcript";
const TRANSCRIPT_KEY = "everyone";
const TRANSCRIPT_SOURCE = "server";
const TRANSCRIPT_SCHEMA_VERSION = 2;
const originalConnectChannel = apiClient.connectChannel.bind(apiClient);
const originalGetSession = apiClient.getSession.bind(apiClient);
const originalGetMessages = apiClient.getMessages.bind(apiClient);
const originalGetChannels = apiClient.getChannels.bind(apiClient);
const originalGetChatPresence = apiClient.getChatPresence.bind(apiClient);
const originalGetChatState = apiClient.getChatState.bind(apiClient);
const originalGetAccountProfile = apiClient.getAccountProfile.bind(apiClient);
const originalUpdateChatChannelState = apiClient.updateChatChannelState.bind(apiClient);
const originalMarkChatNotificationsDelivered = apiClient.markChatNotificationsDelivered.bind(apiClient);
const originalSubscribeChatNotifications = apiClient.subscribeChatNotifications.bind(apiClient);
const originalSubscribeChatPresence = apiClient.subscribeChatPresence.bind(apiClient);
const originalEditMessage = apiClient.editMessage.bind(apiClient);

const SERVER_CHAT_CHANNELS: ChatChannel[] = [
  { id: "everyone", name: "everyone", created_at: "2026-03-26T12:10:05.684Z" },
  { id: "equities", name: "equities", created_at: "2026-05-09T00:00:00.000Z" },
  { id: "options", name: "options", created_at: "2026-05-09T00:00:00.000Z" },
  { id: "help", name: "help", created_at: "2026-05-09T00:00:00.000Z" },
];

async function flushMicrotasks() {
  await Promise.resolve();
  await Promise.resolve();
}

function recentChatTimestamp(offsetMs = 60_000) {
  return new Date(Date.now() - offsetMs).toISOString();
}

function mentionNotification(overrides: Partial<ChatNotification> = {}): ChatNotification {
  const channelId = overrides.channelId ?? "everyone";
  const messageId = overrides.messageId ?? "m1";
  const createdAt = overrides.createdAt ?? "2026-03-28T00:00:00.000Z";
  return {
    id: overrides.id ?? "n1",
    type: overrides.type ?? "mention",
    channelId,
    messageId,
    createdAt,
    message: overrides.message ?? {
      id: messageId,
      channelId,
      content: "hey @vince",
      replyToId: null,
      createdAt,
      user: { id: "u2", username: "bob", displayName: "Bob" },
    },
  };
}

class TrackingPersistence extends MemoryPersistence {
  stateWrites = 0;

  override setState(key: string, value: unknown, options?: { schemaVersion?: number }): void {
    this.stateWrites += 1;
    super.setState(key, value, options);
  }
}

beforeEach(() => {
  apiClient.getChatPresence = async () => ({ onlineCount: 0 });
  apiClient.getChatState = async () => ({
    channels: SERVER_CHAT_CHANNELS,
    onlineCount: 0,
    channelStates: SERVER_CHAT_CHANNELS.map((channel) => ({
      channelId: channel.id,
      notificationsEnabled: false,
      lastReadMessageId: null,
      unreadCount: 0,
    })),
    notifications: [],
  });
  apiClient.updateChatChannelState = async (channelId, body) => ({
    channelId,
    notificationsEnabled: body.notificationsEnabled ?? false,
    lastReadMessageId: body.readThroughMessageId ?? null,
    unreadCount: 0,
  });
  apiClient.markChatNotificationsDelivered = async () => ({ delivered: 1 });
  apiClient.subscribeChatNotifications = () => () => {};
  apiClient.subscribeChatPresence = () => () => {};
});

afterEach(() => {
  for (const controller of testControllers) controller.dispose();
  testControllers.clear();
  jest.useRealTimers();
  apiClient.dispose();
  apiClient.setSessionToken(null);
  apiClient.setCookieSessionMode(false);
  apiClient.connectChannel = originalConnectChannel;
  apiClient.getSession = originalGetSession;
  apiClient.getMessages = originalGetMessages;
  apiClient.getChannels = originalGetChannels;
  apiClient.getChatPresence = originalGetChatPresence;
  apiClient.getChatState = originalGetChatState;
  apiClient.getAccountProfile = originalGetAccountProfile;
  apiClient.updateChatChannelState = originalUpdateChatChannelState;
  apiClient.markChatNotificationsDelivered = originalMarkChatNotificationsDelivered;
  apiClient.subscribeChatNotifications = originalSubscribeChatNotifications;
  apiClient.subscribeChatPresence = originalSubscribeChatPresence;
  apiClient.editMessage = originalEditMessage;
});

describe("ChatController", () => {
  test("hydrates cached session, draft, and transcript from plugin persistence", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const message: ChatMessage = chatMessage({
      id: "m1",
      content: "hello",
      createdAt: "2026-03-28T00:00:00.000Z",
    });

    persistSession(persistence);
    persistence.setState("channel:everyone", {
      draft: "cached draft",
      replyToId: "m1",
      lastCursor: "2026-03-28T00:00:00.000Z",
      lastViewedMessageId: "m1",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [message],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);

    const snapshot = controller.getSnapshot();
    expect(apiClient.getSessionToken()).toBe("token-123");
    expect(snapshot.user?.username).toBe("vince");
    expect(snapshot.draft).toBe("cached draft");
    expect(snapshot.replyToId).toBe("m1");
    expect(snapshot.messages.map((entry) => entry.id)).toEqual(["m1"]);
  });

  test("uses a browser cookie session without exposing its token", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const sentMessages: string[] = [];

    apiClient.setCookieSessionMode(true);
    apiClient.restoreCachedUser({
      id: "u1",
      username: "vince",
      emailVerified: true,
    });
    apiClient.getSession = async () => apiClient.getCurrentUser();
    apiClient.connectChannel = () => ({
      send: async (content) => {
        sentMessages.push(content);
        return {
          id: "m1",
          channelId: "everyone",
          content,
          replyToId: null,
          createdAt: "2026-08-23T00:00:00.000Z",
          user: { id: "u1", username: "vince", displayName: "Vince" },
        };
      },
      close: () => {},
    });

    controller.attachPersistence(persistence);
    await controller.refreshSession();

    expect(apiClient.getSessionToken()).toBeNull();
    expect(controller.getSnapshot()).toMatchObject({
      hasSavedSession: true,
      user: { id: "u1", username: "vince", emailVerified: true },
    });
    expect(controller.send("hello from the browser")).toBe(true);
    await flushMicrotasks();
    expect(sentMessages).toEqual(["hello from the browser"]);
    controller.dispose();
  });

  test("rejects unknown shortcut channels after the server list loads", async () => {
    const controller = createController();
    apiClient.getChannels = async () => SERVER_CHAT_CHANNELS;

    await expect(controller.resolveRequiredChannelId("help")).resolves.toBe("help");
    await expect(controller.resolveRequiredChannelId("made-up")).rejects.toThrow(
      'Unknown chat channel "#made-up".',
    );
  });

  test("keeps private channels when a public refresh finishes after chat state", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const directChannel: ChatChannel = {
      id: "dm:u2",
      name: "u2",
      kind: "direct",
      created_at: "2026-03-28T00:00:00.000Z",
    };
    const teamChannel: ChatChannel = {
      id: "team:org-1:trades",
      name: "trades",
      kind: "team",
      teamId: "org-1",
      created_at: "2026-09-14T00:00:00.000Z",
    };
    let resolvePublicChannels: ((channels: ChatChannel[]) => void) | undefined;

    persistSession(persistence, { emailVerified: true });
    apiClient.getChannels = () => new Promise((resolve) => {
      resolvePublicChannels = resolve;
    });
    apiClient.getChatState = async () => ({
      channels: [...SERVER_CHAT_CHANNELS, directChannel, teamChannel],
      onlineCount: 0,
      channelStates: [],
      notifications: [],
    });
    controller.attachPersistence(persistence);

    const publicRefresh = controller.refreshChannels();
    await controller.refreshChatState();
    expect(controller.getChannels().map((channel) => channel.id)).toContain(directChannel.id);
    expect(controller.getChannels().map((channel) => channel.id)).toContain(teamChannel.id);

    resolvePublicChannels!(SERVER_CHAT_CHANNELS);
    await publicRefresh;

    expect(controller.getChannels().map((channel) => channel.id)).toContain(directChannel.id);
    expect(controller.getChannels().map((channel) => channel.id)).toContain(teamChannel.id);
  });

  test("hydrates a cached verified user into the api client for offline use", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistSession(persistence, { emailVerified: true });

    controller.attachPersistence(persistence);

    expect(apiClient.getCurrentUser()).toMatchObject({
      id: "u1",
      username: "vince",
      emailVerified: true,
    });
    await expect(apiClient.ensureVerifiedSession()).resolves.toMatchObject({
      id: "u1",
      username: "vince",
      emailVerified: true,
    });
  });

  test("does not restore persisted websocket tokens", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistence.setState("session", {
      sessionToken: "token-123",
      websocketToken: "stale-ws-token",
      user: { id: "u1", username: "vince", emailVerified: true },
    }, { schemaVersion: 1 });

    controller.attachPersistence(persistence);

    expect(apiClient.getSessionToken()).toBe("token-123");
    expect(apiClient.getWebSocketToken()).toBeNull();
    expect(apiClient.getCurrentUser()).toMatchObject({
      id: "u1",
      username: "vince",
      emailVerified: true,
    });
  });

  test("reset clears persisted chat state and session token", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistSession(persistence);
    persistence.setState("channel:everyone", {
      draft: "cached draft",
      replyToId: null,
      lastCursor: null,
      lastViewedMessageId: null,
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);
    controller.reset(true);

    expect(apiClient.getSessionToken()).toBeNull();
    expect(persistence.getState("session", { schemaVersion: 1 })).toBeNull();
    expect(persistence.getResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
    })).toBeNull();
  });

  test("defers draft persistence and subscriber sync until the user pauses or leaves", () => {
    const persistence = new TrackingPersistence();
    const controller = createController();
    const draftSnapshots: string[] = [];

    controller.attachPersistence(persistence);
    const unsubscribe = controller.subscribe((snapshot) => {
      draftSnapshots.push(snapshot.draft);
    });
    draftSnapshots.length = 0;
    persistence.stateWrites = 0;

    controller.setDraft("h");
    controller.setDraft("he");

    expect(controller.getSnapshot().draft).toBe("he");
    expect(draftSnapshots).toEqual([]);
    expect(persistence.stateWrites).toBe(0);
    expect(persistence.getState("channel:everyone", { schemaVersion: 1 })).toBeNull();

    unsubscribe();
    controller.dispose();

    expect(persistence.getState<{ draft: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      draft: "he",
    });
  });

  test("pauses verification polling while the app is backgrounded", () => {
    const controller = createController();

    apiClient.setSessionToken("token-123");
    (controller as any).session.sessionToken = "token-123";
    (controller as any).session.user = { id: "u1", username: "vince", emailVerified: false };

    controller.setAppActive(false);
    (controller as any).realtime.syncVerificationPolling();
    expect((controller as any).realtime.verificationPollTimer).toBeNull();

    controller.setAppActive(true);
    expect((controller as any).realtime.verificationPollTimer).not.toBeNull();

    controller.reset(true);
  });

  test("dispose stops verification polling and closes the live connection", () => {
    const controller = createController();
    let closed = false;

    apiClient.setSessionToken("token-123");
    (controller as any).session.sessionToken = "token-123";
    (controller as any).session.user = { id: "u1", username: "vince", emailVerified: false };
    (controller as any).realtime.syncVerificationPolling();
    expect((controller as any).realtime.verificationPollTimer).not.toBeNull();

    (controller as any).session.user = { id: "u1", username: "vince", emailVerified: true };
    apiClient.connectChannel = () => ({
      send: async () => {
        throw new Error("not implemented");
      },
      close: () => {
        closed = true;
      },
    });

    controller.ensureConnection();

    controller.dispose();

    expect(closed).toBe(true);
    expect((controller as any).realtime.verificationPollTimer).toBeNull();
  });

  test("runs a quiet safety refresh while the live connection is active", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const originalSetInterval = globalThis.setInterval;
    const originalClearInterval = globalThis.clearInterval;
    const intervalCallbacks: Array<() => void> = [];
    const intervalHandle = { unref: () => {} };
    let cleared = false;
    let getMessagesCalls = 0;
    const loadingSnapshots: boolean[] = [];

    persistSession(persistence, { emailVerified: true });

    (globalThis as any).setInterval = (callback: () => void, timeout: number) => {
      expect(timeout).toBe(30_000);
      intervalCallbacks.push(callback);
      return intervalHandle;
    };
    (globalThis as any).clearInterval = (handle: unknown) => {
      if (handle === intervalHandle) {
        cleared = true;
      }
    };

    try {
      apiClient.getMessages = async () => {
        getMessagesCalls += 1;
        return [];
      };
      apiClient.connectChannel = () => ({
        send: async () => {
          throw new Error("not implemented");
        },
        close: () => {},
      });

      controller.attachPersistence(persistence);
      controller.ensureConnection();
      await flushMicrotasks();

      expect(intervalCallbacks).toHaveLength(1);
      expect(getMessagesCalls).toBe(1);
      expect(controller.getSnapshot().loading).toBe(false);

      controller.subscribe((snapshot) => {
        loadingSnapshots.push(snapshot.loading);
      });
      loadingSnapshots.length = 0;

      intervalCallbacks[0]!();
      await flushMicrotasks();

      expect(getMessagesCalls).toBe(2);
      expect(loadingSnapshots).toEqual([false]);

      controller.clearSession();
      expect((controller as any).realtime.safetyRefreshTimer).toBeNull();
      expect(cleared).toBe(true);
    } finally {
      controller.dispose();
      (globalThis as any).setInterval = originalSetInterval;
      (globalThis as any).clearInterval = originalClearInterval;
    }
  });

  test("validates a persisted native session through protected chat state", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const directChannel: ChatChannel = {
      id: "dm:u2",
      name: "u2",
      kind: "direct",
      created_at: "2026-03-28T00:00:00.000Z",
    };

    persistSession(persistence, { emailVerified: true });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      apiClient.restoreCachedUser(null);
      return null;
    };
    apiClient.getChatState = async () => ({
      channels: [...SERVER_CHAT_CHANNELS, directChannel],
      onlineCount: 0,
      channelStates: [],
      notifications: [],
    });

    await controller.refreshSession();

    expect(apiClient.getSessionToken()).toBe("token-123");
    expect(apiClient.getCurrentUser()?.id).toBe("u1");
    expect(controller.getChannels()).toContainEqual(directChannel);
    expect(persistence.getState<{
      sessionToken: string;
      user: { id: string; username: string; emailVerified: boolean };
    }>("session", { schemaVersion: 1 })).toEqual({
      sessionToken: "token-123",
      user: { id: "u1", username: "vince", emailVerified: true },
    });
    expect(controller.getSnapshot().user).toEqual({
      id: "u1",
      username: "vince",
      emailVerified: true,
    });
    controller.dispose();
  });

  test("clears an expired persisted session when protected chat rejects it", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistence.setState("session", {
      sessionToken: "expired-token",
      user: { id: "u1", username: "vince", emailVerified: true },
    }, { schemaVersion: 1 });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      apiClient.restoreCachedUser(null);
      return null;
    };
    apiClient.getChatState = async () => {
      throw new ApiRequestError("Unauthorized", 401);
    };

    await controller.refreshSession();

    expect(apiClient.getSessionToken()).toBeNull();
    expect(apiClient.getCurrentUser()).toBeNull();
    expect(controller.getSnapshot().user).toBeNull();
    expect(persistence.getState("session", { schemaVersion: 1 })).toEqual({
      sessionToken: null,
      user: null,
    });
    controller.dispose();
  });

  test("clears an expired persisted session for an unverified user", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    let profileRequests = 0;

    persistence.setState("session", {
      sessionToken: "expired-token",
      user: { id: "u1", username: "vince", emailVerified: false },
    }, { schemaVersion: 1 });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      apiClient.restoreCachedUser(null);
      return null;
    };
    apiClient.getAccountProfile = async () => {
      profileRequests += 1;
      throw new ApiRequestError("Unauthorized", 401);
    };

    await controller.refreshSession();

    expect(profileRequests).toBe(1);
    expect(apiClient.getSessionToken()).toBeNull();
    expect(apiClient.getCurrentUser()).toBeNull();
    expect(controller.getSnapshot().user).toBeNull();
    controller.dispose();
  });

  test("downgrades stale verification state when protected chat rejects it", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistSession(persistence, { emailVerified: true });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      apiClient.restoreCachedUser(null);
      return null;
    };
    apiClient.getChatState = async () => {
      throw new ApiRequestError("Email verification required", 403);
    };

    await controller.refreshSession();

    expect(apiClient.getSessionToken()).toBe("token-123");
    expect(apiClient.getCurrentUser()?.emailVerified).toBe(false);
    expect(controller.getSnapshot().user?.emailVerified).toBe(false);
    expect(persistence.getState<{
      sessionToken: string;
      user: { id: string; username: string; emailVerified: boolean };
    }>("session", { schemaVersion: 1 })?.user.emailVerified).toBe(false);
    controller.dispose();
  });

  test("does not let a stale validation failure clear a replacement session", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    let rejectProbe: ((error: Error) => void) | null = null;
    let markProbeStarted: (() => void) | null = null;
    const probeStarted = new Promise<void>((resolve) => {
      markProbeStarted = resolve;
    });

    persistence.setState("session", {
      sessionToken: "old-token",
      user: { id: "u1", username: "vince", emailVerified: true },
    }, { schemaVersion: 1 });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      apiClient.restoreCachedUser(null);
      return null;
    };
    apiClient.getChatState = () => new Promise((_, reject) => {
      rejectProbe = reject;
      markProbeStarted?.();
    });

    const refresh = controller.refreshSession();
    await probeStarted;
    controller.adoptSession("new-token", {
      id: "u2",
      username: "mara",
      emailVerified: true,
    });
    rejectProbe?.(new ApiRequestError("Unauthorized", 401));
    await refresh;

    expect(apiClient.getSessionToken()).toBe("new-token");
    expect(apiClient.getCurrentUser()?.id).toBe("u2");
    expect(controller.getSnapshot().user?.id).toBe("u2");
    expect(persistence.getState<{
      sessionToken: string;
      user: { id: string };
    }>("session", { schemaVersion: 1 })).toMatchObject({
      sessionToken: "new-token",
      user: { id: "u2" },
    });
    controller.dispose();
  });

  test("does not apply stale chat state after a replacement session", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    let resolveProbe: ((state: ChatStateResponse) => void) | null = null;
    let markProbeStarted: (() => void) | null = null;
    const probeStarted = new Promise<void>((resolve) => {
      markProbeStarted = resolve;
    });
    const oldDirectChannel: ChatChannel = {
      id: "dm:old-account",
      name: "old-account",
      kind: "direct",
      created_at: "2026-03-28T00:00:00.000Z",
    };

    persistence.setState("session", {
      sessionToken: "old-token",
      user: { id: "u1", username: "vince", emailVerified: true },
    }, { schemaVersion: 1 });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      apiClient.restoreCachedUser(null);
      return null;
    };
    apiClient.getChatState = () => new Promise<ChatStateResponse>((resolve) => {
      resolveProbe = resolve;
      markProbeStarted?.();
    });

    const refresh = controller.refreshSession();
    await probeStarted;
    controller.adoptSession("new-token", {
      id: "u2",
      username: "mara",
      emailVerified: true,
    });
    resolveProbe?.({
      channels: [...SERVER_CHAT_CHANNELS, oldDirectChannel],
      onlineCount: 0,
      channelStates: [],
      notifications: [],
    });
    await refresh;

    expect(apiClient.getSessionToken()).toBe("new-token");
    expect(controller.getSnapshot().user?.id).toBe("u2");
    expect(controller.getChannels()).not.toContainEqual(oldDirectChannel);
    controller.dispose();
  });

  test("revalidates a persisted session after an offline validation probe", async () => {
    jest.useFakeTimers();
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistSession(persistence, { emailVerified: true });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      apiClient.restoreCachedUser(null);
      return null;
    };
    apiClient.getChatState = async () => {
      throw new Error("network down");
    };

    await controller.refreshSession();

    expect(apiClient.getSessionToken()).toBe("token-123");
    expect(apiClient.getCurrentUser()?.id).toBe("u1");
    expect(controller.getSnapshot().user?.id).toBe("u1");
    expect((controller as any).realtime.sessionRetryTimer).not.toBeNull();

    apiClient.getChatState = async () => {
      throw new ApiRequestError("Unauthorized", 401);
    };
    jest.advanceTimersByTime(SESSION_RETRY_MS);
    await controller.refreshSession();

    expect(apiClient.getSessionToken()).toBeNull();
    expect(controller.getSnapshot().user).toBeNull();
    expect((controller as any).realtime.sessionRetryTimer).toBeNull();
    controller.dispose();
    jest.useRealTimers();
  });

  test("signs out when get-session returns no user and no token is stored", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistence.setState("session", {
      sessionToken: null,
      user: { id: "u1", username: "vince", emailVerified: true },
    }, { schemaVersion: 1 });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => null;

    await controller.refreshSession();

    expect(apiClient.getSessionToken()).toBeNull();
    expect(controller.getSnapshot().user).toBeNull();
    controller.dispose();
  });

  test("keeps the cached session when session refresh fails transiently", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();

    persistSession(persistence, { emailVerified: true });

    controller.attachPersistence(persistence);
    apiClient.getSession = async () => {
      throw new Error("network down");
    };

    await expect(controller.refreshSession()).rejects.toThrow("network down");
    expect(apiClient.getSessionToken()).toBe("token-123");
    expect(persistence.getState<{
      sessionToken: string;
      user: { id: string; username: string; emailVerified: boolean };
    }>("session", { schemaVersion: 1 })).toEqual({
      sessionToken: "token-123",
      user: { id: "u1", username: "vince", emailVerified: true },
    });
    expect(controller.getSnapshot().user).toEqual({
      id: "u1",
      username: "vince",
      emailVerified: true,
    });
    expect((controller as any).realtime.sessionRetryTimer).not.toBeNull();
    controller.dispose();
  });

  test("refreshes the public transcript without requiring a session", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const message: ChatMessage = chatMessage({
      id: "m1",
      content: "hello from the lobby",
      createdAt: "2026-03-28T00:00:00.000Z",
    });

    controller.attachPersistence(persistence);
    apiClient.getMessages = async () => [message];

    await controller.refreshMessages();

    expect(controller.getSnapshot().messages).toEqual([message]);
    expect(persistence.getResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
    })?.value).toEqual({
      messages: [message],
    });
  });

  test("keeps per-channel drafts and transcripts isolated", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const everyoneMessage: ChatMessage = chatMessage({
      id: "m1",
      content: "general",
      createdAt: "2026-03-28T00:00:00.000Z",
    });
    const optionsMessage: ChatMessage = chatMessage({
      id: "m2",
      channelId: "options",
      content: "options note",
      createdAt: "2026-03-28T00:01:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistence.setState("channel:everyone", {
      draft: "general draft",
      replyToId: null,
      lastCursor: "m1",
      lastViewedMessageId: "m1",
    }, { schemaVersion: 1 });
    persistence.setState("channel:options", {
      draft: "options draft",
      replyToId: null,
      lastCursor: "m2",
      lastViewedMessageId: "m2",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, "everyone", { messages: [everyoneMessage] }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });
    persistence.setResource(TRANSCRIPT_KIND, "options", { messages: [optionsMessage] }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);
    controller.setChannelDraft("options", "updated options");

    expect(controller.getSnapshot().messages.map((entry) => entry.content)).toEqual(["general"]);
    expect(controller.getSnapshot().draft).toBe("general draft");
    expect(controller.getSnapshot("options").messages.map((entry) => entry.content)).toEqual(["options note"]);
    expect(controller.getSnapshot("options").draft).toBe("updated options");
  });

  test("stores the latest message id as the incremental cursor", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const initial: ChatMessage = chatMessage({
      id: "m1",
      content: "hello",
      createdAt: "2026-03-28T00:00:00.000Z",
    });
    const next: ChatMessage = chatMessage({
      id: "m2",
      content: "new message",
      createdAt: "2026-03-28T00:01:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistence.setState("channel:everyone", {
      draft: "",
      replyToId: null,
      lastCursor: "m1",
      lastViewedMessageId: "m1",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [initial],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);

    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
    apiClient.getMessages = async (channelId, opts) => {
      calls.push({ channelId, opts });
      if (!opts?.after) return [initial, next];
      return opts.after === "m1" ? [next] : [];
    };

    await controller.refreshMessages();

    expect(calls[0]?.opts?.after).toBeUndefined();
    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      lastCursor: "m2",
    });

    await controller.refreshMessages();

    expect(calls[1]?.opts?.after).toBe("m2");
  });

  test("recovers a message the cursor already moved past", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const asked: ChatMessage = chatMessage({
      id: "m1",
      content: "why is the chart glitching",
      createdAt: "2026-03-28T00:00:00.000Z",
    });
    const missed: ChatMessage = chatMessage({
      id: "m2",
      content: "charts open with GP",
      replyToId: "m1",
      createdAt: "2026-03-28T00:01:00.000Z",
      user: { id: "u2", username: "gloombot", displayName: "Gloombot" },
    });
    const acknowledged: ChatMessage = chatMessage({
      id: "m3",
      content: "got it",
      createdAt: "2026-03-28T00:02:00.000Z",
    });

    // The cursor already sits on m3, so an incremental fetch can never ask for
    // m2 again even though the server still has it.
    persistence.setState("channel:everyone", {
      draft: "",
      replyToId: null,
      lastCursor: "m3",
      lastViewedMessageId: "m3",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [asked, acknowledged],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);

    apiClient.getMessages = async (_channelId, opts) => (
      opts?.after ? [] : [asked, missed, acknowledged]
    );

    await controller.refreshMessages();

    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2", "m3"]);
  });

  test("hydrates missing transcript cache without marking history unread", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const history: ChatMessage = chatMessage({
      id: "m1",
      content: "already seen",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistSession(persistence, { emailVerified: true });
    persistence.setState("channel:everyone", {
      draft: "",
      replyToId: null,
      lastCursor: "m1",
      lastViewedMessageId: "m1",
    }, { schemaVersion: 1 });

    controller.setNotifier((notification) => {
      notifications.push(notification);
    });
    controller.attachPersistence(persistence);

    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
    apiClient.getMessages = async (channelId, opts) => {
      calls.push({ channelId, opts });
      return opts?.after ? [] : [history];
    };

    await controller.refreshMessages();

    expect(calls).toEqual([{
      channelId: "everyone",
      opts: { limit: 50, after: undefined },
    }]);
    expect(controller.getSnapshot().messages).toEqual([history]);
    expect(controller.getSnapshot().channelStates.find((entry) => entry.channelId === "everyone")).toMatchObject({
      unreadCount: 0,
    });
    expect(notifications).toEqual([]);
  });

  test("backfills from cached transcript when persisted cursor is ahead of the cache", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const cached: ChatMessage = chatMessage({
      id: "m1",
      content: "cached",
      createdAt: "2026-03-28T00:00:00.000Z",
    });
    const fresh: ChatMessage = chatMessage({
      id: "m2",
      content: "fresh",
      createdAt: "2026-03-28T00:01:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistence.setState("channel:everyone", {
      draft: "",
      replyToId: null,
      lastCursor: "m99",
      lastViewedMessageId: "m1",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [cached],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);

    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
    apiClient.getMessages = async (channelId, opts) => {
      calls.push({ channelId, opts });
      return opts?.after ? [] : [cached, fresh];
    };

    await controller.refreshMessages();

    expect(calls[0]?.opts?.after).toBeUndefined();
    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      lastCursor: "m2",
    });

    await controller.refreshMessages();

    // The stale m99 cursor never reaches the server.
    expect(calls[1]?.opts?.after).toBe("m2");
  });

  test("shows a pending message immediately and replaces it when the send succeeds", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const replyTarget: ChatMessage = chatMessage({
      id: "m1",
      content: "first",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });
    const sentMessage: ChatMessage = chatMessage({
      id: "m2",
      content: "hello",
      replyToId: "m1",
      createdAt: "2026-03-28T00:01:00.000Z",
      replyTo: { content: "first", user: { username: "bob" } },
    });

    persistSession(persistence, { emailVerified: true });
    persistence.setState("channel:everyone", {
      draft: "hello",
      replyToId: "m1",
      lastCursor: "m1",
      lastViewedMessageId: "m1",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [replyTarget],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);

    let resolveSend: (message: ChatMessage) => void = () => {
      throw new Error("send resolver was not captured");
    };
    apiClient.connectChannel = () => ({
      send: () => new Promise<ChatMessage>((resolve) => {
        resolveSend = resolve;
      }),
      close: () => {},
    });

    controller.send("hello", "m1");

    let snapshot = controller.getSnapshot();
    expect(snapshot.draft).toBe("");
    expect(snapshot.replyToId).toBeNull();
    expect(snapshot.messages.map((message) => message.id)).toEqual(["m1", snapshot.messages[1]!.id]);
    expect(snapshot.messages[1]).toMatchObject({
      content: "hello",
      replyToId: "m1",
      clientStatus: "sending",
      replyTo: { content: "first", user: { username: "bob" } },
    });

    resolveSend?.(sentMessage);
    await flushMicrotasks();

    snapshot = controller.getSnapshot();
    expect(snapshot.messages).toEqual([replyTarget, sentMessage]);
  });

  test("sends one idempotency key while the same message is pending", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const clientMessageIds: Array<string | undefined> = [];

    persistSession(persistence, { emailVerified: true });

    controller.attachPersistence(persistence);
    apiClient.getMessages = async () => [];
    apiClient.connectChannel = () => ({
      send: (_content, _replyToId, clientMessageId) => {
        clientMessageIds.push(clientMessageId);
        return new Promise<ChatMessage>(() => {});
      },
      close: () => {},
    });

    const detachFirstView = controller.attachChannelView("everyone");
    const detachSecondView = controller.attachChannelView("everyone");

    controller.sendToChannel("everyone", " hello ");
    controller.sendToChannel("everyone", "hello");

    expect(clientMessageIds).toHaveLength(1);
    expect(clientMessageIds[0]).toBeTruthy();
    expect(controller.getSnapshot("everyone").messages).toHaveLength(1);

    detachFirstView();
    detachSecondView();
  });

  test("edits the latest message from the current user", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const original: ChatMessage = chatMessage({
      id: "m1",
      content: "helo",
      createdAt: recentChatTimestamp(),
    });

    persistSession(persistence, { emailVerified: true });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [original],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });
    controller.attachPersistence(persistence);
    apiClient.editMessage = async (channelId, messageId, content) => ({
      ...original,
      channelId,
      id: messageId,
      content,
      editedAt: "2026-03-28T00:01:00.000Z",
    });

    await expect(controller.editChannelMessage("everyone", "m1", "hello")).resolves.toBe(true);

    const [edited] = controller.getSnapshot().messages;
    expect(edited).toMatchObject({
      id: "m1",
      content: "hello",
      editedAt: "2026-03-28T00:01:00.000Z",
    });
  });

  test("refuses to edit after the edit window expires", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const original: ChatMessage = chatMessage({
      id: "m1",
      content: "old typo",
      createdAt: recentChatTimestamp(16 * 60_000),
    });

    persistSession(persistence, { emailVerified: true });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [original],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });
    controller.setNotifier((notification) => notifications.push(notification));
    controller.attachPersistence(persistence);
    apiClient.editMessage = async () => {
      throw new Error("should not call server");
    };

    await expect(controller.editChannelMessage("everyone", "m1", "old fix")).resolves.toBe(false);

    expect(controller.getSnapshot().messages[0]?.content).toBe("old typo");
    expect(notifications).toEqual([{ body: "Messages can only be edited within 15 minutes.", type: "error" }]);
  });

  test("refuses to edit an older message from the current user", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const messages: ChatMessage[] = [
      chatMessage({
        id: "m1",
        content: "older",
        createdAt: "2026-03-28T00:00:00.000Z",
      }),
      chatMessage({
        id: "m2",
        content: "newer",
        createdAt: "2026-03-28T00:01:00.000Z",
      }),
    ];

    persistSession(persistence, { emailVerified: true });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages,
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });
    controller.setNotifier((notification) => notifications.push(notification));
    controller.attachPersistence(persistence);
    apiClient.editMessage = async () => {
      throw new Error("should not call server");
    };

    await expect(controller.editChannelMessage("everyone", "m1", "edited")).resolves.toBe(false);

    expect(controller.getSnapshot().messages.map((message) => message.content)).toEqual(["older", "newer"]);
    expect(notifications).toEqual([{ body: "Only your latest sent message can be edited.", type: "error" }]);
  });

  test("marks a pending message as failed when sending errors", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];

    persistSession(persistence, { emailVerified: true });

    controller.setNotifier((notification) => {
      notifications.push(notification);
    });
    controller.attachPersistence(persistence);

    apiClient.connectChannel = () => ({
      send: async () => {
        throw new Error("server offline");
      },
      close: () => {},
    });

    controller.send("hello");
    await flushMicrotasks();

    const snapshot = controller.getSnapshot();
    expect(snapshot.messages).toHaveLength(1);
    expect(snapshot.messages[0]).toMatchObject({
      content: "hello",
      clientStatus: "failed",
      clientError: "server offline",
    });
    expect(notifications).toEqual([{ body: "server offline", type: "error" }]);
  });

  test("tracks unread mentions from fetched messages without issuing local notifications", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const message: ChatMessage = chatMessage({
      id: "m1",
      content: "hey @Vince can you take a look?",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistSession(persistence, { emailVerified: true });

    controller.setNotifier((notification) => {
      notifications.push(notification);
    });
    controller.attachPersistence(persistence);

    (controller as any).mergeMessages([message]);

    expect(controller.getSnapshot().unreadMentionCount).toBe(1);
    expect(notifications).toEqual([]);
    expect(persistence.getState<{ lastCursor: string | null; lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      lastCursor: "m1",
      lastViewedMessageId: null,
    });
  });

  test("delivers background notifications while the focused chat stays unread", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const deliveredIds: string[][] = [];

    persistSession(persistence, { emailVerified: true });

    controller.setNotifier((notification) => {
      notifications.push(notification);
      return { toastVisible: false, desktopRequested: true };
    });
    apiClient.markChatNotificationsDelivered = async (ids) => {
      deliveredIds.push(ids);
      return { delivered: ids.length };
    };
    controller.attachPersistence(persistence);
    const detachView = controller.attachView(true);
    controller.setAppActive(false);

    (controller as any).handleChatNotification(mentionNotification());

    expect(notifications).toEqual([{
      title: "#everyone",
      body: "@bob mentioned you: hey @vince",
      type: "info",
      desktop: "when-inactive",
    }]);
    expect(controller.getSnapshot().unreadMentionCount).toBe(1);
    expect(deliveredIds).toEqual([["n1"]]);

    controller.setAppActive(true);
    await flushMicrotasks();
    await flushMicrotasks();
    expect(controller.getSnapshot().unreadMentionCount).toBe(0);
    detachView();
  });

  test("keeps undeliverable background notifications pending for email fallback", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const deliveredIds: string[][] = [];
    let desktopAvailable = false;
    let presentationCount = 0;

    persistSession(persistence, { emailVerified: true });
    controller.setNotifier(() => {
      presentationCount += 1;
      return { toastVisible: false, desktopRequested: desktopAvailable };
    });
    apiClient.markChatNotificationsDelivered = async (ids) => {
      deliveredIds.push(ids);
      return { delivered: ids.length };
    };
    controller.attachPersistence(persistence);
    controller.setAppActive(false);

    const notification = mentionNotification({ type: "reply" });
    (controller as any).handleChatNotification(notification);

    expect(presentationCount).toBe(1);
    expect(deliveredIds).toEqual([]);

    desktopAvailable = true;
    (controller as any).handleChatNotification({ ...notification, id: "n2" });

    expect(presentationCount).toBe(2);
    expect(deliveredIds).toEqual([["n2"]]);
  });

  test("marks mentions viewed when a chat view opens", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const message: ChatMessage = chatMessage({
      id: "m1",
      content: "hey @vince",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistSession(persistence, { emailVerified: true });

    controller.setNotifier((notification) => {
      notifications.push(notification);
    });
    controller.attachPersistence(persistence);

    (controller as any).mergeMessages([message]);

    expect(controller.getSnapshot().unreadMentionCount).toBe(1);

    const detachView = controller.attachView();

    expect(controller.getSnapshot().unreadMentionCount).toBe(0);
    expect(notifications).toEqual([]);
    expect(persistence.getState<{ lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      lastViewedMessageId: "m1",
    });
    detachView();
  });

  test("keeps focused foreground notifications read without presenting an alert", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const deliveredIds: string[][] = [];

    persistSession(persistence, { emailVerified: true });

    controller.setNotifier((notification) => {
      notifications.push(notification);
    });
    apiClient.markChatNotificationsDelivered = async (ids) => {
      deliveredIds.push(ids);
      return { delivered: ids.length };
    };
    controller.attachPersistence(persistence);
    const detachView = controller.attachView(true);

    (controller as any).handleChatNotification(mentionNotification());

    expect(controller.getSnapshot().unreadMentionCount).toBe(0);
    expect(notifications).toEqual([]);
    expect(deliveredIds).toEqual([["n1"]]);
    expect(persistence.getState<{ lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      lastViewedMessageId: "m1",
    });

    detachView();
  });

  test("keeps an unfocused foreground chat unread while presenting an in-app alert", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const deliveredIds: string[][] = [];

    persistSession(persistence, { emailVerified: true });
    controller.setNotifier((notification) => {
      notifications.push(notification);
      return { toastVisible: true, desktopRequested: false };
    });
    apiClient.markChatNotificationsDelivered = async (ids) => {
      deliveredIds.push(ids);
      return { delivered: ids.length };
    };
    controller.attachPersistence(persistence);
    const detachUnfocusedView = controller.attachView(false);

    (controller as any).handleChatNotification(mentionNotification());

    expect(notifications).toHaveLength(1);
    expect(controller.getSnapshot().unreadMentionCount).toBe(1);
    expect(deliveredIds).toEqual([["n1"]]);

    detachUnfocusedView();
    const detachFocusedView = controller.attachView(true);
    expect(controller.getSnapshot().unreadMentionCount).toBe(0);
    detachFocusedView();
  });

  test("loads server chat state, pending reply notifications, and acks delivery", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const deliveredIds: string[][] = [];

    persistSession(persistence, { emailVerified: true });
    apiClient.getSession = async () => ({
      id: "u1",
      name: "Vince",
      email: "vince@example.com",
      username: "vince",
      emailVerified: true,
      image: null,
      createdAt: "2026-01-01T00:00:00.000Z",
      updatedAt: "2026-01-01T00:00:00.000Z",
    });
    apiClient.getChatState = async () => ({
      channels: SERVER_CHAT_CHANNELS,
      onlineCount: 7,
      channelStates: [{
        channelId: "options",
        notificationsEnabled: true,
        lastReadMessageId: "m1",
        unreadCount: 3,
      }],
      notifications: [{
        id: "n1",
        type: "reply",
        channelId: "options",
        messageId: "m2",
        createdAt: "2026-03-28T00:02:00.000Z",
        message: chatMessage({
          id: "m2",
          channelId: "options",
          content: "answering you",
          replyToId: "m1",
          createdAt: "2026-03-28T00:02:00.000Z",
          user: { id: "u2", username: "bob", displayName: "Bob" },
          replyTo: { content: "question", user: { id: "u1", username: "vince" } },
        }),
      }],
    });
    apiClient.markChatNotificationsDelivered = async (ids) => {
      deliveredIds.push(ids);
      return { delivered: ids.length };
    };
    apiClient.connectChannel = () => ({
      send: async () => {
        throw new Error("not implemented");
      },
      close: () => {},
    });

    controller.setNotifier((notification) => {
      notifications.push(notification);
      return { toastVisible: true, desktopRequested: false };
    });
    controller.attachPersistence(persistence);

    await controller.refreshSession();

    expect(controller.getSnapshot("options").onlineCount).toBe(7);
    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
      notificationsEnabled: true,
      unreadCount: 3,
    });
    expect(notifications).toEqual([{
      title: "#options",
      body: "@bob replied to you: answering you",
      type: "info",
      desktop: "when-inactive",
    }]);
    expect(deliveredIds).toEqual([["n1"]]);
  });

  test("toggles channel notifications optimistically and keeps the channel connected", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const connectedChannels: string[] = [];

    persistSession(persistence, { emailVerified: true });
    apiClient.updateChatChannelState = async (channelId, body) => ({
      channelId,
      notificationsEnabled: body.notificationsEnabled === true,
      lastReadMessageId: null,
      unreadCount: 0,
    });
    apiClient.connectChannel = (channelId) => {
      connectedChannels.push(channelId);
      return {
        send: async () => {
          throw new Error("not implemented");
        },
        close: () => {},
      };
    };

    controller.attachPersistence(persistence);
    controller.setChannelNotificationsEnabled("options", true);
    await flushMicrotasks();

    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
      notificationsEnabled: true,
    });
    expect(connectedChannels).toContain("options");
  });

  test("dedupes reply notifications by message id", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const notification: ChatNotification = {
      id: "n1",
      type: "reply",
      channelId: "everyone",
      messageId: "m2",
      createdAt: "2026-03-28T00:02:00.000Z",
      message: chatMessage({
        id: "m2",
        content: "same reply",
        replyToId: "m1",
        createdAt: "2026-03-28T00:02:00.000Z",
        user: { id: "u2", username: "bob", displayName: "Bob" },
        replyTo: { content: "question", user: { id: "u1", username: "vince" } },
      }),
    };

    persistSession(persistence, { emailVerified: true });
    controller.setNotifier((entry) => {
      notifications.push(entry);
      return { toastVisible: true, desktopRequested: false };
    });
    controller.attachPersistence(persistence);

    (controller as any).handleChatNotification(notification);
    (controller as any).handleChatNotification({ ...notification, id: "n2" });

    expect(notifications).toHaveLength(1);
  });

  test("opens a server-issued channel notification at its exact message", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const openedMessages: string[] = [];
    const message: ChatMessage = chatMessage({
      id: "m1",
      channelId: "options",
      content: "new option flow",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistSession(persistence, { emailVerified: true });
    controller.setNotifier((entry) => {
      notifications.push(entry);
    }, (channelId, messageId) => {
      openedMessages.push(`${channelId}:${messageId}`);
    });
    controller.attachPersistence(persistence);

    (controller as any).handleChatNotification({
      id: "n1",
      type: "channel",
      channelId: "options",
      messageId: "m1",
      createdAt: "2026-03-28T00:00:00.000Z",
      message,
    } satisfies ChatNotification);

    expect(notifications).toEqual([{
      title: "#options",
      body: "@bob: new option flow",
      type: "info",
      desktop: "when-inactive",
      action: expect.objectContaining({ label: "Open" }),
    }]);
    notifications[0]?.action?.onClick();
    expect(openedMessages).toEqual(["options:m1"]);
  });

  test("uses direct channel labels in server-issued notification titles", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const directChannel: ChatChannel = {
      id: "dm:u2",
      name: "u2",
      kind: "direct",
      created_at: "2026-03-28T00:00:00.000Z",
      dmUser: { id: "u2", username: "bob", displayName: "Bob" },
    };
    const message: ChatMessage = chatMessage({
      id: "m1",
      channelId: directChannel.id,
      content: "ping",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    apiClient.getChatState = async () => ({
      channels: [...SERVER_CHAT_CHANNELS, directChannel],
      onlineCount: 0,
      channelStates: [...SERVER_CHAT_CHANNELS, directChannel].map((channel) => ({
        channelId: channel.id,
        notificationsEnabled: false,
        lastReadMessageId: null,
        unreadCount: 0,
      })),
      notifications: [],
    });
    persistSession(persistence, { emailVerified: true });
    controller.setNotifier((entry) => {
      notifications.push(entry);
    });
    controller.attachPersistence(persistence);
    await controller.refreshChatState();

    (controller as any).handleChatNotification({
      id: "n1",
      type: "channel",
      channelId: directChannel.id,
      messageId: "m1",
      createdAt: "2026-03-28T00:00:00.000Z",
      message,
    } satisfies ChatNotification);

    expect(notifications).toEqual([{
      title: "@bob",
      body: "ping",
      type: "info",
      desktop: "when-inactive",
    }]);
  });

  test("tracks unread channel messages and clears them when the channel opens", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const message: ChatMessage = chatMessage({
      id: "m1",
      channelId: "options",
      content: "new option flow",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
    });

    persistSession(persistence, { emailVerified: true });
    controller.attachPersistence(persistence);

    (controller as any).mergeMessages("options", [message]);

    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
      unreadCount: 1,
    });

    const detachView = controller.attachChannelView("options");

    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
      unreadCount: 0,
    });
    detachView();
  });

  test("server reply notifications fire even when channel notifications are disabled", () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const notifications: AppNotificationRequest[] = [];
    const message: ChatMessage = chatMessage({
      id: "m2",
      channelId: "options",
      content: "reply without channel notify",
      replyToId: "m1",
      createdAt: "2026-03-28T00:00:00.000Z",
      user: { id: "u2", username: "bob", displayName: "Bob" },
      replyTo: { content: "question", user: { id: "u1", username: "vince" } },
    });

    persistSession(persistence, { emailVerified: true });
    controller.setNotifier((notification) => {
      notifications.push(notification);
    });
    controller.attachPersistence(persistence);

    (controller as any).handleChatNotification({
      id: "n1",
      type: "reply",
      channelId: "options",
      messageId: "m2",
      createdAt: "2026-03-28T00:00:00.000Z",
      message,
    } satisfies ChatNotification);

    expect(notifications).toEqual([{
      title: "#options",
      body: "@bob replied to you: reply without channel notify",
      type: "info",
      desktop: "when-inactive",
    }]);
  });

  test("recovers from a legacy timestamp cursor by falling back to a full transcript fetch", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const cached: ChatMessage = chatMessage({
      id: "m1",
      content: "cached",
      createdAt: "2026-03-28T00:00:00.000Z",
    });
    const fullTranscript: ChatMessage[] = [
      cached,
      chatMessage({
        id: "m2",
        content: "fresh",
        createdAt: "2026-03-28T00:01:00.000Z",
        user: { id: "u2", username: "bob", displayName: "Bob" },
      }),
    ];

    persistence.setState("channel:everyone", {
      draft: "",
      replyToId: null,
      lastCursor: "2026-03-28T00:00:00.000Z",
      lastViewedMessageId: "m1",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: [cached],
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);

    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
    apiClient.getMessages = async (channelId, opts) => {
      calls.push({ channelId, opts });
      return opts?.after ? [] : fullTranscript;
    };

    await controller.refreshMessages();

    // The session backfill already ignores the cursor, so the legacy timestamp
    // is never sent and the old wasted round trip is gone.
    expect(calls).toHaveLength(1);
    expect(calls[0]?.opts?.after).toBeUndefined();
    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      lastCursor: "m2",
    });
  });

  test("loads older messages before the oldest cached message without moving the latest cursor", async () => {
    const persistence = new MemoryPersistence();
    const controller = createController();
    const cached: ChatMessage[] = [
      chatMessage({
        id: "m3",
        content: "cached older",
        createdAt: "2026-03-28T00:03:00.000Z",
        user: { id: "u3", username: "cara", displayName: "Cara" },
      }),
      chatMessage({
        id: "m4",
        content: "cached newer",
        createdAt: "2026-03-28T00:04:00.000Z",
        user: { id: "u4", username: "drew", displayName: "Drew" },
      }),
    ];
    const older: ChatMessage[] = [
      chatMessage({
        id: "m1",
        content: "oldest",
        createdAt: "2026-03-28T00:01:00.000Z",
        user: { id: "u1", username: "alice", displayName: "Alice" },
      }),
      chatMessage({
        id: "m2",
        content: "older",
        createdAt: "2026-03-28T00:02:00.000Z",
        user: { id: "u2", username: "bob", displayName: "Bob" },
      }),
    ];

    persistence.setState("channel:everyone", {
      draft: "",
      replyToId: null,
      lastCursor: "m4",
      lastViewedMessageId: "m4",
    }, { schemaVersion: 1 });
    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
      messages: cached,
    }, {
      sourceKey: TRANSCRIPT_SOURCE,
      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
    });

    controller.attachPersistence(persistence);

    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
    apiClient.getMessages = async (channelId, opts) => {
      calls.push({ channelId, opts });
      return opts?.before === "m3" ? older : [];
    };

    await controller.loadOlderMessages();

    expect(calls).toEqual([{
      channelId: "everyone",
      opts: { limit: 50, before: "m3" },
    }]);
    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2", "m3", "m4"]);
    expect(controller.getSnapshot().hasOlderMessages).toBe(false);
    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
      lastCursor: "m4",
    });
  });
});