// What an external collector needs from `analytics snapshot` and `reports`: a store-only config (apple.appId without a
// bundle id, no play.reportsBucket), --json on stdout, App Usage and Play install stock numbers per day, and per-day
// sales JSON for a day range of both stores. Fixtures are made-up report files; nothing reaches the network.
import { afterEach, describe, expect, test } from 'bun:test';
import { createHash } from 'node:crypto';
import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { deflateRawSync } from 'node:zlib';
import { run as analytics } from '../cli/analytics';
import { appleDaily, appleTotals, mergeAppleUsage, parseReport, playDaily, playTotals } from '../cli/lib/analytics';
import { type ShipConfig, validateConfig } from '../cli/lib/config';
import { playReportsBucket, profileEnv } from '../cli/lib/credentials';
import { dateRange, parsePlayCsv, parseTsv, playSalesTotals, rangeReport, reportRange, summarizeAppleSales, summarizePlaySalesByDay, totalsByCurrency } from '../cli/lib/reports';
import { run as reports } from '../cli/reports';
import { ascEnv, BASE, capture, jsonOut, mockFetch, playEnv, project, restore } from './helpers/store-mock';

const BUCKET = 'pubsite_prod_rev_01234567890123456789';
afterEach(() => { restore(); delete process.env.PLAY_REPORTS_BUCKET; delete process.env.STOREBOUND_CREDENTIALS_DIR; delete process.env.STOREBOUND_PROFILE; });

const iso = (offset: number) => new Date(Date.now() + offset * 86_400_000).toISOString().slice(0, 10);
type Req = { path: string };

function zip(files: Record<string, string>): Uint8Array {
  const parts: Uint8Array[] = [], central: Uint8Array[] = [];
  let off = 0;
  for (const [name, text] of Object.entries(files)) {
    const raw = new TextEncoder().encode(text), data = deflateRawSync(raw), n = new TextEncoder().encode(name);
    const h = new DataView(new ArrayBuffer(30));
    h.setUint32(0, 0x04034b50, true); h.setUint16(8, 8, true); h.setUint32(18, data.length, true); h.setUint32(22, raw.length, true); h.setUint16(26, n.length, true);
    const c = new DataView(new ArrayBuffer(46));
    c.setUint32(0, 0x02014b50, true); c.setUint16(10, 8, true); c.setUint32(20, data.length, true); c.setUint32(24, raw.length, true); c.setUint16(28, n.length, true); c.setUint32(42, off, true);
    parts.push(new Uint8Array(h.buffer), n, data);
    central.push(new Uint8Array(c.buffer), n);
    off += 30 + n.length + data.length;
  }
  const cdSize = central.reduce((s, x) => s + x.length, 0);
  const e = new DataView(new ArrayBuffer(22));
  e.setUint32(0, 0x06054b50, true); e.setUint16(8, Object.keys(files).length, true); e.setUint16(10, Object.keys(files).length, true); e.setUint32(12, cdSize, true); e.setUint32(16, off, true);
  const all = [...parts, ...central, new Uint8Array(e.buffer)];
  const out = new Uint8Array(all.reduce((s, x) => s + x.length, 0));
  let p = 0;
  for (const x of all) { out.set(x, p); p += x.length; }
  return out;
}

// ---- pure parts ----

