import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { describe, expect, it } from 'vitest';
import {
  DYNAMIC_ALLOWED,
  MAX_IMPLICIT_MATCHES,
  countMatches,
  evaluate,
  firstArgument,
  interpolationResults,
  readEnKeys,
  scanSource,
  scanTree,
  templatePattern,
} from '../../../scripts/i18n-keys.mjs';

// FE-I18N-KEYS-001 to FE-I18N-KEYS-015: the client key check (scripts/i18n-keys.mjs).

const EN = new Set([
  'budget.title',
  'places.count',
  'places.count.one',
  'trips.total.other',
  'trips.total.one',
  'costs.filter.all',
]);

describe('i18n key check', () => {
  it('FE-I18N-KEYS-001: finds literal keys in t, tHtml, tr, TransHtml, translateApiError and *Key props', () => {
    const { literal } = scanSource(
      [
        "t('budget.title')",
        'props.t("places.count", { count })',
        "tHtml('a.html')",
        "tr('pdf.mapTitle')",
        '<TransHtml html="journey.text" />',
        "translateApiError(t, err, 'files.uploadError')",
        "const tabs = [{ labelKey: 'tabs.one' }]",
        '<Hint titleKey="hint.title" />',
      ].join('\n')
    );
    expect(literal.map((l) => l.key)).toEqual([
      'budget.title',
      'places.count',
      'a.html',
      'pdf.mapTitle',
      'journey.text',
      'files.uploadError',
      'tabs.one',
      'hint.title',
    ]);
  });

  it('FE-I18N-KEYS-002: checks both sides of a conditional key and ignores later arguments', () => {
    const { literal } = scanSource("t(open ? 'a.open' : 'a.closed', { name: 'x.y' })");
    expect(literal.map((l) => l.key)).toEqual(['a.open', 'a.closed']);
    expect(firstArgument("t(fn(a, b) ? 'x.y' : 'z.w', 1)", 1)).toBe("fn(a, b) ? 'x.y' : 'z.w'");
  });

  it('FE-I18N-KEYS-003: reads templates, appended prefixes and key builders as patterns', () => {
    const { literal, dynamic } = scanSource(
      [
        't(`costs.filter.${f}`)',
        "t('costs.filter.' + f)",
        't(`plain.key`)',
        'export const guideKey = (id: string): string =>\n  `help.guide.${id}.title`',
        'const cacheKey = (id: number): string => `${id} x`',
        "const other = notATranslation('x.y')",
      ].join('\n')
    );
    expect(literal.map((l) => l.key)).toEqual(['plain.key']);
    expect(dynamic.map((d) => d.template)).toEqual([
      'costs.filter.${f}',
      'costs.filter.${…}',
      'help.guide.${id}.title',
    ]);
    expect(templatePattern('costs.filter.${f}')!.test('costs.filter.all')).toBe(true);
    expect(templatePattern('${opt.label}Hint')).toBeNull();
    // An interpolation is one key segment: costs.filter.${f} does not reach a nested costs.filter.x.y.
    expect(templatePattern('costs.filter.${f}')!.test('costs.filter.x.y')).toBe(false);
  });

  it('FE-I18N-KEYS-004: fails a literal key en lacks and accepts a plural group by its general form', () => {
    const scan = scanSource("t('budget.addCategory'); t('places.count', { count }); t('trips.total', { count })");
    const { missing } = evaluate(scan, EN, []);
    expect(missing.map((m) => m.key)).toEqual(['budget.addCategory']);
  });

  it('FE-I18N-KEYS-005: fails a template no en key matches unless it is allowed with the keys it resolves to', () => {
    const scan = scanSource('t(`costs.filter.${f}`); t(`gone.prefix.${x}`); t(`${opt.label}Hint`)');
    expect(evaluate(scan, EN, []).unmatched.map((u) => u.template)).toEqual(['gone.prefix.${x}', '${opt.label}Hint']);
    const allowed = [{ file: '<source>', template: '${opt.label}Hint', because: 'test', resolves: ['budget.title'] }];
    const result = evaluate(scan, EN, allowed);
    expect(result.unmatched.map((u) => u.template)).toEqual(['gone.prefix.${x}']);
    expect(result.stale).toEqual([]);
  });

  it('FE-I18N-KEYS-006: refuses an allow-list entry nothing uses or whose keys en lacks', () => {
    const scan = scanSource('t(`${opt.label}Hint`)');
    const unused = [{ file: '<source>', template: '${gone}', because: 'test', resolves: ['budget.title'] }];
    expect(evaluate(scan, EN, unused).stale).toEqual(unused);
    const wrong = [{ file: '<source>', template: '${opt.label}Hint', because: 'test', resolves: ['share.nope'] }];
    expect(evaluate(scan, EN, wrong).stale).toEqual(wrong);
    const elsewhere = [
      { file: 'other.tsx', template: '${opt.label}Hint', because: 'test', resolves: ['budget.title'] },
    ];
    expect(evaluate(scan, EN, elsewhere).stale).toEqual(elsewhere);
    expect(evaluate(scan, EN, elsewhere).unmatched.map((u) => u.template)).toEqual(['${opt.label}Hint']);
  });

  it('FE-I18N-KEYS-007: reports en keys neither a literal nor a pattern reaches', () => {
    const scan = scanSource("t('budget.title'); t('places.count', { count }); t(`costs.filter.${f}`)");
    expect(evaluate(scan, EN, []).unused).toEqual(['trips.total.other', 'trips.total.one']);
  });

  it('FE-I18N-KEYS-008: every allow-list entry names its file and a reason, and a prefix-less one its keys', () => {
    for (const entry of DYNAMIC_ALLOWED) {
      expect(entry.file).toMatch(/\.tsx?$/);
      expect(entry.because.length).toBeGreaterThan(20);
      if (templatePattern(entry.template) === null)
        expect('resolves' in entry && entry.resolves.length).toBeGreaterThan(0);
    }
  });

  it('FE-I18N-KEYS-009: fails closed on a missing source tree or one without any key', () => {
    expect(() => scanTree(join(tmpdir(), 'trek-i18n-keys-does-not-exist'))).toThrow(/does not exist/);
    const empty = mkdtempSync(join(tmpdir(), 'trek-i18n-keys-'));
    try {
      expect(() => scanTree(empty)).toThrow(/scanner is broken/);
    } finally {
      rmSync(empty, { recursive: true, force: true });
    }
  });

  it('FE-I18N-KEYS-010: the client source names no key en lacks today', async () => {
    const enKeys = await readEnKeys();
    const { missing, unmatched, broad, stale } = evaluate(scanTree(), enKeys);
    expect(missing).toEqual([]);
    expect(unmatched).toEqual([]);
    expect(broad).toEqual([]);
    expect(stale).toEqual([]);
  });

  // A table of en keys wider than the implicit bound: wide.k0 to wide.k<MAX>.
  const WIDE = new Set([...EN, ...Array.from({ length: MAX_IMPLICIT_MATCHES + 1 }, (_, i) => `wide.k${i}`)]);

  it('FE-I18N-KEYS-011: counts a plural group once when measuring what a template reaches', () => {
    expect(countMatches(templatePattern('trips.${x}')!, EN)).toBe(1);
    expect(countMatches(templatePattern('wide.${x}')!, WIDE)).toBe(MAX_IMPLICIT_MATCHES + 1);
  });

  it('FE-I18N-KEYS-012: fails a template wider than the bound unless its file has an entry for it', () => {
    const scan = scanSource('t(`wide.${x}`); t(`costs.filter.${f}`)', 'a.tsx');
    const { broad, unmatched } = evaluate(scan, WIDE, []);
    expect(broad.map((b) => [b.template, b.matches])).toEqual([['wide.${x}', MAX_IMPLICIT_MATCHES + 1]]);
    expect(unmatched).toEqual([]);
    const otherFile = [{ file: 'b.tsx', template: 'wide.${x}', because: 'test' }];
    expect(evaluate(scan, WIDE, otherFile).broad).toHaveLength(1);
    const ownFile = [{ file: 'a.tsx', template: 'wide.${x}', because: 'test' }];
    expect(evaluate(scan, WIDE, ownFile)).toMatchObject({ broad: [], stale: [] });
  });

  it('FE-I18N-KEYS-013: refuses an entry for a narrow template, and an allowed template that matches nothing', () => {
    const scan = scanSource('t(`costs.filter.${f}`); t(`gone.prefix.${x}`)', 'a.tsx');
    const narrow = [{ file: 'a.tsx', template: 'costs.filter.${f}', because: 'test' }];
    expect(evaluate(scan, EN, narrow).stale).toEqual(narrow);
    const gone = [{ file: 'a.tsx', template: 'gone.prefix.${x}', because: 'test' }];
    expect(evaluate(scan, EN, gone).unmatched.map((u) => u.template)).toEqual(['gone.prefix.${x}']);
  });

  it('FE-I18N-KEYS-014: checks each literal branch of a template as a key, so a typo in one fails', () => {
    const scan = scanSource("t(`costs.filter.${on ? 'all' : 'alll'}`)", 'a.tsx');
    expect(scan.dynamic).toEqual([]);
    expect(scan.literal.map((l) => l.key)).toEqual(['costs.filter.all', 'costs.filter.alll']);
    expect(evaluate(scan, EN, []).missing.map((m) => m.key)).toEqual(['costs.filter.alll']);
    // Nested ternaries, parentheses and optional chaining in the condition; a literal in a comparison is no result.
    expect(interpolationResults("(a?.b === 'x') ? 'p' : c ? ('q') : 'r'")).toEqual({
      literals: ['p', 'q', 'r'],
      complete: true,
    });
    expect(interpolationResults("fn('a.b')")).toEqual({ literals: [], complete: false });
  });

  it('FE-I18N-KEYS-015: keeps a template with data in it a pattern and still checks its literal fallback', () => {
    const scan = scanSource("t(`costs.filter.${role ?? 'nope'}`); t(`budget.${p === 'x' ? 'title' : p}`)", 'a.tsx');
    expect(scan.dynamic.map((d) => d.template)).toEqual([
      "costs.filter.${role ?? 'nope'}",
      "budget.${p === 'x' ? 'title' : p}",
    ]);
    expect(scan.literal.map((l) => l.key)).toEqual(['costs.filter.nope', 'budget.title']);
    expect(evaluate(scan, EN, []).missing.map((m) => m.key)).toEqual(['costs.filter.nope']);
    // A derived pattern is judged under its source template's allow-list entry.
    const two = scanSource("t(`wide.${a ?? 'k0'}.${b}`)", 'a.tsx');
    expect(two.dynamic.map((d) => d.site)).toEqual([undefined, "wide.${a ?? 'k0'}.${b}"]);
  });
});