import { test, expect, type Page } from '@playwright/test';
import { loginViaAPI, CONFIG, navigateTo } from './helpers';

/**
 * CHAT DEEP — Behavioural E2E tests for the chat feature.
 *
 * These tests are written BECAUSE Chat has historically been broken.
 * They make REAL assertions about the state of the app and will FAIL
 * when the feature is broken — that is the whole point.
 *
 * Components tested (source of truth):
 *   - apps/web/src/features/chat/pages/ChatPage.tsx
 *   - apps/web/src/features/chat/components/ChatSidebar.tsx
 *   - apps/web/src/features/chat/components/ChatRoom.tsx
 *   - apps/web/src/features/chat/components/ChatInput.tsx
 *   - apps/web/src/features/chat/components/ChatMessage.tsx
 *   - apps/web/src/features/chat/hooks/useChat.ts
 *   - apps/web/src/features/chat/store/chatStore.ts
 *
 * Selectors derived from the above code:
 *   - Message input: [aria-label="Type a message"]  (placeholder "Broadcast message...")
 *   - Send button:   [aria-label="Send message"]
 *   - Attach file:   [aria-label="Attach file"]
 *   - Emoji button:  [aria-label="Add emoji"] | [aria-label="Close emoji picker"]
 *   - Voice button:  [aria-label="Voice message"]
 *   - Room name input (dialog): #room-name
 *   - Channels list heading: "Active Channels"
 *   - Connection dot: w-2 h-2 rounded-full (bg-success when connected, bg-destructive otherwise)
 *   - Empty state placeholder: "No conversation selected" | "Pick a channel from the sidebar"
 *   - Empty message state: "No messages yet" / "Send the first message"
 *
 * Routes: /chat (protected, redirects to /login when unauthenticated).
 */

const CHAT_URL = `${CONFIG.baseURL}/chat`;

// --- Small helpers scoped to this file --------------------------------------

/** Wait for the ChatPage to mount and either be connected or show a state. */
async function waitForChatPageReady(page: Page): Promise<void> {
  // The page root renders either:
  //  - "ESTABLISHING UPLINK..." while loading
  //  - The main chat layout with "Active Channels" heading
  //  - The "Access Restricted" card
  //  - The "Connection Terminated" error card
  // We accept any of those as "ready" (mount complete), but prefer the main layout.
  await expect(
    page.locator(
      'h2:has-text("Active Channels"), h2:has-text("Access Restricted"), h2:has-text("Connection Terminated"), p:has-text("ESTABLISHING UPLINK")',
    ).first(),
  ).toBeVisible({ timeout: CONFIG.timeouts.navigation });
}

/** Get the first conversation row from the sidebar (buttons rendered by ConversationItem).
 *
 * v1.0.7-rc1-day2: targeted by data-testid="chat-conversation-item"
 * (added on ConversationItem). The prior locator
 * `button[type="button"]` inside the sidebar also matched the
 * "New Channel" CTA button at the sidebar footer — producing the
 * 22-failure cascade where `selectFirstConversation` would click
 * the CTA, open CreateRoomDialog, and the test would fail at the
 * subsequent `expect(input).toBeEnabled()` because the click never
 * set currentConversationId. */
function firstConversationRow(page: Page) {
  return page.getByTestId('chat-conversation-item').first();
}

/** Get the connection status indicator (dot next to "CHANNELS" header). */
function connectionDot(page: Page) {
  // In ChatPage.tsx the status dot is a sibling of the "CHANNELS" label
  // and has class bg-success (connected) or bg-destructive (not).
  return page
    .locator('div.p-4.border-b.border-white\\/5.flex.items-center.justify-between')
    .filter({ hasText: /channels/i })
    .locator('div.w-2.h-2.rounded-full')
    .first();
}

/** Get the message input (only visible when a conversation is selected). */
function messageInput(page: Page) {
  return page.getByLabel('Type a message');
}

/** Get the send button. */
function sendButton(page: Page) {
  return page.getByRole('button', { name: 'Send message' });
}

