import { describe, expect, test } from 'bun:test';
import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join, resolve as pathResolve } from 'node:path';
import bundledJson from '../cli/data/ppp-worldbank.json';
import { parseArgs } from '../cli/lib/args';
import { ALPHA3 } from '../cli/lib/money';
import {
  appleCurrencyHint, bigMacDataset, CURRENCY, datasetJson, datasetProblems, fxOf, HIGH_INCOME, offlinePar, parseFactorCsv, planRows, PPP_DEFAULTS, type PppDataset,
  type PppOptions, pppCsv, shareOf, snapApple, snapEnding, snapUp, TOP_MARKETS, topMarketDrops, topMarketsFromReports, VAT, worldBankDataset,
} from '../cli/lib/ppp';
import { parsePriceCsv } from '../cli/lib/prices';
import { applePoints, run } from '../cli/prices-ppp';

const P = 'com.example.game.remove_ads';
const ds: PppDataset = {
  name: 'worldbank', source: 'test', url: 'https://example.com', license: 'CC BY 4.0', retrieved: '2026-10-11', eur: { fx: 0.9 },
  countries: {
    US: { ppp: 1, fx: 1, year: 2025, currency: 'USD' },
    DE: { ppp: 0.72, fx: 0.9, year: 2025, currency: 'EUR' },
    TR: { ppp: 16, fx: 40, year: 2025, currency: 'TRY' },
    IN: { ppp: 20, fx: 87, year: 2025, currency: 'INR' },
    CH: { ppp: 1.2, fx: 0.8, year: 2025, currency: 'CHF' },
    JP: { ppp: 97, fx: 150, year: 2025, currency: 'JPY' },
    BA: { ppp: 0.7, fx: 1.75, year: 2025, currency: 'BAM' },
    MX: { ppp: 10, fx: 18, year: 2025, currency: 'MXN' },
    CN: { ppp: 3.4, fx: 7.2, year: 2025, currency: 'CNY' },
    AF: { ppp: 13, year: 2024, currency: 'AFN' },
  },
};

const OPEN: PppOptions = { ...PPP_DEFAULTS, maxRatio: 1.2, maxLevel: 5, onlyDecreases: false, includeHighIncome: true };

describe('ppp math', () => {
  test('share of par: level = factor / fx, clamped to min..max ratio; defaults keep high-income, CN and levels above 0.5 at par', () => {
    expect(shareOf('US', 1, PPP_DEFAULTS)).toEqual({ share: 1, reason: 'base' });
    expect(shareOf('DE', 0.8, PPP_DEFAULTS)).toEqual({ share: 1, reason: 'high-income' });
    expect(shareOf('CN', 0.47, PPP_DEFAULTS)).toEqual({ share: 1, reason: 'china' });
    expect(shareOf('MX', 0.55, PPP_DEFAULTS)).toEqual({ share: 1, reason: 'above-level' });
    expect(shareOf('TR', 0.41, PPP_DEFAULTS)).toEqual({ share: 0.41, reason: 'ppp' });
    expect(shareOf('IN', 0.23, PPP_DEFAULTS)).toEqual({ share: 0.3, reason: 'min-ratio' });
    expect(shareOf('DE', 0.8, OPEN)).toEqual({ share: 0.8, reason: 'ppp' });
    expect(shareOf('CH', 1.5, OPEN)).toEqual({ share: 1.2, reason: 'max-ratio' });
    expect(shareOf('AF', null, PPP_DEFAULTS)).toEqual({ share: 1, reason: 'no-ppp-data' });
    expect(HIGH_INCOME.has('DE') && HIGH_INCOME.has('GB') && HIGH_INCOME.has('JP') && !HIGH_INCOME.has('IN') && !HIGH_INCOME.has('CN')).toBe(true);
  });
  test('offline par: US price x exchange rate x (1 + VAT): store prices include VAT, the US price does not', () => {
    expect(offlinePar(4.99, 'DE', 'EUR', ds)).toBeCloseTo(4.99 * 0.9 * 1.19, 6);
    expect(offlinePar(4.99, 'US', 'USD', ds)).toBe(4.99);
    expect(offlinePar(4.99, 'XX', 'XYZ', ds)).toBeNull();
    expect(VAT.US).toBeUndefined();
  });
  test('fxOf: USD 1, EUR the euro rate, else a country with that currency', () => {
    expect(fxOf(ds, 'USD')).toBe(1);
    expect(fxOf(ds, 'EUR')).toBe(0.9);
    expect(fxOf(ds, 'TRY')).toBe(40);
    expect(fxOf(ds, 'XYZ')).toBeNull();
  });
});

