// Generated, do not edit. sha256:992d8ca6dcf32528e84e3de9e67ad72a7550a9fbea3e6b15efe619915b129368
import { describe, it, beforeEach, mock } from 'node:test';
import assert from 'node:assert/strict';

import { createDbHarness } from '../helpers/db-node.mjs';
import {
  VERMOGENSCATEGORIE, CATEGORIE_PER_ASSET_KIND, categorieGekozen, categorieVoor, categorieVoorAsset, reikwijdteVoor,
} from '../../client/tax/constants.js';
import { ENUMS } from '../../shared/config.js';

const harness = createDbHarness();
mock.module('../../server/db.js', { namedExports: harness.exports });

let liveSpot = null;
mock.module('../../client/price/providers.js', {
  namedExports: {
    ensurePriceHistoryFor: async () => {},
    ensurePointsAtFor: async () => {},
    liveSpotPriceFor: async () => liveSpot,
    lastSpotSource: () => (liveSpot != null ? 'Spotbron' : null),
  },
});

for (const mod of ['accounts', 'assets', 'events', 'positions', 'preferences', 'price-history', 'providers', 'valuations']) {
  mock.module(`../../client/data/${mod}.js`, { namedExports: await import(`../../server/data/${mod}.js`) });
}

const { setPref } = await import('../../server/data/preferences.js');

const wealth = await import('../../client/wealth/data.js');

const HUIDIG_JAAR = new Date().getFullYear();

let btc, acc;
beforeEach(() => {
  harness.recreate();
  testProviderId = null;
  liveSpot = null;
  harness.exports.run(
    `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit) VALUES ('BTC','Bitcoin','bitcoin','crypto','BTC','sat',8,'unit')`);
  btc = harness.exports.lastId();
  harness.exports.run(
    `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt) VALUES ('Kluis','kluis','vault',1,0,1,NULL)`);
  acc = harness.exports.lastId();
});

function koop({ sats, fiatPrice, at, fiatFee = null, priceOrigin = null }) {
  harness.exports.run(
    `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, fiatFee, priceOrigin, toAccountId, source, createdAt)
     VALUES (?, 'buy', ?, ?, ?, ?, ?, ?, 'manual', ?)`,
    [btc, at, sats, fiatPrice, fiatFee, priceOrigin, acc, at]);
}
function verkoop({ sats, fiatPrice, at, fiatFee = null, priceOrigin = null }) {
  harness.exports.run(
    `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, fiatFee, priceOrigin, fromAccountId, source, createdAt)
     VALUES (?, 'sell', ?, ?, ?, ?, ?, ?, 'manual', ?)`,
    [btc, at, sats, fiatPrice, fiatFee, priceOrigin, acc, at]);
}
let testProviderId = null;
function testProvider() {
  if (testProviderId === null) {
    harness.exports.run(
      `INSERT INTO Provider (key, name, searchName, baseUrl, authenticationKind, authenticationRequired,
                             isActive, isSeed, isSystem, createdAt)
       VALUES ('test','test','test','','none',0,1,1,0,'2024-01-01T00:00:00Z')`);
    testProviderId = harness.exports.lastId();
    for (const symbool of ['BTC', 'EUR', 'XAU'])
      harness.exports.run(`INSERT INTO ProviderCoverage (providerId, symbol) VALUES (?,?)`,
        [testProviderId, symbool]);
  }
  return testProviderId;
}
function koersPerBtc(datum, eur) {
  harness.exports.run(
    `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, updatedAt)
     VALUES (?,?, 'day', ?, ?, ?)`, [btc, `${datum}T00:00:00Z`, eur, testProvider(), `${datum}T00:00:00Z`]);
}
const jaarRij = (model, jaar) => model.perJaar.find(b => b.year === jaar);
const aanwasRij = (model, jaar) => model.aanwas.find(a => a.year === jaar);

describe('buildWealthModel: de herkomst van een cel', () => {
  function tweedeBron() {
    harness.exports.run(
      `INSERT INTO Provider (key, name, searchName, baseUrl, authenticationKind, authenticationRequired,
                             isActive, isSeed, isSystem, createdAt)
       VALUES ('tweede','Tweede','tweede','','none',0,1,1,0,'2024-01-01T00:00:00Z')`);
    const id = harness.exports.lastId();
    harness.exports.run(`INSERT INTO ProviderCoverage (providerId, symbol) VALUES (?, 'BTC')`, [id]);
    return id;
  }
  function slotkoers(datum, eur, providerId = testProvider()) {
    harness.exports.run(
      `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, createdAt)
       VALUES (?,?, 'day', ?, ?, '2026-01-15T00:00:00Z')`, [btc, `${datum}T00:00:00Z`, eur, providerId]);
  }

  it('noemt de soort, de bron en de dag van de koers op een peildatum', async () => {
    koop({ sats: 1e8, fiatPrice: 40000, at: '2024-06-01T00:00:00Z' });
    slotkoers('2025-01-01', 90000);
    const cel = (await wealth.buildWealthModel()).rows[0].perYear[2025];
    assert.equal(cel.price, 90000);
    assert.deepEqual({ kind: cel.origin.kind, source: cel.origin.source, day: cel.origin.day, fiatPrice: cel.origin.fiatPrice },
      { kind: 'close', source: 'test', day: '2025-01-01', fiatPrice: 90000 });
  });

  it('noemt een doorgetrokken koers met zijn brondag en leeftijd', async () => {
    koop({ sats: 1e8, fiatPrice: 40000, at: '2024-06-01T00:00:00Z' });
    slotkoers('2024-12-29', 88000);
    const cel = (await wealth.buildWealthModel()).rows[0].perYear[2025];
    assert.equal(cel.origin.kind, 'carried');
    assert.equal(cel.origin.sourceDay, '2024-12-29');
    assert.equal(cel.origin.ageDays, 3);
  });

  it('heeft geen herkomst zonder koers, en ook niet bij een positie van nul', async () => {
    koop({ sats: 1e8, fiatPrice: 40000, at: '2024-06-01T00:00:00Z' });
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[2025].price, null);
    assert.equal(m.rows[0].perYear[2025].origin, null);
  });

  it('geeft ook de stand van nu (het dashboard) een herkomst, met de bron van een live spot', async () => {
    koop({ sats: 1e8, fiatPrice: 40000, at: '2024-06-01T00:00:00Z' });
    slotkoers('2025-01-01', 90000);
    const zonderSpot = (await wealth.currentStanding()).rows[0].origin;
    assert.equal(zonderSpot.kind, 'carried', 'de laatste koers, doorgetrokken tot vandaag');
    assert.equal(zonderSpot.source, 'test');
    liveSpot = 95000;
    const metSpot = (await wealth.currentStanding()).rows[0].origin;
    assert.deepEqual({ kind: metSpot.kind, fiatPrice: metSpot.fiatPrice, source: metSpot.source }, { kind: 'live', fiatPrice: 95000, source: 'Spotbron' });
  });

  it('beschrijft bij twee bronnen op één dag de koers die gebruikt is', async () => {
    koop({ sats: 1e8, fiatPrice: 40000, at: '2024-06-01T00:00:00Z' });
    slotkoers('2025-01-01', 90000);
    slotkoers('2025-01-01', 91000, tweedeBron());
    const cel = (await wealth.buildWealthModel()).rows[0].perYear[2025];
    assert.equal(cel.origin.fiatPrice, cel.price, 'de herkomst beschrijft hetzelfde getal als de cel');
    assert.equal(cel.origin.source, cel.price === 90000 ? 'test' : 'Tweede');
  });
});

describe('buildWealthModel: zonder gegevens', () => {
  it('levert een leeg model zonder events', async () => {
    const m = await wealth.buildWealthModel();
    assert.deepEqual(m, { years: [], rows: [], totals: null });
  });

  it('levert een leeg model als het asset verdwijnt', async () => {
    koop({ sats: 100, fiatPrice: 1, at: '2024-01-01T00:00:00' });
    harness.exports.run(`DELETE FROM Asset`);
    assert.equal(harness.exports.one(`SELECT COUNT(*) AS n FROM Event`).n, 0, 'CASCADE ruimde de events op');
    const m = await wealth.buildWealthModel();
    assert.deepEqual(m.years, []);
  });
});

describe('peiljaren', () => {
  it('begint het jaar ná de eerste gebeurtenis en loopt t/m dit jaar', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00' });
    const m = await wealth.buildWealthModel();
    assert.equal(m.years[0], 2023);
    assert.equal(m.years.at(-1), HUIDIG_JAAR);
    assert.equal(m.years.length, HUIDIG_JAAR - 2022);
  });
});

