import { expect, test } from './fixtures';
import { UNKNOWN_UUID } from './helpers/constants';
import { dateRange, dateRangeIso } from './helpers/dates';
import { uniqueName } from './helpers/entities';
import type { SeedState } from './seed/state';

/** Body shared by every report run endpoint (filters + parameters date windows). */
function runBody(seed: SeedState, type: string, parameters: Record<string, unknown> = {}) {
  return {
    websiteId: seed.website.id,
    type,
    filters: { ...dateRange(seed), timezone: 'UTC', unit: 'day' },
    parameters: { ...dateRangeIso(seed), ...parameters },
  };
}

test.describe('Saved reports', () => {
  test.describe.configure({ mode: 'serial' });

  let reportId = '';

  test.afterAll(async ({ admin }) => {
    if (reportId) {
      await admin.del(`/api/reports/${reportId}`);
    }
  });

  test('POST /api/reports creates a report', async ({ admin, seed }) => {
    const name = uniqueName('report');
    const response = await admin.post('/api/reports', {
      websiteId: seed.website.id,
      type: 'funnel',
      name,
      description: 'created by the api suite',
      parameters: { window: 60, steps: [] },
    });

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      id: expect.any(String),
      userId: seed.admin.id,
      websiteId: seed.website.id,
      type: 'funnel',
      name,
      description: 'created by the api suite',
      parameters: { window: 60, steps: [] },
    });

    reportId = response.body.id;
  });

  test('POST /api/reports validates the body', async ({ admin, seed }) => {
    const badType = await admin.post('/api/reports', {
      websiteId: seed.website.id,
      type: 'nope',
      name: 'x',
      parameters: {},
    });
    const missingParameters = await admin.post('/api/reports', {
      websiteId: seed.website.id,
      type: 'goal',
      name: 'x',
    });
    const longName = await admin.post('/api/reports', {
      websiteId: seed.website.id,
      type: 'goal',
      name: 'x'.repeat(201),
      parameters: {},
    });

    expect(badType.status).toBe(400);
    expect(missingParameters.status).toBe(400);
    expect(longName.status).toBe(400);
  });

  test('POST /api/reports requires update access to the website', async ({
    viewer,
    user,
    api,
    seed,
  }) => {
    const body = { websiteId: seed.website.id, type: 'goal', name: 'x', parameters: {} };
    const denied = await viewer.post('/api/reports', body);
    const otherOwner = await user.post('/api/reports', body);
    const anonymous = await api.post('/api/reports', body);
    const unknown = await user.post('/api/reports', { ...body, websiteId: UNKNOWN_UUID });

    expect(denied.status).toBe(401);
    expect(otherOwner.status).toBe(401);
    expect(anonymous.status).toBe(401);
    expect(unknown.status).toBe(401);
  });

  test('GET /api/reports lists reports for a website', async ({ admin, seed }) => {
    const response = await admin.get('/api/reports', { params: { websiteId: seed.website.id } });
    const byType = await admin.get('/api/reports', {
      params: { websiteId: seed.website.id, type: 'funnel' },
    });
    const otherType = await admin.get('/api/reports', {
      params: { websiteId: seed.website.id, type: 'retention' },
    });

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      data: expect.any(Array),
      count: expect.any(Number),
      page: 1,
      pageSize: expect.any(Number),
    });
    expect(response.body.data.map((r: any) => r.id)).toContain(reportId);
    expect(byType.status).toBe(200);
    expect(byType.body.data.map((r: any) => r.id)).toContain(reportId);
    expect(byType.body.data.every((r: any) => r.type === 'funnel')).toBe(true);
    expect(otherType.body.data.map((r: any) => r.id)).not.toContain(reportId);
  });

  test('GET /api/reports validates websiteId and checks access', async ({
    admin,
    viewer,
    share,
    seed,
  }) => {
    const missing = await admin.get('/api/reports');
    const invalid = await admin.get('/api/reports', { params: { websiteId: 'nope' } });
    const badType = await admin.get('/api/reports', {
      params: { websiteId: seed.website.id, type: 'nope' },
    });
    const denied = await viewer.get('/api/reports', { params: { websiteId: seed.website.id } });
    const shared = await (await share()).get('/api/reports', {
      params: { websiteId: seed.website.id },
    });
    const sharedByType = await (await share()).get('/api/reports', {
      params: { websiteId: seed.website.id, type: 'funnel' },
    });

    expect(missing.status).toBe(400);
    expect(invalid.status).toBe(400);
    expect(badType.status).toBe(400);
    expect(denied.status).toBe(401);
    // Listing every type requires a real user; a share token can only list a single section.
    expect(shared.status).toBe(401);
    expect(sharedByType.status).toBe(200);
    expect(sharedByType.body.data.map((r: any) => r.id)).toContain(reportId);
  });

  test('GET /api/websites/{websiteId}/reports lists the website reports', async ({
    admin,
    viewer,
    seed,
  }) => {
    const response = await admin.get(`/api/websites/${seed.website.id}/reports`);
    const byType = await admin.get(`/api/websites/${seed.website.id}/reports`, {
      params: { type: 'retention' },
    });
    const badType = await admin.get(`/api/websites/${seed.website.id}/reports`, {
      params: { type: 'nope' },
    });
    const denied = await viewer.get(`/api/websites/${seed.website.id}/reports`);

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({ data: expect.any(Array), count: expect.any(Number) });
    expect(response.body.data.map((r: any) => r.id)).toContain(reportId);
    expect(byType.status).toBe(200);
    expect(byType.body.data.map((r: any) => r.id)).not.toContain(reportId);
    expect(badType.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('GET /api/reports/{reportId} returns a report', async ({ admin, viewer, api }) => {
    const response = await admin.get(`/api/reports/${reportId}`);
    const denied = await viewer.get(`/api/reports/${reportId}`);
    const anonymous = await api.get(`/api/reports/${reportId}`);
    const unknown = await admin.get(`/api/reports/${UNKNOWN_UUID}`);

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      id: reportId,
      type: 'funnel',
      parameters: { window: 60 },
      createdAt: expect.any(String),
    });
    expect(denied.status).toBe(401);
    expect(anonymous.status).toBe(401);
    expect(unknown.status).toBe(404);
  });

  test('POST /api/reports/{reportId} updates a report', async ({ admin, viewer, seed }) => {
    const name = uniqueName('renamed');
    const body = {
      websiteId: seed.website.id,
      type: 'funnel',
      name,
      description: 'updated',
      parameters: { window: 30, steps: [{ type: 'path', value: '/' }] },
    };
    const response = await admin.post(`/api/reports/${reportId}`, body);
    const invalid = await admin.post(`/api/reports/${reportId}`, { name });
    const denied = await viewer.post(`/api/reports/${reportId}`, body);
    const unknown = await admin.post(`/api/reports/${UNKNOWN_UUID}`, body);

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      id: reportId,
      name,
      description: 'updated',
      parameters: { window: 30 },
    });
    expect(invalid.status).toBe(400);
    expect(denied.status).toBe(401);
    expect(unknown.status).toBe(404);
  });

  test('DELETE /api/reports/{reportId} deletes a report', async ({ admin, viewer }) => {
    const denied = await viewer.del(`/api/reports/${reportId}`);
    const response = await admin.del(`/api/reports/${reportId}`);
    const gone = await admin.get(`/api/reports/${reportId}`);
    const unknown = await admin.del(`/api/reports/${UNKNOWN_UUID}`);

    expect(denied.status).toBe(401);
    expect(response.status).toBe(200);
    expect(response.body).toEqual({ ok: true });
    expect(gone.status).toBe(404);
    expect(unknown.status).toBe(404);

    reportId = '';
  });
});