describe('snapping', () => {
  test('two-decimal currencies: x.x9 under 1, x.99 under 100, ...9 under 1000', () => {
    expect(snapEnding(2.4, 'USD')).toBe(1.99);
    expect(snapEnding(2.6, 'USD')).toBe(2.99);
    expect(snapEnding(0.3, 'GBP')).toBe(0.29);
    expect(snapEnding(0.02, 'GBP')).toBe(0.09);
    expect(snapEnding(1.2, 'EUR')).toBe(0.99);
    expect(snapEnding(49.6, 'TRY')).toBe(49.99);
    expect(snapEnding(129.4, 'TRY')).toBe(129);
    expect(snapEnding(135, 'INR')).toBe(139);
  });
  test('zero-decimal and large-unit currencies: round numbers', () => {
    expect(snapEnding(478, 'JPY')).toBe(480);
    expect(snapEnding(80.4, 'JPY')).toBe(80);
    expect(snapEnding(3456, 'KRW')).toBe(3500);
    expect(snapEnding(45678, 'IDR')).toBe(46000);
    expect(snapEnding(56789, 'VND')).toBe(57000);
    expect(snapEnding(2345, 'CLP')).toBe(2300);
    expect(snapEnding(923, 'HUF')).toBe(920);
    expect(snapEnding(1234.5, 'PKR')).toBe(1200);
  });
  test('par rounds up to the next clean price (stores round their own conversions up)', () => {
    expect(snapUp(5.26, 'EUR')).toBe(5.99);
    expect(snapUp(4.99, 'EUR')).toBe(4.99);
    expect(snapUp(821.5, 'JPY')).toBe(830);
    expect(snapUp(111.35, 'MXN')).toBe(119);
    expect(snapUp(0.31, 'GBP')).toBe(0.39);
  });
  test('Apple: nearest real price point', () => {
    expect(snapApple([49.99, 59.99, 64.99, 69.99], 62)).toBe(59.99);
    expect(snapApple([], 62)).toBeNull();
  });
});