describe('peildata waarop er niets stond', () => {
  it('noemt een peildatum leeg als geen enkele rij dan iets had', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    verkoop({ sats: 100_000_000, fiatPrice: 25000, at: '2023-09-01T00:00:00' });
    koop({ sats: 50_000_000, fiatPrice: 60000, at: `${HUIDIG_JAAR - 1}-06-01T00:00:00` });
    koersPerBtc('2023-01-01', 20000);
    const m = await wealth.buildWealthModel();
    assert.ok(m.emptyYears.includes(2024), '1 januari 2024: alles was verkocht');
    assert.ok(m.emptyYears.includes(HUIDIG_JAAR - 1),
      'en op 1 januari vorig jaar ook nog niet: die aankoop kwam in juni');
    assert.ok(!m.emptyYears.includes(HUIDIG_JAAR), 'maar op 1 januari van dit jaar staat er wél iets');
  });

  it('noemt een peildatum NIET leeg als er wel iets stond maar zonder koers', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc(`${HUIDIG_JAAR}-01-01`, 50000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[2024].value, null, 'de waarde is onbekend');
    assert.ok(!m.emptyYears.includes(2024), 'maar de kolom is niet leeg: er staat een positie');
  });

  it('laat een post BUITEN box 3 de kolom niet bezet houden', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2023-01-01', 20000);
    harness.exports.run(`UPDATE Account SET taxScope = 'none' WHERE id = ?`, [acc]);
    const m = await wealth.buildWealthModel();
    assert.ok(m.emptyYears.includes(2024), 'alleen buiten-box-3-bezit is voor deze pagina leeg');
    assert.equal(m.buitenBox3.length, 1, 'en het wordt wel genoemd, met zijn bedrag');
  });
});

describe('stromen over de grens van het overzicht', () => {
  let pensioen;
  beforeEach(() => {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt, taxScope)
       VALUES ('Pensioen','pensioen','vault',1,0,1,NULL,'none')`);
    pensioen = harness.exports.lastId();
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 20000);
    for (const d of ['2024-06-01', '2025-01-01', '2025-03-01', '2026-01-01']) koersPerBtc(d, 30000);
  });
  const resultaat2025 = m => m.aanwas.find(a => a.year === 2025);

  it('telt een verkoop op een rekening buiten het overzicht niet als onttrekking', async () => {
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', '2024-06-01T00:00:00', 50000000, 20000, ?, 'manual', '2024-06-01T00:00:00')`, [btc, pensioen]);
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, fromAccountId, source, createdAt)
       VALUES (?, 'sell', '2025-03-01T00:00:00', 50000000, 30000, ?, 'manual', '2025-03-01T00:00:00')`, [btc, pensioen]);
    const a = resultaat2025(await wealth.buildWealthModel());
    assert.equal(a.withdrawals, 0, 'die verkoop ligt buiten deze pagina');
    assert.equal(Math.round(a.result), 0, 'en maakt het resultaat dus niet hoger');
  });

  it('telt een verplaatsing naar een rekening buiten het overzicht als onttrekking en niet als verlies', async () => {
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fromAccountId, toAccountId, source, createdAt)
       VALUES (?, 'transfer', '2025-03-01T00:00:00', 50000000, ?, ?, 'manual', '2025-03-01T00:00:00')`, [btc, acc, pensioen]);
    const a = resultaat2025(await wealth.buildWealthModel());
    assert.equal(Math.round(a.withdrawals), 15000, 'een halve BTC tegen de dagkoers verliet het overzicht');
    assert.equal(Math.round(a.result), 0);
  });

  it('trekt dezelfde grens bij "alleen per categorie": tabel en resultaat zien die rekening niet', async () => {
    harness.exports.run(`UPDATE Account SET taxScope = 'category' WHERE id = ?`, [pensioen]);
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fromAccountId, toAccountId, source, createdAt)
       VALUES (?, 'transfer', '2025-03-01T00:00:00', 50000000, ?, ?, 'manual', '2025-03-01T00:00:00')`, [btc, acc, pensioen]);
    const m = await wealth.buildWealthModel();
    const a = resultaat2025(m);
    assert.equal(Math.round(a.withdrawals), 15000);
    assert.equal(Math.round(a.result), 0);
    assert.equal(m.rows.some(r => r.account.id === pensioen), false, 'niet in de tabel');
    assert.equal(m.categoryRows.some(r => r.account.id === pensioen), true, 'wel in de splitsing');
    assert.equal(m.buitenBox3.length, 0, 'en niet genoemd als weggelaten: hij staat in het kader per categorie');
  });

  it('negeert met ignoreTaxSettings de reikwijdte en categorie van account en asset', async () => {
    harness.exports.run(`UPDATE Asset SET taxCategory = 'bank' WHERE id = ?`, [btc]);
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fromAccountId, toAccountId, source, createdAt)
       VALUES (?, 'transfer', '2025-03-01T00:00:00', 50000000, ?, ?, 'manual', '2025-03-01T00:00:00')`, [btc, acc, pensioen]);
    const eigen = await wealth.buildWealthModel();
    const standaard = await wealth.buildWealthModel({ ignoreTaxSettings: true });
    assert.equal(eigen.rows.some(r => r.account.id === pensioen), false, 'met de instelling buiten de tabel');
    assert.equal(standaard.rows.some(r => r.account.id === pensioen), true, 'zonder de instelling erin');
    assert.equal(standaard.buitenBox3.length, 0, 'en dus niet als weggelaten genoemd');
    assert.equal(resultaat2025(standaard).withdrawals, 0, 'de verplaatsing blijft binnen de pagina');
    assert.equal(categorieGekozen(eigen.categoryRows), true);
    assert.equal(categorieGekozen(standaard.categoryRows), false, 'de gekozen categorie telt ook niet');
    assert.equal(standaard.rows.every(r => r.categorie === VERMOGENSCATEGORIE.OVERIG), true, 'BTC volgt zijn soort');
  });

  it('meldt hasTaxSettings alleen bij een afwijking, ook in de standaardweergave', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-06-01T00:00:00' });
    harness.exports.run(`UPDATE Account SET taxScope = NULL WHERE id = ?`, [pensioen]);
    assert.equal((await wealth.buildWealthModel()).hasTaxSettings, false, 'alles op de standaard');
    harness.exports.run(`UPDATE Asset SET taxCategory = 'bank' WHERE id = ?`, [btc]);
    assert.equal((await wealth.buildWealthModel()).hasTaxSettings, true, 'een categorie op een asset');
    assert.equal((await wealth.buildWealthModel({ ignoreTaxSettings: true })).hasTaxSettings, true);
  });
});

describe('sumReturn: een rekening met een asset uit het jaar zelf', () => {
  let xau;
  beforeEach(() => {
    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit) VALUES ('XAU','Goud','goud','metal','g',NULL,4,'unit')`);
    xau = harness.exports.lastId();
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-06-01T00:00:00' });
    koersPerBtc('2024-06-01', 20000);
    koersPerBtc('2025-01-01', 30000);
    koersPerBtc('2025-07-01', 33000);
    koersPerBtc('2026-01-01', 33000);
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', '2025-05-26T23:00:00Z', 1000000, 50, ?, 'manual', '2025-05-26T23:00:00Z')`, [xau, acc]);
    for (const [d, eur] of [['2025-05-01', 50], ['2025-10-01', 60], ['2026-01-01', 60]]) {
      harness.exports.run(
        `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, updatedAt)
         VALUES (?,?, 'day', ?, ?, ?)`, [xau, `${d}T00:00:00Z`, eur, testProvider(), `${d}T00:00:00Z`]);
    }
  });
  const cellen = (m, ids) => m.rows.filter(r => r.account.id === acc && ids.includes(r.asset.id))
    .map(r => ({ begin: r.perYear[2025], eind: r.perYear[2026] }));

  it('telt het goud mee in resultaat én percentage van de rekening', async () => {
    const m = await wealth.buildWealthModel();
    const goud = m.rows.find(r => r.asset.id === xau);
    assert.equal(goud.perYear[2026].pct, null, 'het goud zelf heeft geen percentage: het begon bij nul');
    const res = wealth.sumReturn(cellen(m, [btc, xau]));
    assert.equal(Math.round(res.gain), 4000);
    assert.ok(Math.abs(res.pct - 4000 / 33000) < 1e-4, `percentage ${res.pct}`);
  });

  it('geeft wel het resultaat maar geen percentage als de rekening op 1 januari leeg was', async () => {
    const m = await wealth.buildWealthModel();
    const res = wealth.sumReturn(cellen(m, [xau]));
    assert.equal(Math.round(res.gain), 1000);
    assert.equal(res.pct, null);
  });
});

