/**
 * render-svg.test — pure inline-SVG builders: accessibility hooks, token-driven
 * classes, zero-total safety, determinism.
 */
import { describe, it, expect } from 'vitest';
import { barsSvg, donutSvg, type BandBar, type DonutSegment } from '../render-svg.js';

const SEGMENTS: DonutSegment[] = [
  { label: 'passed', count: 12, cssClass: 'seg-pass' },
  { label: 'failed', count: 3, cssClass: 'seg-fail' },
  { label: 'skipped', count: 5, cssClass: 'seg-skip' },
];

const BANDS: BandBar[] = [
  { label: '< 500 ms', count: 9, cssClass: 'band-fast' },
  { label: '< 1000 ms', count: 4, cssClass: 'band-ok' },
  { label: '< 3000 ms', count: 2, cssClass: 'band-warn' },
  { label: '≥ 3000 ms', count: 1, cssClass: 'band-slow' },
];

describe('donutSvg', () => {
  it('emits an accessible svg with one ring segment per non-zero count', () => {
    const svg = donutSvg(SEGMENTS, '80%', 'API checks');
    expect(svg).toMatch(/^<svg /);
    expect(svg).toContain('role="img"');
    expect(svg).toContain('<title>API checks</title>');
    expect(svg).toContain('aria-label="API checks — passed 12 · failed 3 · skipped 5"');
    expect(svg).toContain('class="seg-pass"');
    expect(svg).toContain('class="seg-fail"');
    expect(svg).toContain('class="seg-skip"');
    expect(svg).toContain('>80%</text>');
  });

  it('skips zero-count segments and survives an all-zero total without NaN', () => {
    const svg = donutSvg(
      [
        { label: 'passed', count: 0, cssClass: 'seg-pass' },
        { label: 'failed', count: 0, cssClass: 'seg-fail' },
      ],
      '—',
      'Empty',
    );
    expect(svg).not.toContain('NaN');
    expect(svg).not.toContain('seg-pass'); // no segment ring, only the track
    expect(svg).toContain('seg-track');
  });

  it('escapes hostile labels', () => {
    const svg = donutSvg([{ label: '<script>', count: 1, cssClass: 'seg-pass"' }], '<b>', 'x"y');
    expect(svg).not.toContain('<script>');
    expect(svg).toContain('&lt;script&gt;');
    expect(svg).toContain('&lt;b&gt;');
  });

  it('is deterministic (same input ⇒ same bytes)', () => {
    expect(donutSvg(SEGMENTS, '80%', 'API checks')).toBe(donutSvg(SEGMENTS, '80%', 'API checks'));
  });
});

describe('barsSvg', () => {
  it('emits one labeled bar per band with proportional integer widths', () => {
    const svg = barsSvg(BANDS, 'API latency');
    expect(svg).toContain('role="img"');
    expect(svg).toContain('<title>API latency</title>');
    for (const band of BANDS) {
      expect(svg).toContain(`class="${band.cssClass}"`);
    }
    // Max count (9) gets the full width; the count text is rendered.
    expect(svg).toContain('width="260"');
    expect(svg).toContain('>9</text>');
  });

  it('an all-zero distribution renders hairline bars, never NaN', () => {
    const svg = barsSvg(
      [
        { label: 'a', count: 0, cssClass: 'band-fast' },
        { label: 'b', count: 0, cssClass: 'band-ok' },
      ],
      'Empty',
    );
    expect(svg).not.toContain('NaN');
    expect(svg).toContain('width="1"');
  });

  it('is deterministic', () => {
    expect(barsSvg(BANDS, 'API latency')).toBe(barsSvg(BANDS, 'API latency'));
  });
});