describe('planRows', () => {
  test('defaults: Germany stays near EUR 5.99 for USD 4.99, India and Turkey drop, high-income and price levels above 0.5 keep par', () => {
    const { rows, kept, skipped } = planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: PPP_DEFAULTS });
    const by = new Map([...rows, ...kept].map(r => [r.region, r] as const));
    expect(rows.map(r => r.region)).toEqual(['BA', 'IN', 'TR', 'US']);
    for (const r of ['CH', 'DE', 'FR', 'JP', 'MX']) expect(kept.map(k => k.region)).toContain(r);
    expect(by.get('MX')).toMatchObject({ reason: 'above-level', share: 1 });
    expect(by.get('US')).toMatchObject({ currency: 'USD', price: 4.99, snap: 'base' });
    expect(by.get('DE')).toMatchObject({ currency: 'EUR', price: 5.99, reason: 'high-income', share: 1 });
    expect(by.get('JP')).toMatchObject({ currency: 'JPY', reason: 'high-income' });
    expect(by.get('JP')!.price).toBeGreaterThanOrEqual(4.99 * 150 * 1.1);
    expect(by.get('CH')).toMatchObject({ reason: 'high-income', share: 1 });
    expect(by.get('IN')).toMatchObject({ currency: 'INR', reason: 'min-ratio', share: 0.3 });
    expect(by.get('IN')!.price).toBeLessThan(4.99 * 87 * 1.18 * 0.35);
    expect(by.get('TR')).toMatchObject({ currency: 'TRY', reason: 'ppp', share: 0.4 });
    expect(by.get('TR')!.price).toBe(snapEnding(4.99 * 40 * 1.2 * 0.4, 'TRY'));
    expect(by.get('BA')).toMatchObject({ currency: 'BAM', reason: 'ppp', share: 0.4 });
    expect(skipped.find(s => s.region === 'AF')!.why).toBe('no exchange rate');
    expect(skipped.find(s => s.region === 'PE')!.why).toMatch(/no PPP factor/);
    expect(skipped.find(s => s.region === 'CN')!.why).toMatch(/not available in mainland China/);
    expect(rows.every(r => r.price <= r.par * 1.2 || r.share === 1)).toBe(true);
    expect(rows.every(r => r.territory === undefined)).toBe(true);
  });
  test('the old method (no VAT, no par, everything cut) would have given Germany EUR 3.59: the open options still compare net with net', () => {
    const { rows } = planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: OPEN });
    const de = rows.find(r => r.region === 'DE')!;
    expect(de.share).toBeCloseTo(0.8, 6);
    expect(de.price).toBe(snapEnding(4.99 * 0.9 * 1.19 * 0.8, 'EUR'));
    expect(de.price).toBeGreaterThan(3.59);
  });
  test('only-decreases: never above the current store price; max-ratio caps a region at N x par', () => {
    const current = new Map([['TR', { currency: 'TRY', price: 59.99 }], ['DE', { currency: 'EUR', price: 4.99 }]]);
    const { rows, kept } = planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: PPP_DEFAULTS, current });
    expect(rows.some(r => r.region === 'TR' || r.region === 'DE')).toBe(false);
    expect(kept.find(r => r.region === 'TR')).toMatchObject({ price: 59.99, reason: 'only-decreases' });
    expect(kept.find(r => r.region === 'DE')).toMatchObject({ price: 4.99, reason: 'only-decreases' });
    const up = planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: { ...PPP_DEFAULTS, onlyDecreases: false, includeHighIncome: true, maxLevel: 1 }, current }).rows;
    expect(up.find(r => r.region === 'TR')!.price).toBeGreaterThan(59.99);
    const capped = planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: { ...OPEN, maxRatio: 0.5 } }).rows;
    expect(capped.find(r => r.region === 'DE')).toMatchObject({ share: 0.5, reason: 'max-ratio' });
  });
  test('offline Apple: the currency hint (Euro-Zone group EUR, USD groups USD), alpha-3 territory, CN at par', () => {
    const { rows, kept } = planRows({ product: P, base: 4.99, store: 'apple', dataset: ds, options: PPP_DEFAULTS });
    expect(rows.find(r => r.region === 'BA')).toMatchObject({ currency: 'EUR', territory: 'BIH' });
    expect(kept.find(r => r.region === 'CN')).toMatchObject({ reason: 'china', share: 1 });
    expect(appleCurrencyHint('TR')).toBe('TRY');
    expect(appleCurrencyHint('AF')).toBe('USD');
    expect(appleCurrencyHint('RS')).toBe('EUR');
  });
  test('online: the store\'s own conversion is par (Apple equalizations, Play convertRegionPrices); Apple snaps to its price points', () => {
    const regions = new Map([
      ['US', { currency: 'USD', points: [3.99, 4.99, 5.99] }],
      ['DE', { currency: 'EUR', points: [4.99, 5.99, 6.99], par: 5.99 }],
      ['TR', { currency: 'TRY', points: [49.99, 59.99, 64.99, 69.99, 79.99, 99.99], par: 249.99 }],
      ['JP', { currency: 'JPY', points: [] as number[] }],
    ]);
    const { rows, kept, skipped } = planRows({ product: P, base: 4.99, store: 'apple', dataset: ds, options: PPP_DEFAULTS, regions });
    expect([...rows, ...kept].map(r => `${r.region} ${r.currency} ${r.price} ${r.snap}`)).toEqual(['TR TRY 99.99 apple-point', 'US USD 4.99 apple-point', 'DE EUR 5.99 par']);
    expect(rows.find(r => r.region === 'TR')!.snappedFrom).toBeCloseTo(249.99 * 0.4, 1);
    expect(kept.find(r => r.region === 'DE')!.parFrom).toBe('store');
    expect(skipped.map(s => `${s.region}: ${s.why}`)).toEqual(['JP: no Apple price points']);
  });
  test('top-market check: a drop of more than 20 % in a top market is named', () => {
    const { rows } = planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: OPEN });
    const drops = topMarketDrops(rows, TOP_MARKETS);
    expect(drops.map(d => d.region)).toContain('JP');
    expect(drops.every(d => d.drop > 0.2)).toBe(true);
    expect(topMarketDrops(planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: PPP_DEFAULTS }).rows, TOP_MARKETS)).toEqual([]);
    expect(topMarketsFromReports([[{ 'Country Code': 'TR', Units: '10', 'Developer Proceeds': '80', 'Currency of Proceeds': 'TRY' },
      { 'Country Code': 'DE', Units: '3', 'Developer Proceeds': '4', 'Currency of Proceeds': 'EUR' }], [{ 'Buyer Country': 'IN', 'Charged Amount': '2000', 'Currency of Sale': 'INR' }]], ds))
      .toEqual(['IN', 'TR', 'DE']);
  });
  test('CSV round trip through parsePriceCsv (the prices import parser)', () => {
    const rows = [...planRows({ product: P, base: 4.99, store: 'apple', dataset: ds, options: PPP_DEFAULTS }).rows,
      ...planRows({ product: P, base: 4.99, store: 'play', dataset: ds, options: PPP_DEFAULTS }).rows];
    const back = parsePriceCsv(pppCsv(rows), { products: [P], today: '2026-10-11' });
    const k = (r: { store: string; region: string; currency: string; price: number }) => `${r.store} ${r.region} ${r.currency} ${r.price}`;
    expect(back.map(k).sort()).toEqual(rows.map(k).sort());
    expect(back.find(r => r.store === 'apple' && r.region === 'BA')!.territory).toBe('BIH');
    expect(pppCsv(rows).split('\n')[0]).toBe('product,store,region,currency,price,start_date,kind');
  });
});