describe('startjaar van de administratie', () => {
  it('begrenst de peiljaren zonder de stand aan te tasten', async () => {
    koop({ sats: 100_000_000, fiatPrice: 5000, at: '2018-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    await setPref('app', 'start_year', 2024);
    const m = await wealth.buildWealthModel();
    assert.equal(m.years[0], 2024, 'de reeks begint bij het gekozen jaar');
    assert.equal(m.years.length, HUIDIG_JAAR - 2023);
    assert.equal(m.ingekort, true);
    assert.equal(m.firstYear, 2018, 'het écht eerste jaar gaat mee terug, voor de melding op de pagina');
    assert.equal(jaarRij(m, 2024).value, 40000, '1 BTC uit 2018 × de koers van 1-1-2024');
  });

  it('doet niets bij een startjaar vóór de eerste peildatum', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00' });
    await setPref('app', 'start_year', 1990);
    const m = await wealth.buildWealthModel();
    assert.equal(m.years[0], 2023, 'de eerste positie blijft de ondergrens');
    assert.equal(m.ingekort, false, 'er is niets afgesneden, dus de pagina meldt niets');
  });

  it('houdt minstens één kolom over bij een startjaar in de toekomst', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00' });
    await setPref('app', 'start_year', HUIDIG_JAAR + 5);
    const m = await wealth.buildWealthModel();
    assert.deepEqual(m.years, [HUIDIG_JAAR]);
  });

  it('gebruikt zonder keuze de eerste positie', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00' });
    const m = await wealth.buildWealthModel();
    assert.equal(m.years[0], 2023);
    assert.equal(m.ingekort, false);
  });
});

describe('koerstoekenning per peildatum', () => {
  it('gebruikt de koers van de peildatum zelf', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    const m = await wealth.buildWealthModel();
    assert.equal(jaarRij(m, 2024).value, 40000, '1 BTC × 40.000');
  });

  it('geeft geen waarde vóór het begin van de historie', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2025-01-01', 50000);
    const m = await wealth.buildWealthModel();
    assert.equal(jaarRij(m, 2024).value, 0, 'geen koers → deze rij telt niet mee in het totaal');
    assert.equal(m.rows[0].perYear[2024].price, null);
    assert.equal(m.rows[0].perYear[2024].value, null);
  });

  it('trekt een koers vooruit tot de OUDERDOMSGRENS en daarna niet meer', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00' });
    koersPerBtc('2023-12-28', 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(jaarRij(m, 2024).value, 30000, 'binnen de grens wordt hij wél doorgetrokken');
    const cel = m.rows[0].perYear[2025];
    assert.equal(cel.price, null, 'een jaar later geldt die koers niet meer, en dat is de grens');
    assert.equal(cel.value, null, 'dus geen waarde, en null betekent hier "wel bezit, niet te waarderen"');
    assert.equal(cel.sats, 100_000_000, 'de positie staat er nog wel');
  });

  it('geeft metaal een RUIMERE grens dan crypto, met dezelfde koersdatum', async () => {
    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
       VALUES ('XAU','Goud','goud','metal','g','mg',3,'unit')`);
    const goud = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', '2022-06-01T00:00:00', 1000, 80, ?, 'manual', '2022-06-01T00:00:00')`,
      [goud, acc]);
    harness.exports.run(
      `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, updatedAt)
       VALUES (?, '2023-12-20T00:00:00Z', 'day', 100, ?, '2023-12-20T00:00:00Z')`, [goud, testProvider()]);
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00' });
    koersPerBtc('2023-12-20', 30000);

    const m = await wealth.buildWealthModel();
    const cel = (assetId) => m.rows.find(r => r.asset.id === assetId).perYear[2024];
    assert.equal(cel(goud).price, 100, 'twaalf dagen valt binnen de grens van metaal');
    assert.equal(cel(btc).price, null, 'en buiten die van crypto');
  });

  it('kent fiat GEEN grens, want een vaste koers veroudert niet', async () => {
    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
       VALUES ('EUR','Euro','euro','fiat','EUR','cent',2,'unit')`);
    const eur = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'interest', '2022-06-01T00:00:00', 100000, NULL, ?, 'manual', '2022-06-01T00:00:00')`,
      [eur, acc]);
    harness.exports.run(
      `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, updatedAt)
       VALUES (?, '2022-06-01T00:00:00Z', 'day', 1, ?, '2022-06-01T00:00:00Z')`, [eur, testProvider()]);
    const m = await wealth.buildWealthModel();
    const rij = m.rows.find(r => r.asset.id === eur);
    assert.equal(rij.perYear[2024].price, 1, 'anderhalf jaar later nog steeds 1,00');
    assert.equal(rij.perYear[2024].value, 1000, 'en dus 1.000 euro op de rekening');
  });

  it('gebruikt een live spot voor de huidige stand als die er is', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    liveSpot = 90000;
    const m = await wealth.buildWealthModel();
    assert.equal(m.totals.current, 90000, 'de verse spot gaat vóór het laatste gridpunt');
  });

  it('valt zonder live spot terug op het laatste gridpunt', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    koersPerBtc('2024-06-01', 55000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.totals.current, 55000);
  });

  it('geeft NUL en niet "geen waarde" als de positie nul is', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
       VALUES ('XAU','Goud','goud','metal','g','mg',3,'unit')`);
    const goud = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', ?, ?, ?, ?, 'manual', ?)`,
      [goud, `${HUIDIG_JAAR}-03-01T00:00:00`, 10_000, 80, acc, `${HUIDIG_JAAR}-03-01T00:00:00`]);

    const m = await wealth.buildWealthModel();
    const goudRij = m.rows.find(r => r.asset.id === goud);
    assert.ok(goudRij, 'de rij bestaat, want er is later wél een positie');
    assert.equal(goudRij.perYear[2024].sats, 0);
    assert.equal(goudRij.perYear[2024].price, null, 'er is geen koers op die peildatum');
    assert.equal(goudRij.perYear[2024].value, 0, 'en nul eenheden is nul euro, ook zonder koers');
    assert.equal(goudRij.current.sats, 10_000);
    assert.equal(goudRij.current.value, null, 'wél een positie en géén koers blijft onbekend');
  });
});

describe('rijen per account en asset', () => {
  it('laat een combinatie zonder enig saldo weg', async () => {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt) VALUES ('Leeg','leeg','bank',0,0,1,NULL)`);
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows.length, 1);
    assert.equal(m.rows[0].account.name, 'Kluis');
  });

  it('noemt de rij naar het account bij één asset en met symbool bij meerdere', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    assert.equal((await wealth.buildWealthModel()).rows[0].name, 'Kluis');

    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit) VALUES ('XAU','Goud','goud','metal','g',NULL,7,'unit')`);
    assert.equal((await wealth.buildWealthModel()).rows[0].name, 'Kluis · BTC');
  });
});

