/**
 * The Parametric EQ (#367): up to ten bands on one node, compiled to filters in a row, and the curve
 * the editor draws from them.
 */
import { describe, expect, it } from 'vitest';
import { CreateAssetCommand } from '../../src/core/commands/assetCommands';
import type { BehaviorAsset, SoundFxAsset } from '../../src/core/model/Asset';
import { compileSoundFx } from '../../src/core/soundfx/compile';
import { fxChainOf } from '../../src/core/soundfx/nodes';
import {
  type EqBand,
  eqBandDb,
  eqBandsOf,
  eqCurves,
  MAX_EQ_BANDS,
  withBandSet,
} from '../../src/core/soundfx/parametricEq';
import { fillShapes } from '../../src/editor/soundfx/eqView';
import { graphEditor, makeProject, roundTrip } from '../helpers';

const band = (change: Partial<EqBand>): EqBand => ({
  type: 'peaking',
  frequency: 1000,
  gain: 0,
  q: 1,
  slope: 12,
  ...change,
});

function eqLine(bands: unknown) {
  const f = makeProject();
  const command = new CreateAssetCommand('soundfx', 'EQ');
  f.stack.execute(command);
  const fx = command.asset as SoundFxAsset;
  const edit = graphEditor(f, fx as unknown as BehaviorAsset);
  const input = edit.addNode('SoundFxInput');
  const eq = edit.addNode('SoundFxParametricEq');
  eq.params.bands = bands as never;
  const output = edit.addNode('SoundFxOutput');
  edit.connect(input, 'out', eq, 'in');
  edit.connect(eq, 'out', output, 'in');
  return { ...f, fx };
}

describe('the bands of a Parametric EQ', () => {
  it('are held to what the editor offers, at most ten of them', () => {
    const bands = eqBandsOf({
      bands: [
        { type: 'lowpass', frequency: 99999, gain: 3, q: 0, slope: 24 },
        { type: 'allpass', frequency: 5, gain: -99, q: 'x', slope: 7 },
        'not a band',
        ...Array.from({ length: 12 }, () => ({ type: 'peaking', frequency: 500 })),
      ],
    });
    expect(bands).toHaveLength(MAX_EQ_BANDS);
    expect(bands[0]).toEqual({ type: 'lowpass', frequency: 20000, gain: 3, q: 0.1, slope: 24 });
    expect(bands[1]).toEqual({ type: 'peaking', frequency: 20, gain: -24, q: Math.SQRT1_2, slope: 12 });
    expect(eqBandsOf({})).toEqual([]);
    expect(withBandSet([band({})], 0, { gain: 40 })[0]!.gain).toBe(24);
  });

  it('compile to one filter each, a steeper cut to more, and a flat peak to none', () => {
    const f = eqLine([
      band({ gain: 6 }),
      band({ type: 'highpass', frequency: 80, q: Math.SQRT1_2, slope: 24 }),
      band({ type: 'lowshelf', frequency: 200, gain: 0 }),
    ]);
    const build = compileSoundFx(f.fx.graph);
    expect(build.effects).toBe(1);
    expect(fxChainOf(build.compiled!).stages).toEqual([
      { kind: 'pass', filter: 'peaking', stages: 1, cutoff: 1000, q: 1, gain: 6 },
      { kind: 'pass', filter: 'highpass', stages: 2, cutoff: 80, q: 20 * Math.log10(Math.SQRT1_2), gain: 0 },
    ]);
    expect(roundTrip(f.project)).toEqual(f.project);
  });

  it('draw the curve Web Audio plays', () => {
    const peak = band({ gain: 6 });
    expect(eqBandDb(peak, 1000)).toBeCloseTo(6, 3);
    expect(Math.abs(eqBandDb(peak, 20))).toBeLessThan(0.1);

    // A cut with no bump is 3 dB down at its frequency and falls 12 dB an octave below it.
    const cut = band({ type: 'highpass', frequency: 200, q: Math.SQRT1_2 });
    expect(eqBandDb(cut, 200)).toBeCloseTo(-3.01, 1);
    expect(eqBandDb(cut, 50) - eqBandDb(cut, 25)).toBeCloseTo(12, 0);
    const steeper = { ...cut, slope: 48 as const };
    expect(eqBandDb(steeper, 50) - eqBandDb(steeper, 25)).toBeCloseTo(48, 0);

    const shelf = band({ type: 'lowshelf', frequency: 200, gain: 6 });
    expect(eqBandDb(shelf, 20)).toBeCloseTo(6, 1);
    expect(eqBandDb(shelf, 200)).toBeCloseTo(3, 1);
    expect(eqBandDb(band({ type: 'notch' }), 1000)).toBeLessThan(-60);

    // Together they add up in dB; a band that does nothing is drawn but not counted.
    const flat = band({ type: 'peaking', frequency: 300, gain: 0 });
    const curves = eqCurves([peak, flat, shelf], [300, 3000]);
    expect(curves.bands[1]).toHaveLength(2);
    expect(curves.bands[2]![0]).toBeCloseTo(eqBandDb(shelf, 300), 6);
    expect(curves.sum[0]).toBeCloseTo(eqBandDb(peak, 300) + eqBandDb(shelf, 300), 6);
    expect(curves.sum[1]).toBeCloseTo(eqBandDb(peak, 3000) + eqBandDb(shelf, 3000), 6);
  });

  it('fills a curve that crosses 0 dB with one shape for each side, meeting on the line', () => {
    // From 10 above the line at y 50 to 10 below and back: it crosses twice, at x 15 and x 45.
    const shapes = fillShapes([0, 10, 20, 30, 40, 50, 60], [40, 40, 60, 60, 60, 40, 40], 50);
    expect(shapes).toEqual([
      [0, 50, 0, 40, 10, 40, 15, 50],
      [15, 50, 20, 60, 30, 60, 40, 60, 45, 50],
      [45, 50, 50, 40, 60, 40, 60, 50],
    ]);
    // On one side all along it stays one shape.
    expect(fillShapes([0, 10, 20], [40, 30, 40], 50)).toEqual([[0, 50, 0, 40, 10, 30, 20, 40, 20, 50]]);
  });
});