describe('datasets', () => {
  const bundled = bundledJson as unknown as PppDataset;
  test('bundled World Bank file: shape, citation, licence, euro rate', () => {
    expect(datasetProblems(bundled)).toEqual([]);
    expect(bundled.name).toBe('worldbank');
    expect(bundled.license).toBe('CC BY 4.0');
    expect(bundled.attribution).toMatch(/World Bank/);
    expect(bundled.source).toMatch(/PA\.NUS\.PPP/);
    expect(bundled.source).toMatch(/PA\.NUS\.FCRF/);
    expect(bundled.retrieved).toMatch(/^\d{4}-\d{2}-\d{2}$/);
    expect(bundled.urls!.some(u => u.startsWith('https://api.worldbank.org/'))).toBe(true);
    expect(bundled.year).toBeGreaterThanOrEqual(2023);
    expect(Object.keys(bundled.countries).length).toBeGreaterThan(120);
    for (const [r, e] of Object.entries(bundled.countries)) {
      expect(ALPHA3[r]).toBeDefined();
      expect(e.currency).toBe(CURRENCY[r]!);
      if (e.currency === 'EUR') expect(e.fx).toBe(bundled.eur!.fx);
    }
    expect(bundled.countries.US).toMatchObject({ ppp: 1, fx: 1 });
    expect(JSON.parse(datasetJson(bundled))).toEqual(bundled);
  });
  test('CURRENCY covers every App Store territory', () => {
    expect(Object.keys(ALPHA3).filter(k => !CURRENCY[k])).toEqual([]);
  });
  test('worldBankDataset: latest year, aggregates out, euro rate, unit mismatch dropped', () => {
    const obs = (id: string, date: string, value: number | null) => ({ country: { id }, countryiso3code: '', date, value });
    const ppp: [unknown, ReturnType<typeof obs>[]] = [{}, [obs('ZH', '2025', 5), obs('DE', '2024', 0.7), obs('DE', '2025', 0.71), obs('TR', '2025', null), obs('TR', '2024', 15), obs('LR', '2025', 0.4), obs('US', '2025', 1)]];
    const fx: [unknown, ReturnType<typeof obs>[]] = [{}, [obs('XC', '2025', 0.88), obs('TR', '2025', 39), obs('LR', '2025', 190), obs('US', '2025', 1)]];
    const countries: [unknown, { id: string; iso2Code: string; region?: { value?: string } }[]] = [{}, [
      { id: 'AFE', iso2Code: 'ZH', region: { value: 'Aggregates' } }, { id: 'DEU', iso2Code: 'DE', region: { value: 'Europe & Central Asia' } },
      { id: 'TUR', iso2Code: 'TR' }, { id: 'LBR', iso2Code: 'LR' }, { id: 'USA', iso2Code: 'US' }]];
    const d = worldBankDataset(ppp, fx, countries, '2026-10-11');
    expect(Object.keys(d.countries)).toEqual(['DE', 'TR', 'US']);
    expect(d.countries.DE).toEqual({ ppp: 0.71, fx: 0.88, year: 2025, currency: 'EUR' });
    expect(d.countries.TR).toEqual({ ppp: 15, fx: 39, year: 2024, fxYear: 2025, currency: 'TRY' });
    expect(d.eur).toEqual({ fx: 0.88, year: 2025 });
    expect(d.notes!.join(' ')).toMatch(/LR/);
    expect(datasetProblems(d)).toEqual([]);
  });
  test('bigMacDataset: implied PPP = local / US price, latest date, euro area row for EUR members', () => {
    const csv = `date,iso_a3,currency_code,name,local_price,dollar_ex,dollar_price
2025-07-01,USA,USD,United States,5.5,1,5.5
2026-07-01,USA,USD,United States,6,1,6
2026-07-01,TUR,TRY,Turkey,240,40,6
2026-07-01,EUZ,EUR,Euro area,5.4,0.9,6
`;
    const d = bigMacDataset(csv, '2026-10-11');
    expect(d.countries.TR).toEqual({ ppp: 40, fx: 40, year: 2026, currency: 'TRY' });
    expect(d.countries.DE).toEqual({ ppp: 0.9, fx: 0.9, year: 2026, currency: 'EUR' });
    expect(d.countries.US!.ppp).toBe(1);
    expect(d.eur!.fx).toBe(0.9);
    expect(d.license).toMatch(/CC BY 4\.0/);
  });
  test('factor CSV: fx falls back to the bundled rate when the currency matches; errors at once', () => {
    const fb: PppDataset = { ...ds };
    const d = parseFactorCsv('region,factor,currency,fx\nTR,15,TRY,\nDE,0.7,EUR,0.92\nUS,1,USD,\nAF,13,AFN,\n', fb, 'f.csv');
    expect(d.countries.TR).toEqual({ ppp: 15, fx: 40, currency: 'TRY' });
    expect(d.countries.DE!.fx).toBe(0.92);
    expect(d.countries.US!.fx).toBe(1);
    expect(d.countries.AF!.fx).toBeUndefined();
    expect(() => parseFactorCsv('region,factor,currency\nTUR,0,tr\n')).toThrow(/region "TUR"/);
    expect(() => parseFactorCsv('region,factor,currency\nTR,0,tr\n')).toThrow(/currency.*factor/);
  });
});