describe('App Usage and Play install stock numbers', () => {
  const SESSIONS = 'Date\tApp Name\tApp Apple Identifier\tApp Version\tDevice\tPlatform Version\tSource Type\tSource Info\tTerritory\tSessions\tTotal Session Duration\tUnique Devices\n' +
    '2026-10-01\tExample\t1\t1.0\tiPhone\tiOS 26\t\t\tUS\t100\t3000\t40\n2026-10-01\tExample\t1\t1.0\tiPad\tiPadOS 26\t\t\tTR\t20\t600\t8\n2026-10-02\tExample\t1\t1.0\tiPhone\tiOS 26\t\t\tUS\t50\t1000\t30\n';
  const CRASHES = 'Date\tApp Name\tApp Apple Identifier\tApp Version\tDevice\tPlatform Version\tCrashes\tUnique Devices\n2026-10-01\tExample\t1\t1.0\tiPhone\tiOS 26\t4\t3\n2026-10-03\tExample\t1\t1.0\tiPhone\tiOS 26\t1\t1\n';
  test('sessions, active devices, session time and crashes per day, merged into the engagement days', () => {
    const base = appleDaily(parseReport('Date\tEvent\tCounts\tUnique Counts\n2026-10-01\tImpression\t10\t8\n'), []);
    const d = mergeAppleUsage(base, parseReport(SESSIONS), parseReport(CRASHES));
    expect(d.map(x => x.date)).toEqual(['2026-10-01', '2026-10-02', '2026-10-03']);
    expect(d[0]).toMatchObject({ impressions: 10, sessions: 120, activeDevices: 48, sessionSeconds: 3600, crashes: 4 });
    expect(d[1]).toMatchObject({ impressions: 0, sessions: 50, activeDevices: 30 });
    expect(d[1]!.crashes).toBeUndefined();
    expect(d[2]).toMatchObject({ crashes: 1 });
    expect(appleTotals(d)).toMatchObject({ sessions: 170, crashes: 5, activeDevicesAvg: 39 });
    expect(appleTotals(base).sessions).toBeUndefined();
  });
  test('Play: stock columns from the overview file, else summed over the country rows; totals take the newest day', () => {
    const country = parseReport('Date,Package Name,Country,Daily Device Installs,Daily User Installs,Total User Installs,Active Device Installs\n' +
      '2026-10-01,p,US,5,4,100,60\n2026-10-01,p,TR,2,2,50,30\n2026-10-02,p,US,1,1,101,61\n');
    expect(playDaily([], country)).toEqual([
      { date: '2026-10-01', visitors: 0, acquisitions: 0, installs: 6, activeDeviceInstalls: 90, totalUserInstalls: 150 },
      { date: '2026-10-02', visitors: 0, acquisitions: 0, installs: 1, activeDeviceInstalls: 61, totalUserInstalls: 101 }]);
    const overview = parseReport('Date,Package Name,Total User Installs,Active Device Installs\n2026-10-01,p,160,95\n2026-10-02,p,162,96\n');
    const d = playDaily([], country, overview);
    expect(d[0]).toMatchObject({ installs: 6, activeDeviceInstalls: 95, totalUserInstalls: 160 });
    expect(playTotals(d)).toMatchObject({ installs: 7, activeDeviceInstalls: 96, totalUserInstalls: 162 });
    expect(playDaily([], parseReport('Date,Daily User Installs\n2026-10-01,3\n'))[0]!.activeDeviceInstalls).toBeUndefined();
  });
});

describe('store-only config and bucket fallback', () => {
  const virtual = (apple: Record<string, unknown>): unknown => ({ ...BASE, apple, play: { packageName: 'com.example.notes' } });
  test('apple.appId alone is enough; a missing id is still an error', () => {
    expect(validateConfig(virtual({ bundleId: null, appId: '6400000101' }))).toEqual([]);
    expect(validateConfig(virtual({ appId: '6400000101' }))).toEqual([]);
    expect(validateConfig(virtual({ bundleId: null }))[0]).toContain('apple.bundleId');
    expect(validateConfig(virtual({ bundleId: 'nope' }))[0]).toContain('apple.bundleId');
    expect(validateConfig(virtual({ bundleId: null, appId: 'abc' }))[0]).toContain('apple.bundleId');
  });
  test('reports bucket: config, then env PLAY_REPORTS_BUCKET, then the profile field reportsBucket', () => {
    const dir = mkdtempSync(join(tmpdir(), 'sb-prof-'));
    writeFileSync(join(dir, 'acme.json'), JSON.stringify({ reportsBucket: `gs://${BUCKET}/` }));
    process.env.STOREBOUND_CREDENTIALS_DIR = dir;
    process.env.STOREBOUND_PROFILE = 'acme';
    const root = mkdtempSync(join(tmpdir(), 'sb-root-'));
    expect(profileEnv('acme').PLAY_REPORTS_BUCKET).toBe(`gs://${BUCKET}/`);
    expect(playReportsBucket(root)).toBe(`gs://${BUCKET}/`);
    process.env.PLAY_REPORTS_BUCKET = 'pubsite_prod_rev_999';
    expect(playReportsBucket(root)).toBe('pubsite_prod_rev_999');
    expect(playReportsBucket(root, BUCKET)).toBe(BUCKET);
    process.env.PLAY_REPORTS_BUCKET = 'my-bucket';
    expect(() => playReportsBucket(root)).toThrow('PLAY_REPORTS_BUCKET');
    delete process.env.PLAY_REPORTS_BUCKET;
    process.env.STOREBOUND_PROFILE = '';
    expect(playReportsBucket(root)).toBeNull();
  });
});