describe('vermogensaanwas', () => {
  it('rekent eind − begin − stortingen + onttrekkingen', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2025-01-01', 50000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.begin, 30000);
    assert.equal(a.eind, 50000);
    assert.equal(a.deposits, 0);
    assert.equal(a.result, 20000);
  });

  it('trekt een storting binnen het jaar van het resultaat af', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koop({ sats: 100_000_000, fiatPrice: 35000, at: '2024-07-01T00:00:00' });
    koersPerBtc('2025-01-01', 50000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.eind, 100000, '2 BTC × 50.000');
    assert.equal(a.deposits, 35000);
    assert.equal(a.result, 100000 - 30000 - 35000, 'alleen de waardegroei blijft over');
  });

  it('telt de fee van een aankoop mee in de storting', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koop({ sats: 100_000_000, fiatPrice: 35000, at: '2024-07-01T00:00:00', fiatFee: 250 });
    koersPerBtc('2025-01-01', 50000);
    assert.equal(aanwasRij(await wealth.buildWealthModel(), 2024).deposits, 35250,
      'de kosten van de aankoop horen bij het ingelegde bedrag');
  });

  it('telt een verkoop als onttrekking, ná aftrek van de fee', async () => {
    koop({ sats: 200_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    verkoop({ sats: 100_000_000, fiatPrice: 40000, at: '2024-07-01T00:00:00', fiatFee: 100 });
    koersPerBtc('2025-01-01', 50000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.begin, 60000);
    assert.equal(a.eind, 50000, 'nog 1 BTC over × 50.000');
    assert.equal(a.withdrawals, 40000 - 100, 'netto ontvangen, dus na kosten');
    assert.equal(a.result, 50000 - 60000 + 39900);
  });

  it('telt van een interne verplaatsing met "niets tegenover" alleen de euro-fee', async () => {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt) VALUES ('Tweede','tweede','vault',1,0,1,NULL)`);
    const tweede = harness.exports.lastId();
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2024-07-01', 40000);
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatFee, priceOrigin, fromAccountId, toAccountId, source, createdAt)
       VALUES (?, 'transfer', '2024-07-01T00:00:00', 50000000, 2, 'none', ?, ?, 'manual', '2024-07-01T00:00:00')`,
      [btc, acc, tweede]);
    koersPerBtc('2025-01-01', 50000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.deposits, 2, 'alleen de fee');
    assert.equal(a.giften, 0, 'een interne verplaatsing is geen gift');
    assert.equal(a.withdrawals, 0);
  });

  it('rekent een ONTVANGEN GIFT uit het rendement, op de dagkoers', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2024-07-01', 40000);
    koop({ sats: 100_000_000, fiatPrice: 0, at: '2024-07-01T00:00:00', priceOrigin: 'none' });
    koersPerBtc('2025-01-01', 50000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.deposits, 0, 'er is niets betaald, dus dit is geen inleg');
    assert.equal(a.giften, 40000, 'wel waarde binnen, tegen de koers van die dag');
    assert.equal(a.result, 100000 - 30000 - 40000, 'en dus blijft alleen de waardegroei over');
  });

  it('boekt een WEGGEGEVEN gift terug, anders leest hij als verlies', async () => {
    koop({ sats: 200_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2024-07-01', 40000);
    verkoop({ sats: 100_000_000, fiatPrice: 0, at: '2024-07-01T00:00:00', priceOrigin: 'none' });
    koersPerBtc('2025-01-01', 50000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.withdrawals, 0, 'er is niets ontvangen, dus geen onttrekking');
    assert.equal(a.giften, -40000);
    assert.equal(a.result, 50000 - 60000 + 40000, 'de waardegroei van wat je hield, en geen verlies');
  });

  it('laat een gift zonder koers op die dag in het rendement staan', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2025-01-01', 50000);
    koop({ sats: 100_000_000, fiatPrice: 0, at: '2024-07-01T00:00:00', priceOrigin: 'none' });
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.giften, 0, 'niet te waarderen, dus geen correctie');
  });

  it('levert het rendement en géén belastingbedrag', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2025-01-01', 50000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.result, 20000, 'het rendement zelf is wél een kengetal');
    for (const veld of ['vrijstelling', 'belastbaar', 'belasting']) {
      assert.equal(a[veld], undefined, `${veld} hoort geen onderdeel meer te zijn van het model`);
    }
  });

  it('laat een verlies als negatief rendement staan', async () => {
    koop({ sats: 100_000_000, fiatPrice: 60000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 60000);
    koersPerBtc('2025-01-01', 40000);
    const a = aanwasRij(await wealth.buildWealthModel(), 2024);
    assert.equal(a.result, -20000, 'het verlies zelf blijft zichtbaar, en dat is het kengetal');
  });

  it('markeert het lopende jaar en meet dat tot nu in plaats van tot 1 januari', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 1}-06-01T00:00:00` });
    koersPerBtc(`${HUIDIG_JAAR}-01-01`, 30000);
    koersPerBtc(`${HUIDIG_JAAR}-06-01`, 45000);
    const a = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR);
    assert.equal(a.running, true);
    assert.equal(a.begin, 30000);
    assert.equal(a.eind, 45000, 'het eind van een lopend jaar is de huidige stand');
  });
});

describe('kengetallen per belastingjaar', () => {
  const scenario2024 = async (waarde2024, waarde2025 = waarde2024) => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', waarde2024);
    koersPerBtc('2025-01-01', waarde2025);
    return jaarRij(await wealth.buildWealthModel(), 2024);
  };

  it('geeft de waarde op de peildatum en het rendement over dat jaar', async () => {
    const b = await scenario2024(100000, 101000);
    assert.equal(b.value, 100000);
    assert.equal(b.rendement, 1000, 'eind − begin, gecorrigeerd voor stortingen en onttrekkingen');
  });

  it('splitst de waarde uit per vermogenscategorie', async () => {
    const b = await scenario2024(100000);
    assert.deepEqual(b.perCategorie, { [VERMOGENSCATEGORIE.OVERIG]: 100000 });
    assert.equal(b.categorieCompleet, true);
  });

  it('telt de categorieën op tot het totaal', async () => {
    const b = await scenario2024(100000);
    const som = Object.values(b.perCategorie).reduce((s, v) => s + v, 0);
    assert.equal(som, b.value);
  });

  it('rekent geen belasting meer, en dat hoort zo te blijven', async () => {
    const b = await scenario2024(100000);
    for (const veld of ['params', 'hvv', 'grondslag', 'voordeel', 'belasting', 'tegenbewijs']) {
      assert.equal(b[veld], undefined, `${veld} hoort geen onderdeel van het model te zijn`);
    }
  });

  it('geeft ook voor een jaar zonder bekend regime gewoon de waarde', async () => {
    koop({ sats: 100_000_000, fiatPrice: 5000, at: '2019-06-01T00:00:00' });
    koersPerBtc('2020-01-01', 6000);
    const b = jaarRij(await wealth.buildWealthModel(), 2020);
    assert.equal(b.value, 6000);
    assert.deepEqual(b.perCategorie, { [VERMOGENSCATEGORIE.OVERIG]: 6000 });
  });
});

describe('vermogenscategorie per asset-soort', () => {
  it('kent elke soort uit de asset-enum een categorie toe', async () => {
    const { ENUMS } = await import('../../shared/config.js');
    for (const kind of ENUMS.ASSET_KIND) {
      assert.ok(CATEGORIE_PER_ASSET_KIND[kind],
        `asset-soort '${kind}' heeft geen vermogenscategorie; voeg hem toe in tax/constants.js`);
    }
  });

  it('koppelt fiat aan banktegoeden en de rest aan overige bezittingen', () => {
    assert.equal(categorieVoorAsset({ kind: 'fiat' }), VERMOGENSCATEGORIE.BANK);
    assert.equal(categorieVoorAsset({ kind: 'crypto' }), VERMOGENSCATEGORIE.OVERIG);
    assert.equal(categorieVoorAsset({ kind: 'metal' }), VERMOGENSCATEGORIE.OVERIG);
  });

  it('ziet een gekozen categorie alleen als iemand hem zette, op account of asset', () => {
    const rij = (acc, asset) => ({ account: { taxCategory: acc }, asset: { kind: 'fiat', taxCategory: asset } });
    assert.equal(categorieGekozen([rij(null, null), rij(null, null)]), false, 'alles volgt de soort');
    assert.equal(categorieGekozen([rij(null, null), rij('bank', null)]), true, 'op een account');
    assert.equal(categorieGekozen([rij(null, 'overig')]), true, 'op een asset');
    assert.equal(categorieGekozen([{ account: { id: null, taxCategory: null }, asset: { taxCategory: null } }]), false);
    assert.equal(categorieGekozen([]), false);
  });

  it('geeft null voor een onbekende soort in plaats van te gokken', () => {
    assert.equal(categorieVoorAsset({ kind: 'onzin' }), null);
    assert.equal(categorieVoorAsset({ kind: '' }), null);
    assert.equal(categorieVoorAsset(null), null);
  });

  it('kan vandaag niet vóórkomen in de database, en dat is de tweede helft van de guard', () => {
    assert.throws(
      () => harness.exports.run(`UPDATE Asset SET kind = 'onzin' WHERE id = ?`, [btc]),
      /CHECK constraint failed/);
  });

  it('legt een fiat-asset onder banktegoeden in het model', async () => {
    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
       VALUES ('EUR','Euro','euro','fiat','EUR','cent',2,'unit')`);
    const eur = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'interest', '2023-06-01T00:00:00', 100000, NULL, ?, 'manual', '2023-06-01T00:00:00')`,
      [eur, acc]);
    harness.exports.run(
      `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, updatedAt)
       VALUES (?, '2024-01-01T00:00:00Z', 'day', 1, ?, '2024-01-01T00:00:00Z')`, [eur, testProvider()]);
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 100000);
    koersPerBtc('2025-01-01', 100000);

    const b = jaarRij(await wealth.buildWealthModel(), 2024);
    assert.deepEqual(b.perCategorie, {
      [VERMOGENSCATEGORIE.OVERIG]: 100000,
      [VERMOGENSCATEGORIE.BANK]: 1000,
    });
    assert.equal(b.value, 101000, 'het totaal is de som van beide categorieën');
    assert.equal(b.categorieCompleet, true);
  });

  it('haalt een asset met reikwijdte "alleen per categorie" uit tabel en resultaat, niet uit de splitsing', async () => {
    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
       VALUES ('EUR','Euro','euro','fiat','EUR','cent',2,'unit')`);
    const eur = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'interest', '2023-06-01T00:00:00', 100000, NULL, ?, 'manual', '2023-06-01T00:00:00')`,
      [eur, acc]);
    harness.exports.run(
      `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, updatedAt)
       VALUES (?, '2024-01-01T00:00:00Z', 'day', 1, ?, '2024-01-01T00:00:00Z')`, [eur, testProvider()]);
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 100000);
    koersPerBtc('2025-01-01', 100000);

    const gewoon = await wealth.buildWealthModel();
    harness.exports.run(`UPDATE Asset SET taxScope = 'category' WHERE id = ?`, [eur]);
    const apart = await wealth.buildWealthModel();
    assert.equal(gewoon.totals.perYear[2024], 101000);
    assert.deepEqual(gewoon.categorySplit.perYear[2024], gewoon.totals.perYearPerCategorie[2024],
      'zonder aparte reikwijdte is de splitsing die van de tabel');
    assert.equal(apart.totals.perYear[2024], 100000, 'het banktegoed staat niet meer in de totalen');
    assert.equal(apart.rows.some(r => r.asset.id === eur), false, 'en niet in de tabel');
    assert.deepEqual(apart.categorySplit.perYear[2024],
      { [VERMOGENSCATEGORIE.OVERIG]: 100000, [VERMOGENSCATEGORIE.BANK]: 1000 }, 'maar wel in de splitsing');
  });
});

describe('rendementspercentage', () => {
  it('is null voor de eerste kolom', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.pct.perYear[m.years[0]], null, 'er is geen vorige kolom om tegen te meten');
  });

  it('corrigeert voor stortingen, zodat bijstorten geen rendement lijkt', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koop({ sats: 100_000_000, fiatPrice: 30000, at: '2024-07-01T00:00:00' });
    koersPerBtc('2025-01-01', 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.pct.perYear[2025], 0,
      'waarde verdubbeld, maar volledig door de storting → 0% rendement');
  });

  it('meet de huidige waarde tegen het gemiddeld werkzame vermogen', async (t) => {
    const start = new Date(HUIDIG_JAAR, 0, 1);
    const storting = new Date(HUIDIG_JAAR, 0, 1, 1);
    if (Date.now() - storting.getTime() < 24 * 3600 * 1000) return t.skip('te vroeg in het jaar');
    koop({ sats: 100_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 1}-06-01T00:00:00` });
    koersPerBtc(`${HUIDIG_JAAR}-01-01`, 30000);
    koop({ sats: 100_000_000, fiatPrice: 30000, at: storting.toISOString() });
    koersPerBtc(new Date().toISOString().slice(0, 10), 33000);
    const m = await wealth.buildWealthModel();
    const a = aanwasRij(m, HUIDIG_JAAR);
    assert.equal(a.result, 6000);
    const nu = Date.now();
    const gewicht = (nu - storting.getTime()) / (nu - start.getTime());
    const verwacht = 6000 / (30000 + gewicht * 30000);
    assert.ok(Math.abs(m.pct.current - verwacht) < 1e-4, `verwacht ${verwacht}, kreeg ${m.pct.current}`);
    assert.ok(Math.abs(a.pct - verwacht) < 1e-4, 'het aangifteblok leest hetzelfde getal');
  });

  it('volgt de keuze voor IRR ook op de totaalregel', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 2}-06-01T00:00:00` });
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 30000);
    koop({ sats: 100_000_000, fiatPrice: 30000, at: `${HUIDIG_JAAR - 1}-07-01T00:00:00` });
    koersPerBtc(`${HUIDIG_JAAR}-01-01`, 36000);
    await setPref('app', 'mwr_method', 'irr');
    const m = await wealth.buildWealthModel();
    const rij = m.rows[0].perYear[HUIDIG_JAAR];
    assert.ok(Math.abs(rij.pct - 0.2715) < 0.002, `de IRR van de rij: verwacht 27,15%, kreeg ${rij.pct}`);
    assert.ok(Math.abs(m.pct.perYear[HUIDIG_JAAR] - rij.pct) < 1e-6,
      `totaal ${m.pct.perYear[HUIDIG_JAAR]} tegen rij ${rij.pct}`);
  });

  function rekening(naam) {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt) VALUES (?,?,'vault',1,0,1,NULL)`,
      [naam, naam.toLowerCase()]);
    return harness.exports.lastId();
  }
  function balans({ op, sats, at }) {
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`, [btc, at.slice(0, 10), op, sats, at]);
  }
  function verplaats({ sats, at, naar }) {
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fromAccountId, toAccountId, source, createdAt)
       VALUES (?, 'transfer', ?, ?, ?, ?, 'manual', ?)`, [btc, at, sats, acc, naar, at]);
  }

  it('deelt door het gemiddeld werkzame vermogen en niet meer door de beginwaarde', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-06-01T00:00:00' });
    koersPerBtc('2025-01-01', 20000);
    koop({ sats: 100_000_000, fiatPrice: 24000, at: '2025-07-01T00:00:00' });
    koersPerBtc('2026-01-01', 24000);
    const m = await wealth.buildWealthModel();
    const cel = m.rows[0].perYear[2026];
    assert.equal(Math.round(cel.gain), 4000, 'de teller blijft wat hij was');
    assert.equal(Math.round((4000 / 20000) * 1000) / 10, 20, 'de oude som, ter vergelijking');
    assert.ok(Math.abs(cel.pct - 0.1246) < 0.002, `verwacht ongeveer 12,5%, kreeg ${cel.pct}`);
    assert.ok(cel.pct < 0.2, 'en in elk geval fors onder de oude 20%');
  });

  it('zet de noemer op de cel, zodat een regel die assets optelt hem kan sommeren', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-06-01T00:00:00' });
    koersPerBtc('2025-01-01', 20000);
    koop({ sats: 100_000_000, fiatPrice: 24000, at: '2025-07-01T00:00:00' });
    koersPerBtc('2026-01-01', 24000);
    const cel = (await wealth.buildWealthModel()).rows[0].perYear[2026];
    assert.ok(Math.abs(cel.basis - 32100) < 100, `verwacht ongeveer 32.100, kreeg ${cel.basis}`);
    assert.equal(Math.round((cel.gain / cel.basis) * 1000) / 1000, Math.round(cel.pct * 1000) / 1000,
      'en het percentage op de cel is precies die deling');
  });

  it('geeft exact het oude getal zolang er niets stroomt', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2025-01-01', 20000);
    koersPerBtc('2026-01-01', 25000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[2026].pct, 0.25, '5.000 op 20.000, precies zoals voorheen');
  });

  it('staat per rij op de kolom waar dat jaar op eindigt', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2025-01-01', 60000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[2025].pct, 1, 'koers verdubbeld, niets bijgekocht → +100%');
  });

  it('is per rij leeg in de eerste kolom', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[m.years[0]].pct, null);
  });

  it('corrigeert per rij voor een aankoop halverwege het jaar', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koop({ sats: 100_000_000, fiatPrice: 30000, at: '2024-07-01T00:00:00' });
    koersPerBtc('2025-01-01', 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[2025].pct, 0, 'de waarde verdubbelde, maar volledig door de aankoop');
  });

  it('leest een verplaatsing tussen eigen rekeningen niet als verlies', async () => {
    const tweede = rekening('Beurs');
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2024-07-01', 30000);
    verplaats({ sats: 100_000_000, at: '2024-07-01T00:00:00', naar: tweede });
    koersPerBtc('2025-01-01', 30000);
    const m = await wealth.buildWealthModel();
    const vertrek = m.rows.find(r => r.account.id === acc);
    const aankomst = m.rows.find(r => r.account.id === tweede);
    assert.equal(vertrek.perYear[2025].pct, 0, 'de rekening die leegliep heeft niets verloren');
    assert.equal(aankomst.perYear[2025].pct, null, 'en zonder beginwaarde is er geen percentage te geven');
  });

  it('geeft een positie die vanaf nul is opgebouwd wél een resultaat en géén percentage', async () => {
    const tweede = rekening('Beurs');
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2024-07-01', 30000);
    verplaats({ sats: 100_000_000, at: '2024-07-01T00:00:00', naar: tweede });
    koersPerBtc('2025-01-01', 45000);
    const m = await wealth.buildWealthModel();
    const aankomst = m.rows.find(r => r.account.id === tweede).perYear[2025];
    assert.equal(aankomst.pct, null, 'er was geen beginwaarde om tegen af te meten');
    assert.equal(aankomst.gain, 15000, 'maar de koersstijging ná de verplaatsing is een echt resultaat');
  });

  it('trekt per RIJ een ontvangen gift van het resultaat af', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2024-07-01', 40000);
    koop({ sats: 100_000_000, fiatPrice: 0, at: '2024-07-01T00:00:00', priceOrigin: 'none' });
    koersPerBtc('2025-01-01', 50000);
    const m = await wealth.buildWealthModel();
    const cel = m.rows.find(r => r.account.id === acc).perYear[2025];
    assert.equal(cel.gain, 100000 - 30000 - 40000, 'alleen de koersgroei, niet de gift zelf');
  });

  it('trekt per rij af wat uit een balans komt in plaats van uit een boeking', async () => {
    const spaar = rekening('Spaar');
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2023-06-01T00:00:00' });
    koersPerBtc('2024-01-01', 30000);
    koersPerBtc('2025-01-01', 30000);
    balans({ op: spaar, sats: 100_000_000, at: '2023-12-01T00:00:00' });
    balans({ op: spaar, sats: 200_000_000, at: '2024-07-01T00:00:00' });
    const m = await wealth.buildWealthModel();
    const rij = m.rows.find(r => r.account.id === spaar);
    assert.equal(rij.perYear[2024].value, 30000, 'de stand op de peildatum komt uit de eerste balans');
    assert.equal(rij.perYear[2025].value, 60000, 'en verdubbelt door de tweede');
    assert.equal(rij.perYear[2025].pct, 0, 'maar dat is een meting en geen rendement');
  });
});

