/**
 * Journey: Billing Upgrade UI Smoke
 *
 * Covers the revenue-critical billing path:
 *   /billing/plans  — Pricing page for authenticated users (upgrade CTAs visible)
 *   /billing        — Current plan management page
 *   Upgrade flow    — CRO-013 confirm dialog + checkout POST interception
 *
 * == Design notes ==
 *
 * This spec does NOT perform a real Stripe transaction. The Stripe checkout
 * POST is intercepted at the network level and fulfilled with a mock redirect
 * to a synthetic checkout URL. This validates:
 *   1. The upgrade button initiates a checkout request (route wired correctly)
 *   2. The CRO-013 confirmation dialog fires before the POST
 *   3. The browser navigates toward the checkout URL on success
 *
 * In CI the E2E user is on the free plan (no Cashier subscription seeded).
 * The pricing page therefore renders upgrade CTAs for every paid tier, which
 * is exactly the state we want to assert.
 *
 * == Background request noise ==
 * The same test-env artifacts present in other journey specs apply here:
 *   - /api/lead-score/pql-signal 401: Sanctum statefulDomains mismatch
 *   - PATCH /profile 419: timezone auto-detect CSRF timing
 * These are tracked and excluded from the "no failed requests" assertion.
 *
 * == Auth guard ==
 * Both /billing and /billing/plans redirect unauthenticated visitors to /login.
 */

import { expect, test } from '../fixtures/auth';

// Known test-env noise URLs — exclude from failed-request assertions.
const NOISE_URLS = ['/api/lead-score/pql-signal', '/profile'];

function isNoise(url: string): boolean {
  return NOISE_URLS.some((n) => url.includes(n));
}

/** Set up console-error + failed-request collectors for a page. */
function trackErrors(page: Parameters<typeof test>[1] extends { page: infer P } ? P : never) {
  const consoleErrors: string[] = [];
  const failedRequests: string[] = [];

  page.on('pageerror', (err) => {
    if (!isNoise(err.message)) consoleErrors.push(err.message);
  });
  page.on('console', (msg) => {
    if (msg.type() === 'error' && !isNoise(msg.text())) consoleErrors.push(msg.text());
  });
  page.on('response', (res) => {
    if (res.status() >= 500 && !isNoise(res.url())) {
      failedRequests.push(`${res.status()} ${res.request().method()} ${res.url()}`);
    }
  });

  return {
    assertNoErrors: () => {
      expect(consoleErrors, `Uncaught JS errors: ${consoleErrors.join('; ')}`).toHaveLength(0);
    },
    assertNoServerErrors: () => {
      expect(failedRequests, `5xx errors: ${failedRequests.join('; ')}`).toHaveLength(0);
    },
  };
}

// ---------------------------------------------------------------------------
// Suite A: /billing/plans (authenticated pricing page)
// ---------------------------------------------------------------------------

test.describe('Billing Upgrade: A — /billing/plans renders for authenticated user', () => {
  test('pricing page loads without JS errors', async ({ page }) => {
    const { assertNoErrors } = trackErrors(page);
    await page.goto('/billing/plans', { waitUntil: 'domcontentloaded' });

    await expect(page).toHaveURL(/\/billing\/plans/);
    // Page title should reference pricing
    await expect(page).toHaveTitle(/pricing|plan/i);
    assertNoErrors();
  });

  test('pricing page renders paid plan cards with upgrade CTAs', async ({ page }) => {
    await page.goto('/billing/plans', { waitUntil: 'networkidle' });

    // Free-plan user should see upgrade buttons for paid tiers (Pro / Team).
    // The button text is "Upgrade to Professional" or "Upgrade to Team" (plan name from config).
    const upgradeButtons = page.getByRole('button', { name: /upgrade to/i });
    await expect(upgradeButtons.first()).toBeVisible();

    // At least one plan card must be rendered — confirms the controller passed tiers data.
    const planCards = page.locator('[class*="card"]').filter({ hasText: /per month|\/mo/i });
    await expect(planCards.first()).toBeVisible();
  });

  test('pricing page shows no application 5xx errors', async ({ page }) => {
    const { assertNoServerErrors } = trackErrors(page);
    await page.goto('/billing/plans', { waitUntil: 'networkidle' });
    assertNoServerErrors();
  });
});

// ---------------------------------------------------------------------------
// Suite B: /billing (current plan management page)
// ---------------------------------------------------------------------------