test.describe('Report runs', () => {
  test('POST /api/reports/attribution returns attribution by channel', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post(
      '/api/reports/attribution',
      runBody(seed, 'attribution', { model: 'first-click', type: 'path', step: '/pricing' }),
    );
    const lastClick = await admin.post(
      '/api/reports/attribution',
      runBody(seed, 'attribution', { model: 'last-click', type: 'event', step: 'signup' }),
    );
    const shared = await (await share()).post(
      '/api/reports/attribution',
      runBody(seed, 'attribution', { model: 'first-click', type: 'path', step: '/pricing' }),
    );
    const invalid = await admin.post(
      '/api/reports/attribution',
      runBody(seed, 'attribution', { model: 'nope', type: 'path', step: '/' }),
    );
    const denied = await viewer.post(
      '/api/reports/attribution',
      runBody(seed, 'attribution', { model: 'first-click', type: 'path', step: '/' }),
    );

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      referrer: expect.any(Array),
      paidAds: expect.any(Array),
      utm_source: expect.any(Array),
      utm_medium: expect.any(Array),
      utm_campaign: expect.any(Array),
      utm_content: expect.any(Array),
      utm_term: expect.any(Array),
      total: {
        pageviews: expect.any(Number),
        visitors: expect.any(Number),
        visits: expect.any(Number),
      },
    });
    expect(response.body.total.visitors).toBeGreaterThan(0);
    expect(lastClick.status).toBe(200);
    expect(shared.status).toBe(200);
    expect(invalid.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/breakdown returns rows grouped by field', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post(
      '/api/reports/breakdown',
      runBody(seed, 'breakdown', { fields: ['path'] }),
    );
    const multi = await admin.post(
      '/api/reports/breakdown',
      runBody(seed, 'breakdown', { fields: ['browser', 'os'] }),
    );
    const shared = await (await share()).post(
      '/api/reports/breakdown',
      runBody(seed, 'breakdown', { fields: ['path'] }),
    );
    const invalid = await admin.post(
      '/api/reports/breakdown',
      runBody(seed, 'breakdown', { fields: ['nope'] }),
    );
    const denied = await viewer.post(
      '/api/reports/breakdown',
      runBody(seed, 'breakdown', { fields: ['path'] }),
    );

    expect(response.status).toBe(200);
    expect(Array.isArray(response.body)).toBe(true);
    // Aggregates come back as numeric strings on Postgres and numbers on ClickHouse.
    expect(response.body[0]).toMatchObject({
      path: expect.any(String),
      views: expect.anything(),
      visitors: expect.anything(),
      visits: expect.anything(),
      bounces: expect.anything(),
      totaltime: expect.anything(),
    });
    expect(Number(response.body[0].views)).toBeGreaterThan(0);
    expect(response.body.map((r: any) => r.path)).toContain('/pricing');
    expect(multi.status).toBe(200);
    expect(multi.body[0]).toMatchObject({ browser: expect.any(String), os: expect.any(String) });
    expect(shared.status).toBe(200);
    expect(invalid.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/funnel returns conversion per step', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const parameters = {
      window: 60,
      steps: [
        { type: 'path', value: '/' },
        { type: 'path', value: '/pricing' },
        { type: 'path', value: '/blog/hello-world' },
      ],
    };
    const response = await admin.post('/api/reports/funnel', runBody(seed, 'funnel', parameters));
    const shared = await (await share()).post(
      '/api/reports/funnel',
      runBody(seed, 'funnel', parameters),
    );
    const tooFewSteps = await admin.post(
      '/api/reports/funnel',
      runBody(seed, 'funnel', { window: 60, steps: [{ type: 'path', value: '/' }] }),
    );
    const denied = await viewer.post('/api/reports/funnel', runBody(seed, 'funnel', parameters));

    expect(response.status).toBe(200);
    expect(response.body).toHaveLength(3);
    expect(response.body[0]).toMatchObject({
      type: 'path',
      value: '/',
      visitors: expect.any(Number),
      previous: expect.any(Number),
      dropped: expect.any(Number),
      remaining: expect.any(Number),
    });
    expect(response.body[1]).toMatchObject({ value: '/pricing', dropoff: expect.any(Number) });
    expect(response.body[0].visitors).toBeGreaterThan(0);
    expect(response.body[1].visitors).toBeGreaterThan(0);
    expect(response.body[1].visitors).toBeLessThanOrEqual(response.body[0].visitors);
    expect(response.body[2].visitors).toBeLessThanOrEqual(response.body[1].visitors);
    expect(shared.status).toBe(200);
    expect(tooFewSteps.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/goal returns goal completion', async ({ admin, share, viewer, seed }) => {
    const response = await admin.post(
      '/api/reports/goal',
      runBody(seed, 'goal', { type: 'path', value: '/' }),
    );
    const event = await admin.post(
      '/api/reports/goal',
      runBody(seed, 'goal', { type: 'event', value: 'signup' }),
    );
    const shared = await (await share()).post(
      '/api/reports/goal',
      runBody(seed, 'goal', { type: 'path', value: '/' }),
    );
    const invalid = await admin.post('/api/reports/goal', runBody(seed, 'goal', { type: 'path' }));
    const denied = await viewer.post(
      '/api/reports/goal',
      runBody(seed, 'goal', { type: 'path', value: '/' }),
    );

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({ num: expect.any(Number), total: expect.any(Number) });
    expect(response.body.num).toBeGreaterThan(0);
    expect(response.body.total).toBeGreaterThanOrEqual(response.body.num);
    expect(event.status).toBe(200);
    expect(event.body.num).toBeGreaterThan(0);
    expect(shared.status).toBe(200);
    expect(invalid.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/heatmap returns click and scroll data', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post(
      '/api/reports/heatmap',
      runBody(seed, 'heatmap', { urlPath: '/', mode: 'click' }),
    );
    const scroll = await admin.post(
      '/api/reports/heatmap',
      runBody(seed, 'heatmap', { urlPath: '/', mode: 'scroll' }),
    );
    const invalid = await admin.post(
      '/api/reports/heatmap',
      runBody(seed, 'heatmap', { urlPath: '/', mode: 'nope' }),
    );
    const shared = await (await share()).post(
      '/api/reports/heatmap',
      runBody(seed, 'heatmap', { urlPath: '/' }),
    );
    const denied = await viewer.post(
      '/api/reports/heatmap',
      runBody(seed, 'heatmap', { urlPath: '/' }),
    );

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      mode: 'click',
      pages: expect.any(Array),
      points: expect.any(Array),
      scroll: { buckets: expect.any(Array), totalSessions: expect.any(Number) },
    });
    expect(response.body.pages.map((p: any) => p.urlPath ?? p.url ?? p.path)).toContain('/');
    expect(scroll.status).toBe(200);
    expect(scroll.body.mode).toBe('scroll');
    expect(invalid.status).toBe(400);
    // Heatmaps require a logged in user; share tokens are rejected.
    expect(shared.status).toBe(401);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/journey returns paths between steps', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post(
      '/api/reports/journey',
      runBody(seed, 'journey', { steps: 3 }),
    );
    const anchored = await admin.post(
      '/api/reports/journey',
      runBody(seed, 'journey', { steps: 3, startStep: '/' }),
    );
    const shared = await (await share()).post(
      '/api/reports/journey',
      runBody(seed, 'journey', { steps: 3 }),
    );
    const invalid = await admin.post(
      '/api/reports/journey',
      runBody(seed, 'journey', { steps: 1 }),
    );
    const denied = await viewer.post(
      '/api/reports/journey',
      runBody(seed, 'journey', { steps: 3 }),
    );

    expect(response.status).toBe(200);
    expect(Array.isArray(response.body)).toBe(true);
    expect(response.body.length).toBeGreaterThan(0);
    expect(response.body[0]).toMatchObject({ items: expect.any(Array), count: expect.any(Number) });
    expect(response.body[0].items.length).toBeGreaterThan(0);
    expect(anchored.status).toBe(200);
    expect(anchored.body.length).toBeGreaterThan(0);
    expect(anchored.body.every((r: any) => r.items[0] === '/')).toBe(true);
    expect(shared.status).toBe(200);
    expect(invalid.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/performance returns web vitals', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post(
      '/api/reports/performance',
      runBody(seed, 'performance', { unit: 'day', timezone: 'UTC' }),
    );
    const metric = await admin.post(
      '/api/reports/performance',
      runBody(seed, 'performance', { metric: 'lcp' }),
    );
    const shared = await (await share()).post(
      '/api/reports/performance',
      runBody(seed, 'performance'),
    );
    const invalid = await admin.post(
      '/api/reports/performance',
      runBody(seed, 'performance', { metric: 'nope' }),
    );
    const denied = await viewer.post('/api/reports/performance', runBody(seed, 'performance'));

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      chart: expect.any(Array),
      summary: { count: expect.any(Number) },
      pages: expect.any(Array),
      pageTitles: expect.any(Array),
      devices: expect.any(Array),
      browsers: expect.any(Array),
    });
    expect(response.body.summary.count).toBeGreaterThan(0);
    expect(metric.status).toBe(200);
    expect(shared.status).toBe(200);
    expect(invalid.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/retention returns cohorts by day', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post(
      '/api/reports/retention',
      runBody(seed, 'retention', { timezone: 'UTC' }),
    );
    const shared = await (await share()).post('/api/reports/retention', runBody(seed, 'retention'));
    const denied = await viewer.post('/api/reports/retention', runBody(seed, 'retention'));

    expect(response.status).toBe(200);
    expect(Array.isArray(response.body)).toBe(true);
    expect(response.body.length).toBeGreaterThan(0);
    expect(response.body[0]).toMatchObject({
      date: expect.any(String),
      day: expect.any(Number),
      visitors: expect.any(Number),
      returnVisitors: expect.any(Number),
      percentage: expect.any(Number),
    });
    expect(shared.status).toBe(200);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/revenue returns revenue totals', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post(
      '/api/reports/revenue',
      runBody(seed, 'revenue', { currency: seed.data.currency }),
    );
    const shared = await (await share()).post(
      '/api/reports/revenue',
      runBody(seed, 'revenue', { currency: seed.data.currency }),
    );
    const missingCurrency = await admin.post('/api/reports/revenue', runBody(seed, 'revenue'));
    const denied = await viewer.post(
      '/api/reports/revenue',
      runBody(seed, 'revenue', { currency: seed.data.currency }),
    );

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      chart: expect.any(Array),
      total: {
        sum: expect.anything(),
        count: expect.anything(),
        average: expect.anything(),
        unique_count: expect.anything(),
      },
      country: expect.any(Array),
      region: expect.any(Array),
      referrer: expect.any(Array),
      channel: expect.any(Array),
    });
    expect(Number(response.body.total.sum)).toBeGreaterThan(0);
    expect(Number(response.body.total.count)).toBeGreaterThan(0);
    expect(shared.status).toBe(200);
    expect(missingCurrency.status).toBe(400);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/utm returns views per utm parameter', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.post('/api/reports/utm', runBody(seed, 'utm'));
    const shared = await (await share()).post('/api/reports/utm', runBody(seed, 'utm'));
    const denied = await viewer.post('/api/reports/utm', runBody(seed, 'utm'));

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      utm_source: expect.any(Array),
      utm_medium: expect.any(Array),
      utm_campaign: expect.any(Array),
      utm_term: expect.any(Array),
      utm_content: expect.any(Array),
    });
    expect(response.body.utm_source[0]).toMatchObject({
      utm: expect.any(String),
      views: expect.any(Number),
    });
    expect(response.body.utm_source.map((r: any) => r.utm)).toContain('newsletter');
    expect(response.body.utm_medium.map((r: any) => r.utm)).toContain('email');
    expect(response.body.utm_campaign.map((r: any) => r.utm)).toContain('launch');
    expect(shared.status).toBe(200);
    expect(denied.status).toBe(401);
  });

  test('POST /api/reports/{type} validates the discriminator and envelope', async ({
    admin,
    user,
    api,
    seed,
  }) => {
    const wrongType = await admin.post('/api/reports/utm', runBody(seed, 'goal'));
    const missingFilters = await admin.post('/api/reports/utm', {
      websiteId: seed.website.id,
      type: 'utm',
      parameters: dateRangeIso(seed),
    });
    const missingParameters = await admin.post('/api/reports/utm', {
      websiteId: seed.website.id,
      type: 'utm',
      filters: dateRange(seed),
    });
    const anonymous = await api.post('/api/reports/utm', runBody(seed, 'utm'));
    const unknownWebsite = await user.post('/api/reports/utm', {
      ...runBody(seed, 'utm'),
      websiteId: UNKNOWN_UUID,
    });

    expect(wrongType.status).toBe(400);
    expect(missingFilters.status).toBe(400);
    expect(missingParameters.status).toBe(400);
    expect(anonymous.status).toBe(401);
    expect(unknownWebsite.status).toBe(401);
  });
});