describe('currentStanding', () => {
  it('is leeg zonder assets', async () => {
    harness.exports.run(`DELETE FROM Asset`);
    assert.deepEqual(await wealth.currentStanding(), { rows: [], total: 0, totalSats: 0, today: null });
  });

  it('geeft het resultaat van vandaag, zonder wat er op een beheerd account gebeurt', async () => {
    const gisteren = new Date(Date.now() - 86_400_000).toISOString().slice(0, 10);
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt, wealthScope)
       VALUES ('Spaarpot','spaarpot','bank',0,0,1,NULL,'managed')`);
    const spaarpot = harness.exports.lastId();
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-01-01T00:00:00' });
    const nu = new Date().toISOString().slice(0, 19);
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', ?, 50000000, 20000, ?, 'manual', ?)`, [btc, nu, spaarpot, nu]);
    koersPerBtc('2024-01-01', 40000);
    koersPerBtc(gisteren, 40000);
    liveSpot = 44000;
    const s = await wealth.currentStanding();
    assert.equal(Math.round(s.today.total), 4000);
    assert.equal(Math.round(s.today.perAsset.get(btc)), 4000);
  });

  it('laat een account zonder saldo weg', async () => {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt) VALUES ('Leeg','leeg','bank',0,0,1,NULL)`);
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-01-01T00:00:00' });
    koersPerBtc('2024-01-01', 40000);
    const s = await wealth.currentStanding();
    assert.equal(s.rows.length, 1);
    assert.equal(s.total, 40000);
    assert.equal(s.totalSats, 100_000_000);
  });

  it('sorteert op waarde, grootste eerst', async () => {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt) VALUES ('Tweede','tweede','vault',1,0,1,NULL)`);
    const acc2 = harness.exports.lastId();
    koop({ sats: 50_000_000, fiatPrice: 20000, at: '2024-01-01T00:00:00' });
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', '2024-01-02T00:00:00', 300000000, 20000, ?, 'manual', '2024-01-02T00:00:00')`,
      [btc, acc2]);
    koersPerBtc('2024-01-01', 40000);

    const s = await wealth.currentStanding();
    assert.deepEqual(s.rows.map(r => r.account.name), ['Tweede', 'Kluis']);
  });

  it('geeft een rij zonder koers een waarde van null maar telt het saldo mee', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-01-01T00:00:00' });
    const s = await wealth.currentStanding();
    assert.equal(s.rows[0].value, null, 'geen koershistorie → geen waarde');
    assert.equal(s.total, 0);
    assert.equal(s.totalSats, 100_000_000, 'de hoeveelheid is er wel');
  });

  it('slaat een beheerd account over, zonder dat het in de restpost belandt', async () => {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt, wealthScope)
       VALUES ('Spaarpot','spaarpot','bank',0,0,1,NULL,'managed')`);
    const spaarpot = harness.exports.lastId();
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2024-01-01T00:00:00' });
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', '2024-01-02T00:00:00', 50000000, 20000, ?, 'manual', '2024-01-02T00:00:00')`,
      [btc, spaarpot]);
    koersPerBtc('2024-01-01', 40000);
    const s = await wealth.currentStanding();
    assert.deepEqual(s.rows.map(r => r.account.name), ['Kluis']);
    assert.equal(s.total, 40000);
    assert.equal(s.totalSats, 100_000_000);
  });
});