test.describe('Billing Upgrade: B — /billing management page', () => {
  test('billing page loads without JS errors', async ({ page }) => {
    const { assertNoErrors } = trackErrors(page);
    await page.goto('/billing', { waitUntil: 'domcontentloaded' });

    await expect(page).toHaveURL(/\/billing/);
    assertNoErrors();
  });

  test('billing page renders plan details section', async ({ page }) => {
    await page.goto('/billing', { waitUntil: 'networkidle' });

    // The billing page must not be blank — it should contain plan-related copy.
    const body = await page.innerText('body');
    expect(body.trim().length, 'Billing page must not be empty').toBeGreaterThan(50);

    // The page renders a "Compare All Plans" or "View plans" link pointing to /billing/plans.
    const comparePlansLink = page
      .getByRole('link', { name: /compare.*plan|view plan/i })
      .or(page.locator('a[href*="billing/plans"]'))
      .first();
    await expect(comparePlansLink).toBeVisible();
  });
});

// ---------------------------------------------------------------------------
// Suite C: Upgrade initiation flow (CRO-013 confirm dialog + POST interception)
// ---------------------------------------------------------------------------

test.describe('Billing Upgrade: C — upgrade flow (mocked Stripe)', () => {
  test('clicking upgrade opens CRO-013 confirm dialog', async ({ page }) => {
    await page.goto('/billing/plans', { waitUntil: 'networkidle' });

    // Click the first upgrade button (any paid plan).
    const upgradeButton = page.getByRole('button', { name: /upgrade to/i }).first();
    await expect(upgradeButton).toBeVisible();
    await upgradeButton.click();

    // CRO-013: a confirmation dialog must appear BEFORE the Stripe redirect.
    // The dialog contains "Confirm and proceed to checkout" and a cancel option.
    const confirmButton = page.getByRole('button', { name: /confirm and proceed to checkout/i });
    await expect(confirmButton).toBeVisible({ timeout: 5_000 });

    // The dialog also shows a "Go back" / cancel option.
    const cancelButton = page.getByRole('button', { name: /go back/i });
    await expect(cancelButton).toBeVisible();
  });

  test('confirming checkout initiates POST to billing.subscribe', async ({ page }) => {
    // Intercept the POST /billing/subscribe and return a mock Stripe redirect.
    // This validates the full checkout POST is wired correctly without hitting live Stripe.
    const MOCK_CHECKOUT_URL = 'https://checkout.stripe.com/c/pay/test_mock_e2e_session';

    let subscribePostCaptured = false;
    await page.route('**/billing/subscribe', async (route) => {
      const request = route.request();
      if (request.method() === 'POST') {
        subscribePostCaptured = true;
        // Return a 302 redirect to our synthetic Stripe checkout URL.
        await route.fulfill({
          status: 302,
          headers: { Location: MOCK_CHECKOUT_URL },
          body: '',
        });
      } else {
        await route.continue();
      }
    });

    await page.goto('/billing/plans', { waitUntil: 'networkidle' });

    // Open the confirm dialog.
    const upgradeButton = page.getByRole('button', { name: /upgrade to/i }).first();
    await upgradeButton.click();

    // Wait for CRO-013 dialog.
    const confirmButton = page.getByRole('button', { name: /confirm and proceed to checkout/i });
    await expect(confirmButton).toBeVisible({ timeout: 5_000 });

    // Click confirm — this triggers router.post() to /billing/subscribe.
    // Await the intercepted request directly: more reliable than polling a captured flag.
    const [postRequest] = await Promise.all([
      page.waitForRequest(
        (req) => req.url().includes('/billing/subscribe') && req.method() === 'POST',
        { timeout: 8_000 },
      ),
      confirmButton.click(),
    ]);

    // The POST must have been sent to the correct endpoint.
    expect(postRequest.url()).toContain('/billing/subscribe');
    expect(subscribePostCaptured, 'route handler must have fired for the POST').toBe(true);
  });
});

// ---------------------------------------------------------------------------
// Suite D: Auth guard
// ---------------------------------------------------------------------------

test.describe('Billing Upgrade: D — auth guard', () => {
  test('billing pages redirect unauthenticated visitors to /login', async ({ browser }) => {
    const context = await browser.newContext({ storageState: { cookies: [], origins: [] } });
    const page = await context.newPage();

    for (const url of ['/billing', '/billing/plans']) {
      await page.goto(url, { waitUntil: 'domcontentloaded' });
      await expect(page, `Expected /login redirect for ${url}`).toHaveURL(/\/login/);
    }

    await context.close();
  });
});