describe('day ranges and daily sales', () => {
  test('reportRange: --days ends yesterday, --from/--to inclusive, checks', () => {
    const now = new Date('2026-10-26T10:00:00Z');
    expect(reportRange({}, now)).toBeNull();
    expect(reportRange({ days: '3' }, now)).toEqual({ from: '2026-10-23', to: '2026-10-25', dates: ['2026-10-23', '2026-10-24', '2026-10-25'] });
    expect(reportRange({ from: '2026-10-24' }, now)!.dates).toEqual(['2026-10-24', '2026-10-25']);
    expect(reportRange({ from: '2026-10-24', to: '2026-10-24' }, now)!.dates).toEqual(['2026-10-24']);
    expect(() => reportRange({ days: '0' }, now)).toThrow('--days');
    expect(() => reportRange({ days: '2', from: '2026-10-01' }, now)).toThrow('not both');
    expect(() => reportRange({ from: '2026-10-03', to: '2026-10-01' }, now)).toThrow('after');
    expect(() => reportRange({ from: '10/03/2026' }, now)).toThrow('YYYY-MM-DD');
    expect(() => reportRange({ to: '2026-10-03' }, now)).toThrow('--from');
    expect(dateRange('2026-02-27', '2026-03-02')).toHaveLength(4);
  });
  test('rangeReport: totals per currency over the days, the dates without a report listed', () => {
    const tsv = (units: number) => ['Provider\tSKU\tTitle\tUnits\tDeveloper Proceeds\tCurrency of Proceeds', `APPLE\tcom.example.pro\tPro\t${units}\t2.5\tUSD`, 'APPLE\tcom.example.pro\tPro\t1\t3\tEUR', ''].join('\n');
    const day = (date: string, units: number) => { const summary = summarizeAppleSales(parseTsv(tsv(units))); return { date, rows: 2, summary, totals: totalsByCurrency(summary) }; };
    const r = rangeReport([day('2026-10-02', 4), day('2026-10-01', 2)], ['2026-10-01', '2026-10-02', '2026-10-03']);
    expect(r.days.map(d => d.date)).toEqual(['2026-10-01', '2026-10-02']);
    expect(r.totals).toEqual([{ currency: 'EUR', units: 2, amount: 6 }, { currency: 'USD', units: 6, amount: 15 }]);
    expect(r.missing).toEqual(['2026-10-03']);
  });
  test('Play sales per order-charged date and currency: charged, refunds (negative), net', () => {
    const csv = 'Order Number,Order Charged Date,Financial Status,SKU ID,Currency of Sale,Item Price,Taxes Collected,Charged Amount\n' +
      'A1,2026-10-01,Charged,pro,USD,4.99,0.00,4.99\nA2,2026-10-01,Charged,pro,USD,4.00,0.50,4.50\nA3,2026-10-01,Charged,pro,EUR,5.00,1.00,6.00\n' +
      'A4,2026-10-02,Refund,pro,USD,4.99,0.00,4.99\nA5,2026-10-02,Refund,pro,USD,-1.00,0.00,-1.00\nA6,2026-09-30,Charged,pro,USD,9,0,9\nA7,2026-10-02,Other,pro,USD,9,0,9\n';
    const d = summarizePlaySalesByDay(parsePlayCsv(csv), '2026-10-01', '2026-10-03');
    expect(d).toEqual([
      { date: '2026-10-01', currency: 'EUR', orders: 1, refunds: 0, itemPrice: 5, taxes: 1, charged: 6, refunded: 0, net: 6 },
      { date: '2026-10-01', currency: 'USD', orders: 2, refunds: 0, itemPrice: 8.99, taxes: 0.5, charged: 9.49, refunded: 0, net: 9.49 },
      { date: '2026-10-02', currency: 'USD', orders: 0, refunds: 2, itemPrice: 0, taxes: 0, charged: 0, refunded: -5.99, net: -5.99 }]);
    expect(playSalesTotals(d)).toEqual([{ currency: 'EUR', orders: 1, refunds: 0, charged: 6, refunded: 0, net: 6 }, { currency: 'USD', orders: 2, refunds: 2, charged: 9.49, refunded: -5.99, net: 3.5 }]);
  });
});