describe('peilmoment: de jaargrens ligt op lokale middernacht, niet op UTC-middernacht', () => {
  const NET_VOOR = '2023-12-31T22:30:00Z';
  const NET_NA   = '2023-12-31T23:30:00Z';

  it('telt een aankoop van vlak vóór lokale middernacht nog mee in het oude jaar', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00Z' });
    koop({ sats: 50_000_000, fiatPrice: 30000, at: NET_VOOR });
    koersPerBtc('2022-06-01', 20000);
    koersPerBtc('2024-01-01', 40000);
    const m = await wealth.buildWealthModel();
    const rij = m.rows[0];
    assert.equal(rij.perYear[2024].sats, 150_000_000,
      'een aankoop om 23:30 lokaal hoort nog bij het jaar dat dan afloopt');
  });

  it('laat een aankoop van vlak ná lokale middernacht buiten het oude jaar', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: '2022-06-01T00:00:00Z' });
    koop({ sats: 50_000_000, fiatPrice: 30000, at: NET_NA });
    koersPerBtc('2022-06-01', 20000);
    koersPerBtc('2024-01-01', 40000);
    const m = await wealth.buildWealthModel();
    const rij = m.rows[0];
    assert.equal(rij.perYear[2024].sats, 100_000_000,
      'een aankoop om 00:30 lokaal valt in het nieuwe jaar; zou de grens op UTC-middernacht ' +
      'liggen, dan telde hij hier ten onrechte mee');
  });
});