/** Wait until at least one conversation is rendered in the sidebar (or timeout). */
async function waitForConversationOrEmpty(
  page: Page,
  timeout = 8_000,
): Promise<'has-conversations' | 'empty' | 'unknown'> {
  // v1.0.7-rc1-day2: conversation rows targeted by testid instead of
  // the sidebar-region + button[type="button"] heuristic, which
  // matched the "New Channel" CTA alongside real conversations.
  const firstRow = page.getByTestId('chat-conversation-item').first();
  const emptyBanner = page.locator('text=/No conversations yet/i').first();

  try {
    await Promise.race([
      firstRow.waitFor({ state: 'visible', timeout }),
      emptyBanner.waitFor({ state: 'visible', timeout }),
    ]);
  } catch {
    return 'unknown';
  }

  if (await firstRow.isVisible().catch(() => false)) return 'has-conversations';
  if (await emptyBanner.isVisible().catch(() => false)) return 'empty';
  return 'unknown';
}

/** Select the first available conversation and wait for the input to appear. */
async function selectFirstConversation(page: Page): Promise<boolean> {
  const state = await waitForConversationOrEmpty(page);
  if (state !== 'has-conversations') return false;

  await firstConversationRow(page).click();

  // When a conversation is selected, the ChatInput becomes enabled and visible.
  // The input is rendered unconditionally, but disabled={!currentConversationId}.
  await expect(messageInput(page)).toBeVisible({ timeout: CONFIG.timeouts.action });
  await expect(messageInput(page)).toBeEnabled({ timeout: CONFIG.timeouts.action });
  return true;
}

/** Create a brand-new channel via the sidebar dialog. Returns the name. */
async function createRoom(page: Page): Promise<string> {
  const name = `e2e-deep-${Date.now()}`;
  // v1.0.7-rc1-day2: target the sidebar CTA by testid (prior regex
  // was brittle and collided with the conversation-row locator).
  await page.getByTestId('chat-new-channel-cta').click();

  const nameInput = page.locator('#room-name');
  await expect(nameInput).toBeVisible({ timeout: CONFIG.timeouts.action });
  await nameInput.fill(name);

  await page.getByRole('button', { name: /^create room$/i }).click();

  // Dialog closes and the newly created conversation becomes current.
  await expect(nameInput).toBeHidden({ timeout: CONFIG.timeouts.action });

  // Input must be enabled (room was set as current conversation).
  await expect(messageInput(page)).toBeEnabled({ timeout: CONFIG.timeouts.action });

  return name;
}

/** Count how many chat bubble wrappers are rendered in the current room. */
async function countMessages(page: Page): Promise<number> {
  // ChatRoom renders each message inside a div id="message-{id}".
  return page.locator('[id^="message-"]').count();
}

// =============================================================================
// Test suite
// =============================================================================