describe('command', () => {
  test('applePoints: batched GET with include=territory -> region, currency, points', async () => {
    const urls: string[] = [];
    const fake = { asc: async (_m: string, url: string) => {
      urls.push(url);
      return { data: [
        { id: 'pp1', attributes: { customerPrice: '59.99' }, relationships: { territory: { data: { type: 'territories', id: 'TUR' } } } },
        { id: 'pp2', attributes: { customerPrice: '64.99' }, relationships: { territory: { data: { type: 'territories', id: 'TUR' } } } },
        { id: 'pp3', attributes: { customerPrice: '4.99' }, relationships: { territory: { data: { type: 'territories', id: 'USA' } } } }],
        included: [{ type: 'territories', id: 'TUR', attributes: { currency: 'TRY' } }, { type: 'territories', id: 'USA', attributes: { currency: 'USD' } }] };
    } };
    const m = await applePoints(fake as never, 'iap-1', ['TUR', 'USA']);
    expect(urls).toEqual(['/v2/inAppPurchases/iap-1/pricePoints?filter[territory]=TUR,USA&include=territory&fields[territories]=currency&limit=8000']);
    expect(m.get('TR')).toEqual({ currency: 'TRY', points: [59.99, 64.99] });
    expect(m.get('US')).toEqual({ currency: 'USD', points: [4.99] });
  });

  async function runIn(argv: string[]): Promise<{ out: string; dir: string }> {
    const dir = mkdtempSync(join(tmpdir(), 'ppp-'));
    const config = { app: { name: 'Example' }, apple: { bundleId: 'com.example.game' }, play: { packageName: 'com.example.game' },
      products: [{ id: P, type: 'non_consumable', usd: 2.99, listings: {} }] };
    const lines: string[] = [];
    const orig = console.log, write = process.stdout.write;
    const fetchOrig = globalThis.fetch;
    console.log = (...x: unknown[]) => { lines.push(x.join(' ')); };
    process.stdout.write = ((t: string) => { lines.push(String(t)); return true; }) as typeof process.stdout.write;
    globalThis.fetch = (() => { throw new Error('no network in tests'); }) as never;
    try {
      await run({ loaded: { config, root: dir, path: join(dir, 'storebound.config.ts'), resolve: (p: string) => pathResolve(dir, p) }, args: parseArgs(argv) } as never);
    } finally { console.log = orig; process.stdout.write = write; globalThis.fetch = fetchOrig; }
    return { out: lines.join('\n'), dir };
  }

  test('offline --dry --json: the documented shape, nothing written', async () => {
    const { out, dir } = await runIn(['--offline', '--dry', '--json', '--base', '4.99']);
    const j = JSON.parse(out.slice(out.indexOf('{')));
    expect(Object.keys(j)).toEqual(['source', 'base', 'floor', 'ceiling', 'options', 'online', 'rows', 'kept', 'skipped', 'diff', 'topMarkets', 'out', 'written']);
    expect(j.options).toEqual(PPP_DEFAULTS);
    expect(j.kept.find((r: { store: string; region: string }) => r.store === 'play' && r.region === 'DE')).toMatchObject({ currency: 'EUR', reason: 'high-income', price: 5.99 });
    expect(j.source).toMatchObject({ name: 'worldbank', license: 'CC BY 4.0' });
    expect(j.base).toEqual({ [P]: 4.99 });
    expect(j.written).toBe(false);
    expect(j.rows.find((r: { store: string; region: string }) => r.store === 'play' && r.region === 'US')).toMatchObject({ price: 4.99, factor: 1, usdEquivalent: 4.99 });
    expect(j.diff.every((d: { change: string }) => d.change === 'new')).toBe(true);
    expect(() => readFileSync(join(dir, 'store/prices-ppp.csv'))).toThrow();
  });
  test('offline write: the sheet parses back with the import parser', async () => {
    const { out, dir } = await runIn(['--offline', '--store', 'play', '--floor', '0.4']);
    const csv = readFileSync(join(dir, 'store/prices-ppp.csv'), 'utf8');
    const rows = parsePriceCsv(csv, { products: [P] });
    expect(rows.length).toBeGreaterThan(50);
    expect(rows.every(r => r.store === 'play')).toBe(true);
    expect(out).toMatch(/storebound prices import --csv store\/prices-ppp\.csv --dry/);
  });
  test('source file and bad bounds', async () => {
    const dir = mkdtempSync(join(tmpdir(), 'ppp-f-'));
    writeFileSync(join(dir, 'f.csv'), 'region,factor,currency,fx\nTR,16,TRY,40\n');
    await expect(runIn(['--offline', '--floor', '2', '--ceiling', '1'])).rejects.toThrow(/--min-ratio/);
    await expect(runIn(['--offline', '--min-ratio', '0.6', '--max-ratio', '0.5'])).rejects.toThrow(/--min-ratio/);
    await expect(runIn(['--offline', '--source', 'bigmac'])).rejects.toThrow(/--update-bigmac/);
    const { out } = await runIn(['--offline', '--dry', '--json', '--source', 'file', '--file', join(dir, 'f.csv'), '--store', 'play']);
    const j = JSON.parse(out.slice(out.indexOf('{')));
    expect(j.rows.map((r: { region: string }) => r.region)).toEqual(['TR', 'US']);
  });
});