import { REPORT_KEYS } from '../../seed/freight-permissions.registry';
import { REPORTS, getReport } from './report.registry';

describe('REPORTS', () => {
  it('has exactly one definition per seeded REPORT_KEYS entry', () => {
    const defKeys = REPORTS.map((r) => r.key).sort();
    expect(defKeys).toEqual([...REPORT_KEYS].sort());
  });

  it('has no duplicate keys', () => {
    const keys = REPORTS.map((r) => r.key);
    expect(new Set(keys).size).toBe(keys.length);
  });

  it('resolves every key via getReport', () => {
    for (const key of REPORT_KEYS) {
      expect(getReport(key)?.key).toBe(key);
    }
  });

  it('every sortable column and defaultSort point at a real column key', () => {
    for (const def of REPORTS) {
      const columnKeys = new Set(def.columns.map((c) => c.key));
      if (def.defaultSort) {
        expect(columnKeys.has(def.defaultSort.key)).toBe(true);
      }
      // Every column marked sortable must have a resolvable key (itself, since
      // the runner falls back to `key` when `sortExpr` is absent).
      for (const col of def.columns.filter((c) => c.sortable)) {
        expect(col.key.length).toBeGreaterThan(0);
      }
    }
  });

  it('idKey, when declared, is not also listed as a user-facing filter', () => {
    for (const def of REPORTS) {
      if (!def.idKey) continue;
      expect(def.filters.some((f) => f.key === def.idKey!.key)).toBe(false);
    }
  });

  it('chart.x and chart.y, when declared, point at real column keys', () => {
    for (const def of REPORTS) {
      if (!def.chart) continue;
      const columnKeys = new Set(def.columns.map((c) => c.key));
      expect(columnKeys.has(def.chart.x)).toBe(true);
      for (const y of def.chart.y) {
        expect(columnKeys.has(y)).toBe(true);
      }
    }
  });
});