describe('buildWealthModel: met een balans als anker', () => {
  function balans({ sats, at }) {
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`, [btc, at.slice(0, 10), acc, sats, at]);
  }

  it('zet een rekening met alléén een balans in het model', async () => {
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows.length, 1, 'er is een rij, zonder één gebeurtenis');
    assert.equal(m.years[0], HUIDIG_JAAR - 1, 'de peiljaren beginnen ná het jaar van de balans');
    assert.equal(m.rows[0].perYear[HUIDIG_JAAR - 1].sats, 100_000_000);
    assert.equal(m.rows[0].perYear[HUIDIG_JAAR - 1].value, 30000);
  });

  it('laat het anker de boekingen van vóór dat moment overrulen', async () => {
    koop({ sats: 40_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 2}-01-01T00:00:00` });
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[HUIDIG_JAAR - 1].sats, 100_000_000, 'de balans, niet de 0,4 BTC uit het grootboek');
  });

  it('telt een boeking ná het anker er wél bij op', async () => {
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koop({ sats: 50_000_000, fiatPrice: 25000, at: `${HUIDIG_JAAR - 2}-08-01T00:00:00` });
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[HUIDIG_JAAR - 1].sats, 150_000_000);
  });

  it('gebruikt per peiljaar het anker dat op dát moment gold', async () => {
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 3}-06-30T00:00:00.000Z` });
    balans({ sats: 200_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersPerBtc(`${HUIDIG_JAAR - 2}-01-01`, 30000);
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows[0].perYear[HUIDIG_JAAR - 2].sats, 100_000_000, 'het oudste anker in het eerste jaar');
    assert.equal(m.rows[0].perYear[HUIDIG_JAAR - 1].sats, 200_000_000, 'en het nieuwste daarna');
  });

  it('laat een portefeuille-brede balans het model niet raken', async () => {
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,NULL,?,1.0,?, 'manual')`,
      [btc, `${HUIDIG_JAAR - 2}-06-30`, 100_000_000, `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z`]);
    const m = await wealth.buildWealthModel();
    assert.deepEqual(m, { years: [], rows: [], totals: null });
  });

  it('geeft de huidige stand van een rekening met alleen een balans', async () => {
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR}-01-02T00:00:00.000Z` });
    koersPerBtc(`${HUIDIG_JAAR}-01-02`, 30000);
    const stand = await wealth.currentStanding();
    assert.equal(stand.totalSats, 100_000_000);
    assert.equal(stand.rows.length, 1);
    assert.equal(stand.rows[0].value, 30000);
  });
});

describe('buildWealthModel: wat de boekingen niet verklaren', () => {
  function balans({ sats, at }) {
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`, [btc, at.slice(0, 10), acc, sats, at]);
  }
  function koersen() {
    koersPerBtc(`${HUIDIG_JAAR - 3}-01-01`, 30000);
    koersPerBtc(`${HUIDIG_JAAR - 2}-01-01`, 30000);
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 40000);
    koersPerBtc(`${HUIDIG_JAAR}-01-01`, 40000);
  }

  it('houdt het op nul zolang er geen balans is', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    koersen();
    const m = await wealth.buildWealthModel();
    for (const a of m.aanwas) assert.equal(a.unexplained, 0, `jaar ${a.year}`);
  });

  it('zet de sprong van een balans náást het rendement in plaats van erin', async () => {
    koop({ sats: 40_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersen();
    const jaar = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2);
    assert.equal(jaar.unexplained, 24000, '0,6 BTC tegen de 40.000 van de peildatum aan het eind');
    assert.equal(jaar.deposits, 0, 'en het is géén storting geworden');
    assert.equal(jaar.result, 28000, 'het rendement staat er onveranderd naast, mét de sprong erin');
    assert.equal(jaar.begin, 12000, '0,4 BTC tegen 30.000');
    assert.equal(jaar.eind, 40000, '1 BTC tegen 40.000');
  });

  it('meldt niets als de balans het grootboek bevestigt', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersen();
    assert.equal(aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2).unexplained, 0);
  });

  it('rekent de sprong aan één jaar toe en niet ook aan het jaar erna', async () => {
    koop({ sats: 40_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersen();
    const m = await wealth.buildWealthModel();
    assert.equal(aanwasRij(m, HUIDIG_JAAR - 2).unexplained, 24000);
    assert.equal(aanwasRij(m, HUIDIG_JAAR - 1).unexplained, 0);
  });

  it('noemt per rekening wie het veroorzaakt, met en zonder grootboek eronder', async () => {
    koop({ sats: 40_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt)
       VALUES ('Node','node','lightning',1,0,1,NULL)`);
    const node = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`,
      [btc, `${HUIDIG_JAAR - 2}-06-30`, node, 5_000_000, `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z`]);
    koersen();
    const jaar = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2);
    assert.equal(jaar.unexplained, 24000, '0,6 BTC uit de kluis, tegen de koers van 40.000');
    assert.equal(jaar.uitBalansen, 2000, '0,05 BTC uit de beginbalans van de node');
    assert.deepEqual(jaar.unexplainedRows, [
      { name: 'Kluis', units: 60_000_000, value: 24000 },
    ], 'alleen de rijen waar nog iets te doen valt');
  });

  it('laat een beginbalans niet als rendement gelden', async () => {
    koop({ sats: 40_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt)
       VALUES ('Node','node','lightning',1,0,1,NULL)`);
    const node = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`,
      [btc, `${HUIDIG_JAAR - 2}-06-30`, node, 5_000_000, `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z`]);
    koersen();
    const jaar = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2);
    assert.equal(jaar.begin, 12000, '0,4 BTC tegen 30.000');
    assert.equal(jaar.eind, 18000, '0,45 BTC tegen 40.000');
    assert.equal(jaar.uitBalansen, 2000, 'de beginbalans van de node');
    assert.equal(jaar.result, 4000, 'alleen de koerswinst op wat er al stond');
  });

  it('telt een aanvaard verschil net zo goed uit het rendement', async () => {
    koop({ sats: 40_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`,
      [btc, `${HUIDIG_JAAR - 2}-06-30`, acc, 45_000_000, `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z`]);
    koersen();
    const voor = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2);
    assert.equal(voor.unexplained, 2000, 'vooraf: 0,05 BTC die nergens vandaan komt');
    assert.equal(voor.result, 6000, 'en die zit in het rendement');

    harness.exports.run(`UPDATE Valuation SET gapAcceptedAt = ? WHERE accountId = ?`,
      [`${HUIDIG_JAAR - 2}-07-01T00:00:00.000Z`, acc]);
    const na = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2);
    assert.equal(na.unexplained, 0, 'erna: niets meer onverklaard');
    assert.equal(na.uitBalansen, 2000, 'het staat nu bij de stromen');
    assert.equal(na.result, 4000, 'en het rendement is weer alleen de koerswinst');
  });

  it('houdt de uitsplitsing leeg als er niets onverklaard is', async () => {
    koop({ sats: 100_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersen();
    for (const a of (await wealth.buildWealthModel()).aanwas) assert.deepEqual(a.unexplainedRows, [], `jaar ${a.year}`);
  });

  it('laat een rekening buiten box 3 ook buiten de uitsplitsing', async () => {
    koop({ sats: 40_000_000, fiatPrice: 20000, at: `${HUIDIG_JAAR - 3}-06-01T00:00:00` });
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt, taxScope)
       VALUES ('Pensioenpotje','pensioenpotje','bank',1,0,1,NULL,'none')`);
    const pensioen = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`,
      [btc, `${HUIDIG_JAAR - 2}-06-30`, pensioen, 5_000_000, `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z`]);
    koersen();
    const jaar = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2);
    assert.deepEqual(jaar.unexplainedRows, []);
    assert.equal(jaar.unexplained, 0);
  });

  it('rapporteert een sprong van vóór de eerste peildatum niet, en dat hoort zo', async () => {
    balans({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-30T00:00:00.000Z` });
    koersen();
    const m = await wealth.buildWealthModel();
    assert.equal(m.years[0], HUIDIG_JAAR - 1, 'de reeks begint ná het jaar van de balans');
    for (const a of m.aanwas) assert.equal(a.unexplained, 0, `jaar ${a.year}`);
    assert.equal(m.rows[0].perYear[HUIDIG_JAAR - 1].sats, 100_000_000, 'de stand klopt wél vanaf dag één');
  });
});