// ---- the commands, as the collector calls them ----

const md5 = (s: string) => createHash('md5').update(s).digest('hex');

describe('analytics snapshot on a store-only config', () => {
  const d1 = iso(-1), d2 = iso(-2);
  const ENG = `Date\tEvent\tCounts\tUnique Counts\n${d1}\tImpression\t100\t80\n${d1}\tPage view\t30\t25\n${d2}\tImpression\t60\t50\n`;
  const DL = `Date,Download Type,Counts\n${d1},First-time Download,10\n${d2},Redownload,2\n`;
  const SES = `Date\tSessions\tTotal Session Duration\tUnique Devices\n${d1}\t200\t6000\t90\n${d2}\t150\t4000\t70\n`;
  const CRA = `Date\tCrashes\tUnique Devices\n${d1}\t3\t2\n`;
  const files: Record<string, string> = { eng: ENG, dl: DL, ses: SES, cra: CRA };
  const reportsList = [
    { id: 'r-eng', attributes: { category: 'APP_STORE_ENGAGEMENT', name: 'App Store Discovery and Engagement Standard' } },
    { id: 'r-dl', attributes: { category: 'COMMERCE', name: 'App Store Downloads Standard' } },
    { id: 'r-ses', attributes: { category: 'APP_USAGE', name: 'App Sessions Standard' } },
    { id: 'r-cra', attributes: { category: 'APP_USAGE', name: 'App Crashes Standard' } },
  ];
  const appleRoutes = (list = reportsList) => [
    { match: /\/v1\/apps\/6400000101\/analyticsReportRequests\?/, answer: { data: [{ id: 'req1', attributes: {} }] } },
    { match: /\/v1\/analyticsReportRequests\/req1\/reports\?/, answer: { data: list } },
    { match: /\/v1\/analyticsReports\/r-(\w+)\/instances\?/, answer: (c: Req) => { const k = /r-(\w+)\//.exec(decodeURIComponent(c.path))![1]!; return { data: [{ id: `i-${k}`, attributes: { processingDate: iso(0) } }] }; } },
    { match: /\/v1\/analyticsReportInstances\/i-(\w+)\/segments\?/, answer: (c: Req) => { const k = /i-(\w+)\//.exec(decodeURIComponent(c.path))![1]!; return { data: [{ id: `s-${k}`, attributes: { url: `https://segments.example.com/seg/${k}`, checksum: md5(files[k]!) } }] }; } },
    { match: /^\/seg\/(\w+)$/, answer: (c: Req) => new Response(files[c.path.slice(5)]!) },
  ];
  const virtualConfig = (): ShipConfig => ({ ...BASE, apple: { bundleId: null as unknown as string, appId: '6400000101' }, play: { packageName: 'com.example.notes' } });

  test('apple: appId only, App Usage per day, --json on stdout, --no-write leaves no file', async () => {
    ascEnv();
    const p = project(virtualConfig());
    const calls = mockFetch(appleRoutes());
    const r = await capture(() => analytics(p.ctx(['snapshot', '--store', 'apple', '--days', '3', '--json', '--no-write'])));
    const snap = jsonOut(r.out) as { apple: { daily: Record<string, string | number>[]; totals: Record<string, number> } };
    expect(snap.apple.daily.find(x => x.date === d1)).toMatchObject({ impressions: 100, pageViews: 30, downloads: 10, sessions: 200, activeDevices: 90, sessionSeconds: 6000, crashes: 3 });
    expect(snap.apple.daily.find(x => x.date === d2)).toMatchObject({ sessions: 150, activeDevices: 70 });
    expect(snap.apple.totals).toMatchObject({ sessions: 350, crashes: 3, activeDevicesAvg: 80 });
    expect(calls.some(c => /filter\[bundleId\]/.test(decodeURIComponent(c.path)))).toBe(false);
    expect(existsSync(join(p.root, '.storebound/analytics'))).toBe(false);
  });
  test('apple: without the usage reports the rest still comes, with a note', async () => {
    ascEnv();
    const p = project(virtualConfig());
    mockFetch(appleRoutes(reportsList.slice(0, 2)));
    const r = await capture(() => analytics(p.ctx(['snapshot', '--store', 'apple', '--days', '3', '--json'])));
    const snap = jsonOut(r.out) as { apple: { daily: Record<string, string | number>[]; notes: string[] } };
    expect(snap.apple.daily.find(x => x.date === d1)!.impressions).toBe(100);
    expect(snap.apple.daily[0]!.sessions).toBeUndefined();
    expect(snap.apple.notes[0]).toContain('App Usage');
    expect(existsSync(join(p.root, '.storebound/analytics', `${iso(0)}.json`))).toBe(true);
  });
  test('play: the bucket from env, install stock numbers, daily user installs', async () => {
    playEnv();
    process.env.PLAY_REPORTS_BUCKET = BUCKET;
    const p = project(virtualConfig());
    const month = (d: string) => d.slice(0, 7).replace('-', '');
    const inMonth = (m: string) => [d2, d1].filter(d => month(d) === m);
    const mOf = (c: Req) => /_(\d{6})_/.exec(decodeURIComponent(c.path))![1]!;
    mockFetch([
      { match: /store_performance_com\.example\.notes_(\d{6})_country\.csv\?alt=media$/, answer: (c: Req) => new Response(`Date,Package name,Country,Store listing acquisitions,Store listing visitors\n${inMonth(mOf(c)).map(d => `${d},com.example.notes,US,5,50`).join('\n')}\n`) },
      { match: /installs_com\.example\.notes_(\d{6})_country\.csv\?alt=media$/, answer: (c: Req) => new Response(`Date,Package Name,Country,Daily User Installs,Total User Installs,Active Device Installs\n${inMonth(mOf(c)).map(d => `${d},com.example.notes,US,4,100,60`).join('\n')}\n`) },
      { match: /installs_com\.example\.notes_(\d{6})_overview\.csv\?alt=media$/, answer: (c: Req) => new Response(`Date,Package Name,Total User Installs,Active Device Installs\n${inMonth(mOf(c)).map(d => `${d},com.example.notes,${d === d1 ? 120 : 110},${d === d1 ? 70 : 65}`).join('\n')}\n`) },
    ]);
    const r = await capture(() => analytics(p.ctx(['snapshot', '--store', 'play', '--days', '3', '--json', '--dry'])));
    const snap = jsonOut(r.out) as { play: { daily: Record<string, string | number>[]; totals: Record<string, number> } };
    expect(snap.play.daily.find(x => x.date === d1)).toMatchObject({ visitors: 50, acquisitions: 5, installs: 4, activeDeviceInstalls: 70, totalUserInstalls: 120 });
    expect(snap.play.totals).toMatchObject({ installs: 8, activeDeviceInstalls: 70, totalUserInstalls: 120 });
  });
  test('play without any bucket: the command fails (nothing to write)', async () => {
    playEnv();
    const p = project(virtualConfig());
    mockFetch([]);
    await expect(capture(() => analytics(p.ctx(['snapshot', '--store', 'play', '--days', '3', '--json'])))).rejects.toThrow('nothing written');
  });
});

describe('reports over a day range', () => {
  test('apple-sales --days: one JSON with the days, totals per currency, the missing day listed', async () => {
    ascEnv();
    process.env.ASC_VENDOR_NUMBER = '12345678';
    const p = project();
    const yesterday = iso(-1), before = iso(-2);
    const tsv = (units: number, proceeds: string, cur: string) => ['Provider\tSKU\tTitle\tUnits\tDeveloper Proceeds\tCurrency of Proceeds', `APPLE\tcom.example.notes.pro\tPro\t${units}\t${proceeds}\t${cur}`, ''].join('\n');
    const calls = mockFetch([{ match: /^\/v1\/salesReports\?/, answer: (c: Req) => {
      const date = /reportDate\]=(\d{4}-\d{2}-\d{2})/.exec(decodeURIComponent(c.path))![1]!;
      return date === yesterday ? new Response('{"errors":[{"status":"404","code":"NOT_FOUND"}]}', { status: 404 }) : new Response(Bun.gzipSync(new TextEncoder().encode(tsv(2, '3.49', date === before ? 'USD' : 'EUR'))));
    } }]);
    const r = await capture(() => reports(p.ctx(['apple-sales', '--days', '3', '--json'])));
    const j = jsonOut(r.out) as { from: string; to: string; days: { date: string; totals: unknown[] }[]; totals: unknown[]; missing: string[]; rows: number };
    expect(calls).toHaveLength(3);
    expect(j.to).toBe(yesterday);
    expect(j.days.map(d => d.date)).toEqual([iso(-3), before]);
    expect(j.missing).toEqual([yesterday]);
    expect(j.totals).toEqual([{ currency: 'EUR', units: 2, amount: 6.98 }, { currency: 'USD', units: 2, amount: 6.98 }]);
    expect(j.rows).toBe(2);
    expect(existsSync(join(p.root, `.storebound/reports/apple-sales-daily-${before}.tsv`))).toBe(true);
    expect(readFileSync(join(p.root, `.storebound/reports/apple-sales-daily-${iso(-3)}_${yesterday}.summary.csv`), 'utf8')).toContain('date,key,title,currency,units,amount,rows');
  });
  test('apple-sales with a --type other than SALES, or --days on finance, is refused', async () => {
    ascEnv();
    const p = project();
    await expect(capture(() => reports(p.ctx(['apple-sales', '--days', '3', '--type', 'SUBSCRIPTION', '--vendor', '12345678'])))).rejects.toThrow('SALES');
    await expect(capture(() => reports(p.ctx(['apple-finance', '--days', '3', '--month', '2026-09', '--vendor', '12345678'])))).rejects.toThrow('monthly');
  });
  test('play-sales --days: the daily revenue per currency from the monthly sales zips; play-earnings --days is refused', async () => {
    playEnv();
    process.env.PLAY_REPORTS_BUCKET = BUCKET;
    const p = project({ ...BASE, play: { packageName: 'com.example.notes' } });
    const d1 = iso(-1), d2 = iso(-2);
    const months = new Set([d1, d2].map(d => d.slice(0, 7).replace('-', '')));
    const csv = `Order Number,Order Charged Date,Financial Status,SKU ID,Currency of Sale,Item Price,Taxes Collected,Charged Amount\nA1,${d1},Charged,pro,USD,4.99,0,4.99\nA2,${d2},Charged,pro,USD,4.99,0,4.99\nA3,${d2},Refund,pro,USD,4.99,0,4.99\n`;
    mockFetch([
      { match: /\/o\?prefix=sales\/salesreport_(\d{6})$/, answer: (c: Req) => { const m = /salesreport_(\d{6})/.exec(decodeURIComponent(c.path))![1]!; return { items: months.has(m) ? [{ name: `sales/salesreport_${m}.zip` }] : [] }; } },
      { match: /\/o\/sales\/salesreport_\d{6}\.zip\?alt=media$/, answer: () => new Response(zip({ 'salesreport.csv': csv }) as Uint8Array<ArrayBuffer>) },
    ]);
    const r = await capture(() => reports(p.ctx(['play-sales', '--days', '2', '--json'])));
    const j = jsonOut(r.out) as { days: { date: string; net: number }[]; totals: unknown[]; emptyDays: string[] };
    // one zip per month the window touches: a window across a month end reads the same fixture twice, so compare per day
    const once = months.size === 1;
    expect(j.days).toMatchObject([{ date: d2, currency: 'USD', orders: once ? 1 : 2, refunds: once ? 1 : 2 }, { date: d1, orders: once ? 1 : 2 }]);
    if (once) expect(j.totals).toEqual([{ currency: 'USD', orders: 2, refunds: 1, charged: 9.98, refunded: -4.99, net: 4.99 }]);
    expect(j.emptyDays).toEqual([]);
    expect(existsSync(join(p.root, `.storebound/reports/play-sales-daily-${d2}_${d1}.summary.csv`))).toBe(true);
    await expect(capture(() => reports(p.ctx(['play-earnings', '--days', '2'])))).rejects.toThrow('monthly');
  });
});