// Generated, do not edit. sha256:1af8cbc83fbd3f045e8613c13a26b6a23e68ea741a3545d1ba4e3de41d66fee7
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';

const { sameSelection, selectionFromStored } = await import('../../client/wealth/selection.js');

describe('sameSelection: is dit hetzelfde?', () => {
  it('herkent dezelfde soort en dezelfde assets', () => {
    assert.equal(sameSelection({ kind: 'crypto' }, { kind: 'crypto' }), true);
    assert.equal(sameSelection({ assetIds: [1, 2] }, { assetIds: [1, 2] }), true);
  });

  it('ziet een andere volgorde als iets ánders', () => {
    assert.equal(sameSelection({ assetIds: [1, 2] }, { assetIds: [2, 1] }), false);
  });

  it('SCHEIDT EEN SOORT VAN EEN LIJST ASSETS, ook als die soort precies die assets bevat', () => {
    assert.equal(sameSelection({ kind: 'crypto' }, { assetIds: [1] }), false);
    assert.equal(sameSelection({ assetIds: [1] }, { kind: 'crypto' }), false);
  });

  it('behandelt null als een echte stand', () => {
    assert.equal(sameSelection(null, null), true);
    assert.equal(sameSelection(null, { kind: 'crypto' }), false);
    assert.equal(sameSelection({ kind: 'crypto' }, null), false);
  });
});

describe('selectionFromStored: wat er uit de voorkeuren komt', () => {
  it('leest de twee geldige vormen', () => {
    assert.deepEqual(selectionFromStored({ kind: 'metal' }), { kind: 'metal' });
    assert.deepEqual(selectionFromStored({ assetIds: [3, 4] }), { assetIds: [3, 4] });
  });

  it('MAAKT ER GETALLEN VAN, ook als er tekst opgeslagen stond', () => {
    assert.deepEqual(selectionFromStored({ assetIds: ['3', '4'] }), { assetIds: [3, 4] });
  });

  it('geeft null bij een lege of onbruikbare lijst', () => {
    assert.equal(selectionFromStored({ assetIds: [] }), null);
    assert.equal(selectionFromStored({ assetIds: ['x', null] }), null, 'niets dat een getal wordt');
  });

  it('houdt over wat wél een getal is', () => {
    assert.deepEqual(selectionFromStored({ assetIds: [3, 'x'] }), { assetIds: [3] });
  });

  it('GEEFT NULL BIJ ALLES WAT GEEN SELECTIE IS, in plaats van te struikelen', () => {
    for (const rommel of [null, undefined, 0, '', 'crypto', 42, [], { }, { assetIds: 'crypto' }])
      assert.equal(selectionFromStored(rommel), null, `bij ${JSON.stringify(rommel)}`);
  });

  it('laat de soort vóór de assets gaan als er allebei iets staat', () => {
    assert.deepEqual(selectionFromStored({ kind: 'crypto', assetIds: [1] }), { kind: 'crypto' });
  });
});

const { hiddenFromStored, hiddenAfterFilter, splitHidden, hiddenKindsFromStored, accountKindItems, accountKindOf, NO_ACCOUNT_KIND } =
  await import('../../client/wealth/selection.js');

describe('verborgen kaarten', () => {
  it('leest alleen positieve gehele ids terug', () => {
    assert.deepEqual([...hiddenFromStored([3, '5', null, 0, -1, 'x'])], [3, 5]);
    assert.equal(hiddenFromStored({ ids: [1] }).size, 0, 'geen lijst: niets verborgen');
  });

  it('laat bij accounts de 0 door, de kaart zonder account', () => {
    assert.deepEqual([...hiddenFromStored([0, 4, -1], { allowZero: true })], [0, 4]);
  });

  it('bewaart na de filterbalk wat uit staat, gesorteerd', () => {
    assert.deepEqual(hiddenAfterFilter(new Set(), [1, 2, 3], new Set([1, 3])), [2]);
    assert.deepEqual(hiddenAfterFilter(new Set([2]), [1, 2, 3], new Set([1, 2, 3])), [], 'weer aan is weer zichtbaar');
  });

  it('houdt een verborgen id zonder chip vast, zodat een andere periode hem niet terugzet', () => {
    assert.deepEqual(hiddenAfterFilter(new Set([9, 2]), [1, 2], new Set([1])), [2, 9]);
  });

  it('verdeelt de kaarten in twee stapels die samen alles zijn, in de oorspronkelijke volgorde', () => {
    const k = id => ({ asset: { id } });
    const { shown, hidden } = splitHidden([k(1), k(2), k(3)], new Set([2]));
    assert.deepEqual(shown.map(x => x.asset.id), [1, 3]);
    assert.deepEqual(hidden.map(x => x.asset.id), [2]);
  });

  it('filtert per account op soort, met de kaart zonder account als eigen soort', () => {
    const kaarten = [{ account: { kind: 'exchange' } }, { account: { kind: 'wallet' } }, { account: { kind: 'exchange' } }, { account: null }];
    assert.deepEqual(accountKindItems(kaarten), ['exchange', 'wallet', NO_ACCOUNT_KIND], 'elke soort één keer, in de volgorde van de kaarten');
    const verborgen = hiddenKindsFromStored(['wallet', 'verdwenen', 7, NO_ACCOUNT_KIND], ['exchange', 'wallet']);
    assert.deepEqual([...verborgen].sort(), [NO_ACCOUNT_KIND, 'wallet']);
    const { shown } = splitHidden(kaarten, verborgen, accountKindOf);
    assert.equal(shown.length, 2, 'alleen de twee exchanges blijven staan');
    assert.deepEqual(hiddenAfterFilter(new Set(['wallet']), ['exchange', 'wallet'], new Set(['wallet'])), ['exchange'],
      'een soort weer aan is weer zichtbaar, een andere uit');
  });

  it('splitst accountkaarten op hun eigen sleutel', () => {
    const c = id => ({ accountId: id });
    const { shown } = splitHidden([c(10), c(null)], new Set([0]), x => x.accountId ?? 0);
    assert.deepEqual(shown.map(x => x.accountId), [10]);
  });
});

describe('selectie van een accountkaart', () => {
  it('leest het account terug, ook de kaart zonder account en zonder assets', () => {
    assert.deepEqual(selectionFromStored({ account: 7, assetIds: [1] }), { account: 7, assetIds: [1] });
    assert.deepEqual(selectionFromStored({ account: 0, assetIds: [] }), { account: 0, assetIds: [] });
    assert.equal(selectionFromStored({ account: -1, assetIds: [] }), null);
  });

  it('ziet twee accounts met dezelfde assets als twee selecties', () => {
    assert.equal(sameSelection({ account: 1, assetIds: [5] }, { account: 2, assetIds: [5] }), false);
    assert.equal(sameSelection({ account: 1, assetIds: [5] }, { account: 1, assetIds: [5] }), true);
    assert.equal(sameSelection({ account: 1, assetIds: [5] }, { assetIds: [5] }), false);
  });
});