test.describe('CHAT DEEP — /chat @critical', () => {
  // --- Navigation & loading ------------------------------------------------

  test.describe('Navigation & loading', () => {
    test('unauthenticated user is redirected to /login', async ({ page }) => {
      // Explicitly clear any auth state and visit /chat.
      await page.context().clearCookies();
      await page.goto(CHAT_URL, { waitUntil: 'domcontentloaded' });

      // Wait for redirect.
      await page.waitForURL(/\/login/, { timeout: CONFIG.timeouts.navigation });
      expect(page.url()).toContain('/login');

      // Login form must be visible.
      await expect(page.locator('input[type="email"]')).toBeVisible();
    });

    test('authenticated listener can load /chat without 5xx errors', async ({ page }) => {
      const errors: string[] = [];
      page.on('response', (r) => {
        if (r.status() >= 500 && r.url().includes('/api/')) {
          errors.push(`${r.status()} ${r.url()}`);
        }
      });

      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);

      expect(page.url()).toContain('/chat');
      expect(errors, `5xx backend errors during /chat load:\n${errors.join('\n')}`).toEqual([]);
    });

    test('chat page renders the sidebar "Active Channels" header', async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);

      // The sidebar heading ("Active Channels") MUST be visible. If Chat hangs on
      // "ESTABLISHING UPLINK", this assertion will fail — which is exactly what we want.
      await expect(page.locator('h2:has-text("Active Channels")')).toBeVisible({
        timeout: CONFIG.timeouts.navigation,
      });
    });

    test('chat page renders the main content area (message stream container)', async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);

      // When no conversation is selected, ChatRoom shows the "No conversation selected" placeholder.
      // When one IS selected, the message input appears. Either state proves the main area mounted.
      const placeholder = page.locator('text=/No conversation selected/i').first();
      const input = messageInput(page);

      await expect(placeholder.or(input).first()).toBeVisible({
        timeout: CONFIG.timeouts.navigation,
      });
    });

    test('chat page does not show debug text ([object Object], NaN, etc.)', async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);

      const body = (await page.textContent('body')) ?? '';
      expect(body).not.toContain('[object Object]');
      expect(body).not.toMatch(/500|Internal Server Error/i);
      // Allow a small number of "undefined" (emoji picker / feature flags) but not runaway noise.
      const undefinedCount = (body.match(/\bundefined\b/g) ?? []).length;
      expect(undefinedCount, 'Too many "undefined" tokens in body').toBeLessThanOrEqual(2);
    });
  });

  // --- Channel / conversation selection ------------------------------------

  test.describe('Channel selection', () => {
    test.beforeEach(async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);
    });

    test('clicking a conversation selects it and enables the message input', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      test.skip(!selected, 'No conversations available for user — data-dependent');

      // The disabled attribute is controlled by the store's currentConversationId.
      // If clicking didn't set it, the input stays disabled — the test fails.
      await expect(messageInput(page)).toBeEnabled();
      const placeholder = await messageInput(page).getAttribute('placeholder');
      expect(placeholder).toMatch(/Broadcast message/i);
    });

    test('selected conversation row is visually highlighted (isSelected state)', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      test.skip(!selected, 'No conversations available for user');

      const active = page
        .locator('button[type="button"][class*="bg-primary/10"]')
        .first()
        .or(page.locator('button[type="button"]').filter({ has: page.locator('.bg-primary') }).first());

      await expect(active).toBeVisible({ timeout: CONFIG.timeouts.action });
    });

    // v1.0.7-rc1-day2 (task #61 / v107-e2e-09): DOM-detach race when
    // clicking the second conversation row — the ConversationItem
    // re-renders during the click. Need explicit state transition
    // waits or animation-settled polling before the second click.
    // eslint-disable-next-line playwright/no-skipped-test
    test.skip('switching conversations changes the currently enabled input context', async ({ page }) => {
      const state = await waitForConversationOrEmpty(page);
      test.skip(state !== 'has-conversations', 'Data-dependent: need conversations');

      const rows = page
        .locator('div.flex.flex-col.h-full')
        .filter({ has: page.locator('h2:has-text("Active Channels")') })
        .locator('button[type="button"]')
        .filter({ hasText: /.+/ });

      const n = await rows.count();
      test.skip(n < 2, 'Data-dependent: need at least 2 conversations to switch');

      await rows.nth(0).click();
      await expect(messageInput(page)).toBeEnabled({ timeout: CONFIG.timeouts.action });

      // Type something, then switch. The reply-state should clear per chatStore.setCurrentConversation.
      await messageInput(page).fill('draft-message');
      await rows.nth(1).click();
      await expect(messageInput(page)).toBeEnabled({ timeout: CONFIG.timeouts.action });

      // Input value is local React state — NOT required to persist. We only assert the
      // second conversation is now highlighted as selected.
      const active = page.locator('button[type="button"][class*="bg-primary/10"]').first();
      await expect(active).toBeVisible({ timeout: CONFIG.timeouts.action });
    });

    test('selecting a conversation fetches history via GET /conversations/{id}/history', async ({ page }) => {
      const historyRequests: string[] = [];
      page.on('request', (req) => {
        const url = req.url();
        if (/\/conversations\/[^/]+\/history/.test(url) && req.method() === 'GET') {
          historyRequests.push(url);
        }
      });

      const selected = await selectFirstConversation(page);
      test.skip(!selected, 'Data-dependent: no conversations available');

      // Give the fetch a moment to fire.
      await page.waitForTimeout(1_500);

      expect(
        historyRequests.length,
        `Expected a GET /conversations/{id}/history call. Got: ${JSON.stringify(historyRequests)}`,
      ).toBeGreaterThanOrEqual(1);
    });

    test('initial load shows either conversations or the empty-state banner (never a crash)', async ({ page }) => {
      const state = await waitForConversationOrEmpty(page, 10_000);
      expect(state).not.toBe('unknown');
    });
  });

  // --- Sending messages ----------------------------------------------------

  test.describe('Sending messages', () => {
    test.beforeEach(async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);
    });

    test('the message input accepts typed text', async ({ page }) => {
      // Ensure a room is current. Create one if needed (this guarantees we can type).
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const input = messageInput(page);
      await input.fill('hello world');
      await expect(input).toHaveValue('hello world');
    });

    test('Send button is disabled when the input is empty', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      await expect(messageInput(page)).toHaveValue('');
      await expect(sendButton(page)).toBeDisabled();
    });

    test('Send button becomes enabled once text is typed', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      await expect(sendButton(page)).toBeDisabled();
      await messageInput(page).fill('non empty');
      await expect(sendButton(page)).toBeEnabled();
    });

    test('whitespace-only message does NOT enable the Send button', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      await messageInput(page).fill('   \t  \n  ');
      // ChatInput.handleSubmit uses message.trim() and the Send button is disabled on !message.trim().
      await expect(sendButton(page)).toBeDisabled();
    });

    test('pressing Enter submits the form and clears the input', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const input = messageInput(page);
      const marker = `enter-submit-${Date.now()}`;
      await input.fill(marker);
      await input.press('Enter');

      // After handleSubmit(), React clears the local message state to ''.
      // If form submission is broken, the input keeps its value — the test fails.
      await expect(input).toHaveValue('', { timeout: CONFIG.timeouts.action });
    });

    test('clicking Send submits the form and clears the input', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const input = messageInput(page);
      const marker = `send-click-${Date.now()}`;
      await input.fill(marker);
      await sendButton(page).click();

      await expect(input).toHaveValue('', { timeout: CONFIG.timeouts.action });
    });

    test('sent message appears in the room feed after submit', async ({ page }) => {
      // Use a brand-new room we own so the message is guaranteed to be authored by us
      // and to render locally (addMessage() in useChat onmessage handler).
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      // Wait for WebSocket to be connected — otherwise the message is only queued.
      const statusDot = connectionDot(page);
      await expect(statusDot).toBeVisible({ timeout: CONFIG.timeouts.action });

      // Need the dot to be green (bg-success). If WS never connects, skip: it means
      // the WS backend is not running, not a behavioural failure of the UI itself.
      const isConnected = await page
        .locator('div.w-2.h-2.rounded-full.bg-success')
        .first()
        .isVisible({ timeout: 8_000 })
        .catch(() => false);

      test.skip(!isConnected, 'WebSocket not connected — stream/chat server likely down');

      const marker = `sent-visible-${Date.now()}`;
      await messageInput(page).fill(marker);
      await sendButton(page).click();

      // The marker must show up in a message bubble.
      await expect(page.locator(`text=${marker}`).first()).toBeVisible({
        timeout: CONFIG.timeouts.navigation,
      });
    });

    test('each rendered message shows the author name and a timestamp', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      test.skip(!selected, 'No conversation available to check historical messages');

      // Wait for history to render.
      await page.waitForTimeout(2_000);

      const messageCount = await countMessages(page);
      test.skip(messageCount === 0, 'Conversation has no history');

      // ChatMessage renders the sender label ("You" or username) AND a time like "HH:MM".
      // Look at the first rendered message.
      const firstMsg = page.locator('[id^="message-"]').first();
      await expect(firstMsg).toBeVisible();

      // Timestamp pattern (toLocaleTimeString with 2-digit hour/minute).
      const text = (await firstMsg.textContent()) ?? '';
      expect(text, 'message bubble should contain HH:MM timestamp').toMatch(/\d{1,2}[:h]\d{2}/);
      // Author label is uppercased and either "YOU" or the username.
      expect(text.length).toBeGreaterThan(0);
    });

    test('long messages (>1000 chars) are accepted by the input without truncation', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const longText = 'a'.repeat(1200);
      const input = messageInput(page);
      await input.fill(longText);

      // input is a plain <input type="text"> with no maxLength — it must hold the full string.
      const value = await input.inputValue();
      expect(value.length).toBe(1200);
      // Send button is enabled.
      await expect(sendButton(page)).toBeEnabled();
    });

    test('special characters (<script>, emoji, unicode) never execute as HTML', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const xss = `<script>window.__xss_fired = true</script>`;
      const input = messageInput(page);
      await input.fill(`${xss} éàü 🎵 中文`);
      await sendButton(page).click();

      // Whether the message actually sends over WS or not, the text must NEVER
      // become executable script. We check a global flag that would be set by the injected script.
      const xssFired = await page.evaluate(
        () => (window as unknown as { __xss_fired?: boolean }).__xss_fired === true,
      );
      expect(xssFired, 'XSS payload was executed — message rendering is unsafe!').toBe(false);

      // The <script> tag should not exist in the DOM as an actual element.
      const scriptInDom = await page
        .locator('[id^="message-"] script')
        .count()
        .catch(() => 0);
      expect(scriptInDom).toBe(0);
    });

    test('submitting while disconnected does not crash the UI', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      // Force-close the WebSocket connection from inside the page. useChat queues
      // messages when ws.readyState !== OPEN, so the submit should no-op gracefully.
      await page.evaluate(() => {
        // There's no direct handle to the ws; we simulate by dispatching offline.
        window.dispatchEvent(new Event('offline'));
      });

      const input = messageInput(page);
      await input.fill(`while-offline-${Date.now()}`);
      await sendButton(page).click();

      // The page must not show a crash/500.
      const body = (await page.textContent('body')) ?? '';
      expect(body).not.toMatch(/500|Internal Server Error|Unexpected error/i);
      // Input is cleared by handleSubmit (fire-and-forget).
      await expect(input).toHaveValue('', { timeout: CONFIG.timeouts.action });
    });
  });

  // --- WebSocket connection ------------------------------------------------

  test.describe('WebSocket connection', () => {
    test.beforeEach(async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);
    });

    test('a connection status dot is rendered next to the CHANNELS label', async ({ page }) => {
      // The dot is always rendered; color changes with wsStatus.
      await expect(connectionDot(page)).toBeVisible({ timeout: CONFIG.timeouts.action });

      const cls = (await connectionDot(page).getAttribute('class')) ?? '';
      expect(cls).toMatch(/bg-success|bg-destructive/);
    });

    test('WS token endpoint POST /api/v1/chat/token is called on page load', async ({ page, context }) => {
      // Fresh page to observe the call from scratch.
      const newPage = await context.newPage();
      const tokenCalls: { status: number; url: string }[] = [];
      newPage.on('response', (r) => {
        if (r.url().includes('/chat/token') && r.request().method() === 'POST') {
          tokenCalls.push({ status: r.status(), url: r.url() });
        }
      });

      await newPage.goto(CHAT_URL, { waitUntil: 'domcontentloaded' });
      await waitForChatPageReady(newPage);
      await newPage.waitForTimeout(3_000);

      expect(
        tokenCalls.length,
        `Expected at least one POST /chat/token. Got: ${JSON.stringify(tokenCalls)}`,
      ).toBeGreaterThanOrEqual(1);

      await newPage.close();
    });

    test('indicator turns green (bg-success) when WS handshake completes', async ({ page }) => {
      // This is an observational test. If WS can connect, the dot must be green within ~10s.
      // If WS is entirely down in the test env, skip.
      const green = page.locator('div.w-2.h-2.rounded-full.bg-success').first();
      const red = page.locator('div.w-2.h-2.rounded-full.bg-destructive').first();

      const settled = await Promise.race([
        green.waitFor({ state: 'visible', timeout: 10_000 }).then(() => 'green'),
        red.waitFor({ state: 'visible', timeout: 10_000 }).then(() => 'red'),
      ]).catch(() => 'none');

      test.skip(settled === 'none', 'Neither connected nor disconnected state observed');

      if (settled === 'red') {
        test.skip(true, 'WS backend unavailable in this env — cannot verify green-state transition');
      }
      expect(settled).toBe('green');
    });

    test('UI remains stable (no crash) when WS repeatedly reconnects', async ({ page }) => {
      // Navigate away and back a few times; useChat has exponential-backoff reconnection.
      for (let i = 0; i < 3; i++) {
        await navigateTo(page, '/dashboard');
        await navigateTo(page, '/chat');
        await waitForChatPageReady(page);
      }

      // After all toggles, the page should still render the sidebar heading.
      await expect(page.locator('h2:has-text("Active Channels")')).toBeVisible({
        timeout: CONFIG.timeouts.navigation,
      });
      const body = (await page.textContent('body')) ?? '';
      expect(body).not.toMatch(/500|Internal Server Error/i);
    });
  });

  // --- Message features ----------------------------------------------------

  test.describe('Message features', () => {
    test.beforeEach(async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);
    });

    test('Attach file button is present and clickable', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const attach = page.getByRole('button', { name: 'Attach file' });
      await expect(attach).toBeVisible();
      await expect(attach).toBeEnabled();

      // Clicking it triggers a hidden file input (react-dropzone). We cannot observe the
      // native picker, but we can assert that clicking does not throw/navigate.
      await attach.click();
      await page.waitForTimeout(300);
      expect(page.url()).toContain('/chat');
    });

    // v1.0.7-rc1-day2 (task #61 / v107-e2e-09): emoji picker open
    // state doesn't toggle reliably — suspected animation / portal
    // rendering race. Needs the same overlay-wait pattern test 326
    // uses for the expanded player.
    // eslint-disable-next-line playwright/no-skipped-test
    test.skip('Emoji picker toggles via the "Add emoji" button', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const openBtn = page.getByRole('button', { name: 'Add emoji' });
      await expect(openBtn).toBeVisible();
      await openBtn.click();

      // When opened, the aria-label flips to "Close emoji picker".
      const closeBtn = page.getByRole('button', { name: 'Close emoji picker' });
      await expect(closeBtn).toBeVisible({ timeout: CONFIG.timeouts.action });

      await closeBtn.click();
      await expect(openBtn).toBeVisible({ timeout: CONFIG.timeouts.action });
    });

    test('Voice message button is visible when input is empty, hidden when typing', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      // When empty, the Voice button is rendered inside the input wrapper.
      const voice = page.getByRole('button', { name: 'Voice message' });
      await expect(voice).toBeVisible({ timeout: CONFIG.timeouts.action });

      await messageInput(page).fill('now typing');
      // ChatInput hides the Voice button when message.length > 0.
      await expect(voice).toBeHidden({ timeout: CONFIG.timeouts.action });
    });

    test('new message auto-scrolls the feed to the bottom (messagesEndRef)', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      // Only run if WS is connected (new messages otherwise won't render).
      const connected = await page
        .locator('div.w-2.h-2.rounded-full.bg-success')
        .first()
        .isVisible({ timeout: 8_000 })
        .catch(() => false);
      test.skip(!connected, 'WS not connected');

      // Send a message and observe that its rendered bubble is within viewport
      // of the scroll container (scrollIntoView is called in ChatRoom).
      const marker = `auto-scroll-${Date.now()}`;
      await messageInput(page).fill(marker);
      await sendButton(page).click();

      const bubble = page.locator(`text=${marker}`).first();
      await expect(bubble).toBeVisible({ timeout: CONFIG.timeouts.navigation });
      await expect(bubble).toBeInViewport({ timeout: CONFIG.timeouts.action });
    });

    test('own messages are aligned right (ml-auto), others left (mr-auto)', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      test.skip(!selected, 'No conversation available with messages');

      // Wait for history.
      await page.waitForTimeout(2_000);
      const count = await countMessages(page);
      test.skip(count === 0, 'No messages in conversation');

      // Look at the inner wrapper of each message: ChatMessageComponent uses
      // ml-auto (mine) vs mr-auto (others) on the top-level div.
      const mine = await page.locator('[id^="message-"] .ml-auto').count();
      const theirs = await page.locator('[id^="message-"] .mr-auto').count();

      expect(
        mine + theirs,
        'Every rendered message must have either ml-auto or mr-auto alignment',
      ).toBeGreaterThan(0);
    });

    test('message stream container is scrollable (has overflow-y-auto)', async ({ page }) => {
      const selected = await selectFirstConversation(page);
      if (!selected) await createRoom(page);

      const stream = page.locator('div.flex-1.overflow-y-auto.custom-scrollbar').first();
      await expect(stream).toBeVisible();

      // Check overflow is set correctly so large history scrolls.
      const overflowY = await stream.evaluate((el) => getComputedStyle(el).overflowY);
      expect(['auto', 'scroll']).toContain(overflowY);
    });
  });

  // --- Empty-state handling ------------------------------------------------

  test.describe('Empty-state handling', () => {
    test.beforeEach(async ({ page }) => {
      await loginViaAPI(page, CONFIG.users.listener.email, CONFIG.users.listener.password);
      await navigateTo(page, '/chat');
      await waitForChatPageReady(page);
    });

    test('no conversation selected → shows the "Pick a channel" placeholder', async ({ page }) => {
      // On fresh load, currentConversationId is null, so ChatRoom renders the placeholder.
      const placeholder = page.locator('text=/No conversation selected/i').first();
      const picker = page.locator('text=/Pick a channel from the sidebar/i').first();

      // One of the two should be visible at mount (they are both inside the same Card).
      await expect(placeholder.or(picker).first()).toBeVisible({
        timeout: CONFIG.timeouts.navigation,
      });
    });

    test('newly-created empty room shows "No messages yet" welcome', async ({ page }) => {
      // Creating a room in an ephemeral test is data-dependent — skip if create fails.
      try {
        await createRoom(page);
      } catch {
        test.skip(true, 'Could not create a new room (API likely rejected the request)');
      }

      await expect(
        page
          .locator('text=/No messages yet/i')
          .or(page.locator('text=/Send the first message/i'))
          .first(),
      ).toBeVisible({ timeout: CONFIG.timeouts.navigation });
    });
  });
});