describe('een rekening buiten het belaste vermogen', () => {
  function pensioenrekening() {
    harness.exports.run(
      `INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt, taxScope)
       VALUES ('Pensioenpotje','pensioenpotje','bank',0,0,1,NULL,'none')`);
    return harness.exports.lastId();
  }
  function koop({ sats, at, acc }) {
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'buy', ?, ?, 20000, ?, 'manual', ?)`, [btc, at, sats, acc, at]);
  }

  it('laat de rekening uit de cijfers, en noemt hem bij naam', async () => {
    const pensioen = pensioenrekening();
    koop({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-01T00:00:00`, acc });
    koop({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-01T00:00:00`, acc: pensioen });
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 30000);
    const m = await wealth.buildWealthModel();
    assert.deepEqual(m.rows.map(r => r.account.name), ['Kluis'], 'de pensioenrij staat niet in de tabel');
    assert.equal(m.totals.perYear[HUIDIG_JAAR - 1], 30000, 'en telt dus niet in het totaal mee');
    assert.deepEqual(m.buitenBox3.map(x => x.name), ['Pensioenpotje'],
      'maar hij verdwijnt niet stil: de pagina kan hem noemen');
  });

  it('houdt de uitsplitsing per categorie compleet', async () => {
    const pensioen = pensioenrekening();
    koop({ sats: 100_000_000, at: `${HUIDIG_JAAR - 2}-06-01T00:00:00`, acc });
    koop({ sats: 50_000_000, at: `${HUIDIG_JAAR - 2}-06-01T00:00:00`, acc: pensioen });
    koersPerBtc(`${HUIDIG_JAAR - 1}-01-01`, 30000);
    const m = await wealth.buildWealthModel();
    assert.equal(jaarRij(m, HUIDIG_JAAR - 1).categorieCompleet, true);
    assert.deepEqual(Object.keys(jaarRij(m, HUIDIG_JAAR - 1).perCategorie), ['overig']);
  });

  it('laat een categorie op het asset zelf ook werken, en de rekening gaat vóór', async () => {
    assert.equal(categorieVoor({ taxCategory: 'bank' }, { kind: 'crypto' }), 'bank', 'rekening');
    assert.equal(categorieVoor({}, { kind: 'crypto', taxCategory: 'bank' }), 'bank', 'asset');
    assert.equal(categorieVoor({ taxCategory: 'overig' }, { kind: 'fiat', taxCategory: 'bank' }), 'overig',
      'de rekening gaat vóór het asset');
    assert.equal(categorieVoor({}, { kind: 'fiat' }), 'bank', 'en zonder override de asset-soort');
  });

  it('volgt voor de reikwijdte dezelfde volgorde: rekening, asset, dan overal', async () => {
    assert.equal(reikwijdteVoor({ taxScope: 'none' }, { taxScope: 'category' }), 'none', 'de rekening gaat vóór');
    assert.equal(reikwijdteVoor({ taxScope: null }, { taxScope: 'category' }), 'category', 'dan het asset');
    assert.equal(reikwijdteVoor({}, {}), 'all', 'en zonder keuze telt het overal');
    assert.equal(reikwijdteVoor(null, null), 'all');
  });

  it('telt een banktegoed gewoon mee in de jaarcijfers', async () => {
    harness.exports.run(
      `INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
       VALUES ('EUR','Euro','euro','fiat','EUR','cent',2,'unit')`);
    const eur = harness.exports.lastId();
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, toAccountId, source, createdAt)
       VALUES (?, 'interest', ?, 500000, NULL, ?, 'manual', ?)`,
      [eur, `${HUIDIG_JAAR - 3}-06-01T00:00:00`, acc, `${HUIDIG_JAAR - 3}-06-01T00:00:00`]);
    for (const jaar of [HUIDIG_JAAR - 2, HUIDIG_JAAR - 1, HUIDIG_JAAR]) {
      harness.exports.run(
        `INSERT INTO PriceHistory (assetId, observedAt, resolution, fiatPrice, providerId, updatedAt)
         VALUES (?, ?, 'day', 1, ?, ?)`,
        [eur, `${jaar}-01-01T00:00:00Z`, testProvider(), `${jaar}-01-01T00:00:00Z`]);
    }
    const jaar = aanwasRij(await wealth.buildWealthModel(), HUIDIG_JAAR - 2);
    assert.equal(jaar.begin, 5000, 'de beginwaarde kent het banktegoed');
    assert.equal(jaar.eind, 5000, 'en de eindwaarde ook');
    assert.equal(jaar.result, 0, 'dus geen rendement, en geen gat');
  });

  it('heeft dezelfde categorieën als de registry in shared/config.js', () => {
    assert.deepEqual([...Object.values(VERMOGENSCATEGORIE)].sort(), [...ENUMS.TAX_CATEGORY].sort());
  });
});

describe('de stand van nu, langs twee wegen', () => {
  const somPerAsset = async () => (await import('../../server/data/positions.js'))
    .positionsByAsset().reduce((s, r) => s + r.net, 0);
  const koopZonderRekening = (sats, at) => harness.exports.run(
    `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, source, createdAt)
     VALUES (?, 'buy', ?, ?, 30000, 'manual', ?)`, [btc, at, sats, at]);

  it('geeft hetzelfde getal als elke boeking een rekening noemt', async () => {
    koop({ sats: 100_000, fiatPrice: 30_000, at: `${HUIDIG_JAAR - 1}-03-01T00:00:00` });
    koop({ sats: 40_000, fiatPrice: 40_000, at: `${HUIDIG_JAAR}-01-15T00:00:00` });
    verkoop({ sats: 25_000, fiatPrice: 50_000, at: `${HUIDIG_JAAR}-02-01T00:00:00` });
    const stand = await wealth.currentStanding();
    assert.equal(stand.totalSats, 115_000);
    assert.equal(stand.totalSats, await somPerAsset(), 'beide pagina\'s tellen dezelfde eenheden');
  });

  it('geeft ook hetzelfde getal als een boeking GEEN rekening noemt', async () => {
    koop({ sats: 100_000, fiatPrice: 30_000, at: `${HUIDIG_JAAR}-01-15T00:00:00` });
    koopZonderRekening(50_000, `${HUIDIG_JAAR}-02-01T00:00:00`);
    const stand = await wealth.currentStanding();
    assert.equal(await somPerAsset(), 150_000);
    assert.equal(stand.totalSats, 150_000, 'de rest telt mee in plaats van weg te vallen');
  });

  it('zet die rest op een eigen rij, herkenbaar en zonder rekening-id', async () => {
    koop({ sats: 100_000, fiatPrice: 30_000, at: `${HUIDIG_JAAR}-01-15T00:00:00` });
    koopZonderRekening(50_000, `${HUIDIG_JAAR}-02-01T00:00:00`);
    const rest = (await wealth.currentStanding()).rows.find(r => r.account.isUnassigned);
    assert.ok(rest, 'er is een rij zonder rekening');
    assert.equal(rest.sats, 50_000);
    assert.equal(rest.account.id, null, 'geen id, zodat een opzoeking hard faalt in plaats van stil');
  });

  it('telt de rest ook mee in het jaarmodel, in de kolom van zijn eigen jaar', async () => {
    koop({ sats: 100_000, fiatPrice: 30_000, at: `${HUIDIG_JAAR - 2}-03-01T00:00:00` });
    koopZonderRekening(50_000, `${HUIDIG_JAAR}-06-01T00:00:00`);
    koersPerBtc(`${HUIDIG_JAAR - 2}-01-01`, 30_000);
    const m = await wealth.buildWealthModel();
    const restRij = m.rows.find(r => r.account.isUnassigned);
    assert.ok(restRij, 'de restrij staat in het model');
    assert.equal(restRij.perYear[HUIDIG_JAAR].sats, 0, 'op 1 januari bestond hij nog niet');
    assert.equal(restRij.current.sats, 50_000, 'en nu wel');
  });

  it('telt ook een NEGATIEVE rest mee, want die kant bestaat net zo goed', async () => {
    koop({ sats: 100_000, fiatPrice: 30_000, at: `${HUIDIG_JAAR}-01-15T00:00:00` });
    harness.exports.run(
      `INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, source, createdAt)
       VALUES (?, 'sell', ?, 40000, 30000, 'manual', ?)`,
      [btc, `${HUIDIG_JAAR}-02-01T00:00:00`, `${HUIDIG_JAAR}-02-01T00:00:00`]);

    const stand = await wealth.currentStanding();
    assert.equal(await somPerAsset(), 60_000, 'per asset is de verkoop eraf');
    assert.equal(stand.totalSats, 60_000, 'en de stand volgt, in plaats van op 100.000 te blijven staan');
    assert.equal(stand.rows.find(r => r.account.isUnassigned).sats, -40_000);
  });

  it('laat de rest de categorie van het ASSET volgen, want er is geen rekening', async () => {
    koopZonderRekening(50_000, `${HUIDIG_JAAR}-06-01T00:00:00`);
    const restRij = (await wealth.buildWealthModel()).rows.find(r => r.account.isUnassigned);
    assert.equal(restRij.categorie, VERMOGENSCATEGORIE.OVERIG, 'bitcoin is een overige bezitting');
  });

  it('houdt de rest BUITEN box 3 als het asset daar staat, net als bij een echte rekening', async () => {
    harness.exports.run(`UPDATE Asset SET taxScope = 'none' WHERE id = ?`, [btc]);
    koopZonderRekening(50_000, `${HUIDIG_JAAR}-06-01T00:00:00`);
    koersPerBtc(`${HUIDIG_JAAR}-01-01`, 30_000);
    const m = await wealth.buildWealthModel();
    assert.equal(m.rows.find(r => r.account.isUnassigned), undefined,
      'de restrij zit niet in de fiscale rijen');
    assert.equal(m.buitenBox3.length, 1, 'maar hij wordt wél bij naam genoemd');
    assert.match(m.buitenBox3[0].name, /Zonder account/);
  });
});