import assert from 'node:assert/strict';
import test from 'node:test';
import { collectPads } from '../src/lib/parsers';
import abletonTransformer from '../src/lib/transformers/ableton';
import dawProjectTransformer from '../src/lib/transformers/dawProject';
import midiTransformer from '../src/lib/transformers/midi';
import reaperTransformer from '../src/lib/transformers/reaper';
import { TarFile } from '../src/lib/untar';
import {
  EffectType,
  FaderParam,
  Group,
  GroupFaderParam,
  ProjectRawData,
} from '../src/types/types';
import { findPad } from '../src/lib/utils';

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', () => {
  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 };
  assert.deepEqual(
    abletonTransformer(data, params).tracks.map((track) => track.padCode),
    ['a1'],
  );
  assert.deepEqual(
    midiTransformer(data, params).tracks.map((track) => track.padCode),
    ['a1'],
  );
  assert.deepEqual(
    reaperTransformer(data, params).tracks.map((track) => track.padCode),
    ['a1'],
  );
  assert.deepEqual(
    dawProjectTransformer(data, params).tracks.map((track) => track.padCode),
    ['a1'],
  );
});