import assert from 'node:assert/strict';
import test from 'node:test';
import { createServer } from 'vite';
import { collectPads } from '../src/lib/parsers';
import { TarFile } from '../src/lib/untar';
import { findPad } from '../src/lib/utils';
import { EffectType, FaderParam, Group, GroupFaderParam, ProjectRawData } from '../src/types/types';

function faderParams(): GroupFaderParam {
  return Object.fromEntries(
    (['a', 'b', 'c', 'd'] as Group[]).map((group) => [
      group,
      Object.fromEntries(Array.from({ length: 12 }, (_, parameter) => [parameter, -1])),
    ]),
  ) as GroupFaderParam;
}

function sparseProject(): ProjectRawData {
  const rawPad = new Uint8Array(27);
  rawPad[1] = 202;
  rawPad[16] = 100;
  rawPad[20] = 255;
  rawPad[24] = 60;
  const pads = collectPads([new TarFile('pads/a/p02', rawPad.length, rawPad)], []);
  const params = faderParams();

  return {
    pads,
    groupPatterns: [],
    scenes: [
      {
        number: 1,
        name: '01',
        patternNumbers: { a: 0, b: 0, c: 0, d: 0 },
        timeSignature: { numerator: 4, denominator: 4 },
        patterns: [],
        patternEvents: {},
      },
    ],
    songPositions: [],
    settings: {
      bpm: 120,
      scale: 0,
      rootNote: 0,
      groupFaderParams: params,
      faderAssignment: {
        a: FaderParam.LVL,
        b: FaderParam.LVL,
        c: FaderParam.LVL,
        d: FaderParam.LVL,
      },
      rawData: new Uint8Array(),
    },
    effects: {
      rawData: new Uint8Array(),
      effectType: EffectType.Off,
      param1: 0,
      param2: 0,
    },
    sounds: [],
    projectFile: {} as File,
    scenesSettings: { timeSignature: { numerator: 4, denominator: 4 } },
  };
}

test('keeps physical p02 on zero-based pattern source 1 when p01 is omitted', async () => {
  const data = sparseProject();
  const physicalPad = data.pads.a[0];

  assert.equal(physicalPad.pad, 2);
  assert.equal(findPad('a0', data.pads), undefined);
  assert.equal(findPad('a1', data.pads), physicalPad);

  const params = { exportAllPadsWithSamples: true, keepUnusedPatterns: false };
  const server = await createServer({
    server: { middlewareMode: true },
    appType: 'custom',
    mode: 'production',
    define: { 'import.meta.env.DEV': 'false' },
  });

  try {
    const [abletonModule, midiModule, reaperModule, dawProjectModule, webViewModule] =
      await Promise.all([
        server.ssrLoadModule('/src/lib/transformers/ableton.ts'),
        server.ssrLoadModule('/src/lib/transformers/midi.ts'),
        server.ssrLoadModule('/src/lib/transformers/reaper.ts'),
        server.ssrLoadModule('/src/lib/transformers/dawProject.ts'),
        server.ssrLoadModule('/src/lib/transformers/webView.ts'),
      ]);

    assert.deepEqual(
      abletonModule.default(data, params).tracks.map((track: { padCode: string }) => track.padCode),
      ['a1'],
    );
    assert.deepEqual(
      midiModule.default(data, params).tracks.map((track: { padCode: string }) => track.padCode),
      ['a1'],
    );
    assert.deepEqual(
      reaperModule.default(data, params).tracks.map((track: { padCode: string }) => track.padCode),
      ['a1'],
    );
    assert.deepEqual(
      dawProjectModule.default(data, params).tracks.map((track: { padCode: string }) => track.padCode),
      ['a1'],
    );
    assert.deepEqual(
      webViewModule.default(data).scenes[0].patterns.map((pattern: { pad: string }) => pattern.pad),
      ['a1'],
    );
  } finally {
    await server.close();
  }
});