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

import { createDbHarness } from '../helpers/db-node.mjs';
import { toSearchName } from '../../shared/search-name.js';

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

const { assetPositions, eventsNetByAccount } = await import('../../server/data/events.js');
const { accountHoldings, accountPositions, assetPositionsByAccount, firstPositionDate, positionAt, positionsByAsset,
  unexplainedByPair, unexplainedChange, lightningBalanceDiffs, recordLightningBalance } = await import('../../server/data/positions.js');
const { anchorAt, latestAnchors } = await import('../../server/data/valuations.js');
const { lightningBalances } = await import('../../server/data/wallet-sources.js');

const { run, lastId } = harness.exports;
const net = (symbol) => positionsByAsset().find(p => p.symbol === symbol).net;

let btc, eur, kluis, bank;
beforeEach(() => {
  harness.recreate();
  btc = asset('BTC', 'Bitcoin', 'crypto', 8);
  eur = asset('EUR', 'Euro', 'fiat', 2);
  kluis = account('Kluis');
  bank = account('Spaarrekening');
});

function asset(symbol, naam, kind, decimals) {
  run(`INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
       VALUES (?,?,?,?,?,NULL,?,'unit')`, [symbol, naam, toSearchName(naam), kind, symbol, decimals]);
  return lastId();
}
function account(naam) {
  run(`INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt)
       VALUES (?,?,'bank',1,0,1,NULL)`, [naam, toSearchName(naam)]);
  return lastId();
}
function event({ assetId = null, type = 'buy', to = null, from = null, amount = 1000, unitFee = null,
                 at = '2026-03-01T12:00:00.000Z' } = {}) {
  run(`INSERT INTO Event (assetId, type, occurredAt, amount, fiatPrice, unitFee, fromAccountId, toAccountId, source, createdAt)
       VALUES (?,?,?,?,?,?,?,?,'manual',?)`,
    [assetId ?? btc, type, at, amount, type === 'buy' || type === 'sell' ? 50000 : null, unitFee, from, to, at]);
  return lastId();
}
function balans({ assetId = null, acc = undefined, balance = 5000, at = '2026-06-30T00:00:00.000Z' } = {}) {
  const accountId = acc === undefined ? bank : acc;
  run(`INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
       VALUES (?,?,?,?,1.0,?, 'manual')`,
    [assetId ?? eur, at.slice(0, 10), accountId, balance, at]);
  return lastId();
}

describe('positionAt zonder anker', () => {
  it('is gelijk aan de som van de gebeurtenissen, met en zonder peilmoment', () => {
    event({ to: kluis, amount: 100_000, at: '2026-01-01T00:00:00.000Z' });
    event({ to: kluis, amount: 50_000, at: '2026-05-01T00:00:00.000Z' });
    for (const peil of [null, '2026-03-01T00:00:00.000Z', '2026-12-31T00:00:00.000Z']) {
      assert.equal(positionAt(kluis, btc, peil), eventsNetByAccount(kluis, btc, peil), `peil ${peil}`);
    }
    assert.equal(positionAt(kluis, btc, null), 150_000, 'en dat is ook echt het saldo');
  });

  it('geeft nul voor een rekening zonder enige beweging', () => {
    assert.equal(positionAt(bank, eur, null), 0);
  });

  it('ziet een waardering van een ánder asset of een ándere rekening niet als anker', () => {
    balans({ acc: bank, assetId: eur, balance: 999_999 });
    event({ to: kluis, amount: 100_000 });
    assert.equal(positionAt(kluis, btc, null), 100_000, 'ander asset én andere rekening');
    assert.equal(anchorAt(kluis, btc, null), null);
    assert.equal(anchorAt(bank, btc, null), null, 'zelfde rekening, ander asset');
    assert.equal(anchorAt(kluis, eur, null), null, 'zelfde asset, andere rekening');
  });

  it('negeert een portefeuille-brede waardering, want die zegt niets over één rekening', () => {
    balans({ acc: null, assetId: eur, balance: 999_999 });
    event({ assetId: eur, to: bank, amount: 2500 });
    assert.equal(anchorAt(bank, eur, null), null);
    assert.equal(positionAt(bank, eur, null), 2500);
  });
});

describe('positionAt met een anker', () => {
  it('geeft de balans zelf als er niets ná het anker gebeurde', () => {
    balans({ balance: 123_456 });
    assert.equal(positionAt(bank, eur, null), 123_456);
    assert.equal(eventsNetByAccount(bank, eur, null), 0, 'en het grootboek is nog steeds leeg');
  });

  it('telt de bewegingen ná het anker erbovenop', () => {
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    event({ assetId: eur, type: 'interest', to: bank, amount: 500, at: '2026-07-31T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), 100_500, 'rente ná de balans komt erbij');
  });

  it('negeert de bewegingen vóór het anker, ook als ze niet kloppen', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), 100_000);
  });

  it('rekent een gebeurtenis exact op rateAt ín het anker, en niet erbovenop', () => {
    const moment = '2026-06-30T00:00:00.000Z';
    event({ assetId: eur, to: bank, amount: 7_000, at: moment });
    balans({ balance: 100_000, at: moment });
    assert.equal(positionAt(bank, eur, null), 100_000);
  });

  it('kijkt naar rateAt en niet naar valuedOn', () => {
    run(`INSERT INTO Valuation (assetId, valuedOn, accountId, balance, fiatRate, rateAt, source)
         VALUES (?, '2026-06-30', ?, 100000, 1.0, '2026-07-01T12:00:00.000Z', 'manual')`, [eur, bank]);
    event({ assetId: eur, to: bank, amount: 7_000, at: '2026-07-01T09:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), 100_000);
  });

  it('neemt bij twee ankers de nieuwste vóór het peilmoment', () => {
    balans({ balance: 100_000, at: '2026-03-31T00:00:00.000Z' });
    balans({ balance: 200_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, '2026-05-01T00:00:00.000Z'), 100_000, 'de oudste geldt in mei');
    assert.equal(positionAt(bank, eur, null), 200_000, 'en nu de nieuwste');
  });

  it('kijkt daarbij naar het peilmoment en niet naar de invoervolgorde', () => {
    balans({ balance: 200_000, at: '2026-06-30T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2026-03-31T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), 200_000, 'juni is het nieuwste anker, ook al is maart later ingevoerd');
    assert.equal(anchorAt(bank, eur, null).balance, 200_000);
  });

  it('laat een anker exact óp het peilmoment gelden', () => {
    const moment = '2026-06-30T00:00:00.000Z';
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: moment });
    assert.equal(positionAt(bank, eur, moment), 100_000);
  });

  it('negeert een anker dat ná het peilmoment ligt', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, '2026-02-01T00:00:00.000Z'), 40_000);
  });

  it('kan een negatieve uitkomst geven als er ná het anker meer af gaat dan erop staat', () => {
    balans({ balance: 1_000 });
    event({ assetId: eur, type: 'sell', from: bank, amount: 3_000, at: '2026-08-01T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), -2_000);
  });
});

describe('positionAt hergebruikt de tekenregels van het grootboek', () => {
  it('laat de unitFee van een uitgaande verplaatsing ná het anker meedrukken', () => {
    balans({ balance: 100_000 });
    event({ assetId: eur, type: 'transfer', from: bank, to: kluis, amount: 10_000, unitFee: 250,
            at: '2026-08-01T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), 89_750);
  });

  it('rekent een zelf-transfer ná het anker als alleen de fee', () => {
    balans({ balance: 100_000 });
    event({ assetId: eur, type: 'transfer', from: bank, to: bank, amount: 10_000, unitFee: 250,
            at: '2026-08-01T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), 99_750);
  });

  it('laat een boeking zónder rekening buiten de stand van elke rekening', () => {
    balans({ balance: 100_000 });
    event({ assetId: eur, amount: 60_000, at: '2026-08-01T00:00:00.000Z' });
    assert.equal(positionAt(bank, eur, null), 100_000);
    assert.equal(positionAt(kluis, eur, null), 0);
  });
});

describe('latestAnchors', () => {
  it('geeft per rekening en asset de nieuwste, en laat de portefeuille-brede rijen weg', () => {
    balans({ acc: bank, balance: 100_000, at: '2026-03-31T00:00:00.000Z' });
    balans({ acc: bank, balance: 200_000, at: '2026-06-30T00:00:00.000Z' });
    balans({ acc: kluis, assetId: btc, balance: 50_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ acc: null, balance: 999_999 });
    assert.deepEqual(
      latestAnchors().map(a => ({ accountId: a.accountId, assetId: a.assetId, balance: a.balance })),
      [{ accountId: kluis, assetId: btc, balance: 50_000 }, { accountId: bank, assetId: eur, balance: 200_000 }]);
  });

  it('is leeg zonder waarderingen', () => {
    assert.deepEqual(latestAnchors(), []);
  });
});

describe('positionsByAsset', () => {
  it('is gelijk aan het rauwe aggregaat zolang er geen anker is', () => {
    event({ to: kluis, amount: 100_000 });
    event({ assetId: eur, to: bank, amount: 2_500 });
    assert.deepEqual(positionsByAsset(), assetPositions());
  });

  it('corrigeert de stand van een asset met een anker', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    event({ assetId: eur, type: 'interest', to: bank, amount: 500, at: '2026-07-31T00:00:00.000Z' });
    assert.equal(net('EUR'), 100_500, 'de balans plus de rente erna');
    assert.equal(assetPositions().find(p => p.symbol === 'EUR').net, 40_500, 'het rauwe grootboek zegt iets anders');
  });

  it('telt de ankers van twee rekeningen bij elkaar op', () => {
    const tweede = account('Tweede rekening');
    balans({ acc: bank, balance: 100_000 });
    balans({ acc: tweede, balance: 25_000 });
    assert.equal(net('EUR'), 125_000);
  });

  it('houdt een boeking zónder rekening in het vermogenstotaal', () => {
    event({ assetId: eur, amount: 60_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ acc: bank, balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(net('EUR'), 160_000, 'het anker van de bank plus de rekeningloze boeking');
  });

  it('laat een portefeuille-brede balans het totaal niet verschuiven', () => {
    event({ assetId: eur, to: bank, amount: 2_500 });
    balans({ acc: null, balance: 999_999 });
    assert.equal(net('EUR'), 2_500);
  });

  it('laat de koop-aggregaten ongemoeid', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ balance: 100_000 });
    const rij = positionsByAsset().find(p => p.symbol === 'EUR');
    const rauw = assetPositions().find(p => p.symbol === 'EUR');
    assert.equal(rij.buy_events, rauw.buy_events);
    assert.equal(rij.buy_amount, rauw.buy_amount);
    assert.equal(rij.buy_spot_raw, rauw.buy_spot_raw);
  });

  it('komt uit op de som van de standen per rekening plus wat geen rekening heeft', () => {
    const tweede = account('Tweede rekening');
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-01-01T00:00:00.000Z' });
    event({ assetId: eur, to: tweede, amount: 7_000, at: '2026-02-01T00:00:00.000Z' });
    event({ assetId: eur, amount: 60_000, at: '2026-02-15T00:00:00.000Z' });
    balans({ acc: bank, balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    event({ assetId: eur, type: 'interest', to: bank, amount: 500, at: '2026-07-31T00:00:00.000Z' });

    const perRekening = positionAt(bank, eur, null) + positionAt(tweede, eur, null);
    assert.equal(net('EUR'), perRekening + 60_000);
  });
});

describe('accountPositions', () => {
  it('laat een asset weg waar niets meer op staat', () => {
    event({ assetId: eur, to: bank, amount: 1_000, at: '2026-01-01T00:00:00.000Z' });
    event({ assetId: eur, type: 'sell', from: bank, amount: 1_000, at: '2026-02-01T00:00:00.000Z' });
    assert.deepEqual(accountPositions(bank), []);
  });

  it('ziet een rekening die alleen een balans heeft, en dat is de hele reden', () => {
    balans({ balance: 123_456 });
    assert.deepEqual(accountPositions(bank), [{ assetId: eur, saldo: 123_456 }]);
  });

  it('geeft meerdere assets terug, op id gesorteerd', () => {
    event({ to: bank, amount: 100_000 });
    balans({ balance: 5_000 });
    assert.deepEqual(accountPositions(bank), [{ assetId: btc, saldo: 100_000 }, { assetId: eur, saldo: 5_000 }]);
  });

  it('houdt de rekeningen gescheiden', () => {
    balans({ acc: bank, balance: 5_000 });
    event({ to: kluis, amount: 100_000 });
    assert.deepEqual(accountPositions(kluis), [{ assetId: btc, saldo: 100_000 }]);
  });
});

describe('accountHoldings', () => {
  it('geeft het saldo van nu en de nieuwste balans eronder, niet de boeking erna', () => {
    balans({ balance: 5_000, at: '2026-06-30T00:00:00.000Z' });
    event({ assetId: eur, type: 'sell', from: bank, amount: 1_000, at: '2026-07-15T12:00:00.000Z' });
    assert.deepEqual(accountHoldings([bank]), [{ accountId: bank, assetId: eur, saldo: 4_000,
      anchor: { valuedOn: '2026-06-30', rateAt: '2026-06-30T00:00:00.000Z', balance: 5_000 } }]);
  });

  it('geeft geen anker voor een stand uit alleen boekingen, en volgt de volgorde van de vraag', () => {
    event({ to: kluis, amount: 100_000 });
    balans({ acc: bank, balance: 7_000 });
    const rijen = accountHoldings([kluis, bank]);
    assert.deepEqual(rijen.map(r => r.accountId), [kluis, bank]);
    assert.equal(rijen[0].anchor, null);
    for (const id of [kluis, bank]) {
      assert.deepEqual(rijen.filter(r => r.accountId === id).map(({ assetId, saldo }) => ({ assetId, saldo })),
        accountPositions(id), `hetzelfde saldo als accountPositions voor ${id}`);
    }
  });

  it('laat een leeg paar weg, ook als er een balans van nul onder staat', () => {
    balans({ balance: 0 });
    event({ to: kluis, amount: 1_000, at: '2026-01-01T00:00:00.000Z' });
    event({ type: 'sell', from: kluis, amount: 1_000, at: '2026-02-01T00:00:00.000Z' });
    assert.deepEqual(accountHoldings([bank, kluis]), []);
  });

  it('ziet een balans in de toekomst nog niet als anker van nu', () => {
    balans({ balance: 5_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ balance: 9_999, at: '2099-01-01T00:00:00.000Z' });
    const [rij] = accountHoldings([bank]);
    assert.equal(rij.saldo, 5_000);
    assert.equal(rij.anchor.valuedOn, '2026-01-01');
  });
});

describe('assetPositionsByAccount', () => {
  const som = rijen => rijen.reduce((s, r) => s + r.saldo, 0);

  it('splitst per rekening, de grootste eerst', () => {
    event({ to: kluis, amount: 100_000 });
    event({ to: bank,  amount: 300_000 });
    const rijen = assetPositionsByAccount(btc);
    assert.deepEqual(rijen, [{ accountId: bank, saldo: 300_000 }, { accountId: kluis, saldo: 100_000 }]);
    assert.equal(som(rijen), net('BTC'), 'telt op tot de stand van het asset');
  });

  it('geeft een lege lijst voor een asset waar niets van is', () => {
    assert.deepEqual(assetPositionsByAccount(btc), []);
  });

  it('laat een rekening weg die per saldo leeg is', () => {
    event({ to: kluis, amount: 100_000, at: '2026-01-01T00:00:00.000Z' });
    event({ type: 'sell', from: kluis, amount: 100_000, at: '2026-02-01T00:00:00.000Z' });
    assert.deepEqual(assetPositionsByAccount(btc), []);
  });

  it('ziet een rekening die alleen een balans heeft', () => {
    balans({ acc: bank, assetId: eur, balance: 123_456 });
    const rijen = assetPositionsByAccount(eur);
    assert.deepEqual(rijen, [{ accountId: bank, saldo: 123_456 }]);
    assert.equal(som(rijen), net('EUR'));
  });

  it('houdt een verplaatsing tussen twee eigen rekeningen kloppend', () => {
    event({ to: kluis, amount: 100_000, at: '2026-01-01T00:00:00.000Z' });
    event({ type: 'transfer', from: kluis, to: bank, amount: 40_000, at: '2026-02-01T00:00:00.000Z' });
    const rijen = assetPositionsByAccount(btc);
    assert.deepEqual(rijen, [{ accountId: kluis, saldo: 60_000 }, { accountId: bank, saldo: 40_000 }]);
    assert.equal(som(rijen), net('BTC'), 'een verplaatsing verandert het totaal niet');
  });

  it('zet een aankoop zonder rekening in een eigen rij, achteraan', () => {
    event({ to: kluis, amount: 100_000 });
    event({ amount: 50_000 });
    const rijen = assetPositionsByAccount(btc);
    assert.deepEqual(rijen, [{ accountId: kluis, saldo: 100_000 }, { accountId: null, saldo: 50_000 }]);
    assert.equal(som(rijen), net('BTC'));
  });

  it('verbergt een negatieve rest niet', () => {
    event({ to: kluis, amount: 100_000, at: '2026-01-01T00:00:00.000Z' });
    event({ type: 'sell', amount: 40_000, at: '2026-02-01T00:00:00.000Z' });
    const rijen = assetPositionsByAccount(btc);
    assert.deepEqual(rijen, [{ accountId: kluis, saldo: 100_000 }, { accountId: null, saldo: -40_000 }]);
    assert.equal(som(rijen), net('BTC'), 'en de som klopt nog steeds');
  });

  it('blijft kloppen met een anker erbij', () => {
    event({ assetId: eur, to: bank, amount: 1_000, at: '2026-01-01T00:00:00.000Z' });
    balans({ acc: bank, assetId: eur, balance: 5_000, at: '2026-06-30T00:00:00.000Z' });
    const rijen = assetPositionsByAccount(eur);
    assert.deepEqual(rijen, [{ accountId: bank, saldo: 5_000 }]);
    assert.equal(som(rijen), net('EUR'), 'geen restrij, want het anker zit in allebei de getallen');
  });

  it('respecteert het peilmoment', () => {
    event({ to: kluis, amount: 100_000, at: '2026-01-01T00:00:00.000Z' });
    event({ to: bank,  amount: 300_000, at: '2026-05-01T00:00:00.000Z' });
    assert.deepEqual(assetPositionsByAccount(btc, '2026-03-01T00:00:00.000Z'),
      [{ accountId: kluis, saldo: 100_000 }], 'de tweede rekening bestond toen nog niet');
  });
});

describe('firstPositionDate', () => {
  it('is null als er niets is', () => {
    assert.equal(firstPositionDate(), null);
  });

  it('neemt de eerste gebeurtenis als er geen anker is', () => {
    event({ to: kluis, amount: 1_000, at: '2022-06-01T00:00:00' });
    assert.equal(firstPositionDate(), '2022-06-01T00:00:00');
  });

  it('neemt het eerste anker als er geen gebeurtenis is', () => {
    balans({ at: '2026-06-30T00:00:00.000Z' });
    assert.equal(firstPositionDate(), '2026-06-30T00:00:00.000Z');
  });

  it('neemt de vroegste van de twee, welke van de twee dat ook is', () => {
    event({ to: kluis, amount: 1_000, at: '2022-06-01T00:00:00' });
    balans({ at: '2026-06-30T00:00:00.000Z' });
    assert.equal(firstPositionDate(), '2022-06-01T00:00:00', 'de gebeurtenis was eerder');

    harness.exports.run(`DELETE FROM Event`);
    event({ to: kluis, amount: 1_000, at: '2027-01-01T00:00:00' });
    assert.equal(firstPositionDate(), '2026-06-30T00:00:00.000Z', 'nu was het anker eerder');
  });

  it('kijkt niet naar een portefeuille-brede balans', () => {
    balans({ acc: null, at: '2020-01-01T00:00:00.000Z' });
    event({ to: kluis, amount: 1_000, at: '2022-06-01T00:00:00' });
    assert.equal(firstPositionDate(), '2022-06-01T00:00:00');
  });
});

describe('unexplainedChange', () => {
  const jaar = ['2026-01-01T00:00:00.000Z', '2027-01-01T00:00:00.000Z'];

  it('is nul zonder anker, wat er ook geboekt is', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    event({ assetId: eur, type: 'sell', from: bank, amount: 10_000, at: '2026-05-01T00:00:00.000Z' });
    assert.equal(unexplainedChange(bank, eur, ...jaar), 0);
  });

  it('is de sprong die het anker maakt', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(unexplainedChange(bank, eur, ...jaar), 60_000);
  });

  it('meldt niets als de balans het grootboek bevestigt', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ balance: 40_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(unexplainedChange(bank, eur, ...jaar), 0);
  });

  it('rekent de sprong toe aan het jaar waarin hij valt en niet aan het jaar erna', () => {
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(unexplainedChange(bank, eur, ...jaar), 100_000, 'in 2026 wél');
    assert.equal(unexplainedChange(bank, eur, '2027-01-01T00:00:00.000Z', '2028-01-01T00:00:00.000Z'), 0,
      'in 2027 niet meer');
  });

  it('telt de rente ná het anker niet als onverklaard', () => {
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    event({ assetId: eur, type: 'interest', to: bank, amount: 500, at: '2026-07-31T00:00:00.000Z' });
    assert.equal(unexplainedChange(bank, eur, ...jaar), 100_000, 'alleen de sprong van het anker zelf');
  });

  it('houdt rekeningen en assets gescheiden', () => {
    balans({ acc: bank, balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.equal(unexplainedChange(kluis, eur, ...jaar), 0, 'andere rekening');
    assert.equal(unexplainedChange(bank, btc, ...jaar), 0, 'ander asset');
  });
});

describe('unexplainedByPair', () => {
  const jaar = ['2026-01-01T00:00:00.000Z', '2027-01-01T00:00:00.000Z'];

  it('geeft niets terug als er niets onverklaard is', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ balance: 40_000, at: '2026-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar), [], 'de balans bevestigt het grootboek');
  });

  it('noemt het paar, het aantal eenheden en wat daarvan uit een beginbalans komt', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar),
      [{ accountId: bank, assetId: eur, units: 60_000, openingUnits: 0, hasLedger: true }],
      'er stond een boeking vóór deze balans, dus dit is een verschil dat te boeken valt');
  });

  it('rekent een balans zónder boekingen ervóór toe aan `openingUnits`', () => {
    balans({ acc: kluis, assetId: btc, balance: 5_000_000, at: '2026-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar),
      [{ accountId: kluis, assetId: btc, units: 5_000_000, openingUnits: 5_000_000, hasLedger: false }]);
  });

  it('blijft een beginbalans noemen als er ná die balans wél geboekt is', () => {
    balans({ balance: 159_743, at: '2026-02-01T00:00:00.000Z' });
    event({ assetId: eur, to: bank, amount: 380_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ balance: 539_743, at: '2026-04-01T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar),
      [{ accountId: bank, assetId: eur, units: 159_743, openingUnits: 159_743, hasLedger: true }]);
  });

  it('kijkt naar het grootboek van dát paar en niet van de rekening', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ acc: bank, assetId: btc, balance: 5_000_000, at: '2026-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar),
      [{ accountId: bank, assetId: btc, units: 5_000_000, openingUnits: 5_000_000, hasLedger: false }]);
  });

  it('geeft een negatief bedrag als de boekingen méér verklaren dan de stand veranderde', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    event({ assetId: eur, to: bank, amount: 60_000, at: '2027-03-01T00:00:00.000Z' });
    balans({ balance: 100_000, at: '2027-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair('2027-01-01T00:00:00.000Z', '2028-01-01T00:00:00.000Z'),
      [{ accountId: bank, assetId: eur, units: -60_000, openingUnits: 0, hasLedger: true }]);
  });

  it('rekent een balans exact op het beginmoment aan het jaar ervóór toe', () => {
    balans({ balance: 100_000, at: '2026-01-01T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar), [], 'in 2026 niet meer');
    assert.deepEqual(unexplainedByPair('2025-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'),
      [{ accountId: bank, assetId: eur, units: 100_000, openingUnits: 100_000, hasLedger: false }],
      'maar in 2025 wél, want dáár sprong de stand');
  });

  it('laat die balans ook het afgesplitste deel van het nieuwe jaar niet vervuilen', () => {
    balans({ balance: 100_000, at: '2026-01-01T00:00:00.000Z' });
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    balans({ balance: 200_000, at: '2026-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar),
      [{ accountId: bank, assetId: eur, units: 60_000, openingUnits: 0, hasLedger: true }]);
  });

  it('telt een AANVAARD verschil net zo goed als instap', () => {
    event({ assetId: eur, to: bank, amount: 40_000, at: '2026-03-01T00:00:00.000Z' });
    const id = balans({ balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar),
      [{ accountId: bank, assetId: eur, units: 60_000, openingUnits: 0, hasLedger: true }],
      'vooraf: gewoon een verschil');
    run(`UPDATE Valuation SET gapAcceptedAt = '2026-07-01T00:00:00.000Z' WHERE id = ?`, [id]);
    assert.deepEqual(unexplainedByPair(...jaar),
      [{ accountId: bank, assetId: eur, units: 60_000, openingUnits: 60_000, hasLedger: true }],
      'erna: hetzelfde bedrag, maar nu als stroom');
  });

  it('laat een portefeuille-brede balans buiten de uitsplitsing', () => {
    balans({ acc: null, balance: 100_000, at: '2026-06-30T00:00:00.000Z' });
    assert.deepEqual(unexplainedByPair(...jaar), []);
  });
});

describe('een balans in de toekomst', () => {
  const morgen = new Date(Date.now() + 36 * 3600 * 1000).toISOString();
  const gisteren = new Date(Date.now() - 36 * 3600 * 1000).toISOString();

  it('raakt de stand van nu niet, en geldt wél op een peilmoment erná', () => {
    event({ assetId: eur, to: bank, amount: 10_000, at: gisteren });
    balans({ balance: 999_999, at: morgen });
    assert.equal(positionAt(bank, eur, null), 999_999, 'zonder peilmoment is het "alles", inclusief de toekomst');
    assert.equal(net('EUR'), 10_000, 'maar het portefeuille-totaal van nu kent hem niet');
    assert.deepEqual(accountPositions(bank), [{ assetId: eur, saldo: 10_000 }], 'en de stand per rekening ook niet');
  });

  it('wordt wél het anker als je een peilmoment ná die datum vraagt', () => {
    balans({ balance: 999_999, at: morgen });
    assert.equal(net('EUR'), 0, 'nu nog niet');
    const later = new Date(Date.now() + 72 * 3600 * 1000).toISOString();
    assert.equal(positionsByAsset(later).find(p => p.symbol === 'EUR').net, 999_999, 'straks wel');
  });

  it('houdt ook een boeking met een datum in de toekomst buiten het totaal van nu', () => {
    event({ assetId: eur, to: bank, amount: 10_000, at: gisteren });
    event({ assetId: eur, to: bank, amount: 500_000, at: morgen });
    assert.equal(net('EUR'), 10_000);
    assert.deepEqual(accountPositions(bank), [{ assetId: eur, saldo: 10_000 }]);
  });

  it('laat de assets zonder boeking binnen het venster gewoon in de lijst staan', () => {
    event({ assetId: eur, to: bank, amount: 500_000, at: morgen });
    assert.deepEqual(positionsByAsset().map(p => p.symbol), ['BTC', 'EUR'], 'beide assets staan er nog');
    assert.equal(net('EUR'), 0);
  });
});

describe('lightningBalanceDiffs en recordLightningBalance', () => {
  const GEMETEN = '2026-10-19T10:00:00.000Z';
  function bron(kind, sats, acc = kluis) {
    let conn = null;
    if (kind === 'lnd') {
      run(`INSERT INTO Connection (kind, name, searchName, url, isActive, isSystem, createdAt, updatedAt)
           VALUES ('lnd', ?, ?, 'https://node.test', 1, 0, '2024-01-01', '2024-01-01')`, [`Node ${acc}`, `node ${acc}`]);
      conn = lastId();
    }
    run(`INSERT INTO WalletSource (accountId, connectionId, kind, value, balanceSats, lastScannedAt, createdAt)
         VALUES (?, ?, ?, ?, ?, ?, '2026-01-01')`, [acc, conn, kind, `${kind}-${acc}`, sats, GEMETEN]);
  }
  function adres(sats, acc = kluis) {
    run(`INSERT INTO WalletAddress (accountId, address, balanceSats, createdAt) VALUES (?, ?, ?, '2026-01-01')`,
      [acc, `bc1q-${acc}-${sats}`, sats]);
  }

  it('lightningBalances: per account de node, en NWC alleen zonder node', () => {
    bron('lnd', 70_000);
    bron('nwc', 21_000);
    bron('nwc', 5_000, bank);
    assert.deepEqual(lightningBalances().map(r => [r.accountId, r.sats, r.scannedAt]),
      [[kluis, 70_000, GEMETEN], [bank, 5_000, GEMETEN]]);
  });

  it('meet on-chain plus de node tegen het grootboek, zonder het NWC-saldo erbovenop', () => {
    bron('lnd', 70_000);
    bron('nwc', 21_000);
    adres(30_000);
    event({ to: kluis, amount: 90_000, at: '2026-10-01T00:00:00.000Z' });
    assert.deepEqual(lightningBalanceDiffs().map(d => [d.accountId, d.measured, d.ledger, d.gap]),
      [[kluis, 100_000, 90_000, 10_000]]);
  });

  it('een NWC-wallet zonder LND-node telt wel, en een gelijk grootboek geeft geen rij', () => {
    bron('nwc', 21_000, bank);
    assert.deepEqual(lightningBalanceDiffs().map(d => [d.accountId, d.measured]), [[bank, 21_000]]);
    event({ to: bank, amount: 21_000, at: '2026-10-01T00:00:00.000Z' });
    assert.deepEqual(lightningBalanceDiffs(), []);
  });

  it('vastleggen maakt een balans met het GEMETEN bedrag, waarna de rij verdwijnt', async () => {
    bron('lnd', 70_000);
    const id = await recordLightningBalance(kluis, { valuedOn: '2026-10-19', fiatRate: 60_000, balance: 1 });
    const v = harness.exports.one(`SELECT * FROM Valuation WHERE id = ?`, [id]);
    assert.deepEqual([v.accountId, v.assetId, v.balance, v.rateAt, v.source], [kluis, btc, 70_000, GEMETEN, 'onchain']);
    assert.deepEqual(lightningBalanceDiffs(), []);
  });

  it('vervangt een eerdere meting van dezelfde dag, maar nooit een getypte balans', async () => {
    bron('lnd', 70_000);
    const eerste = await recordLightningBalance(kluis, { valuedOn: '2026-10-19', fiatRate: 60_000 });
    run(`UPDATE WalletSource SET balanceSats = 71000`);
    assert.equal(await recordLightningBalance(kluis, { valuedOn: '2026-10-19', fiatRate: 60_000 }), eerste);
    assert.equal(harness.exports.one(`SELECT balance FROM Valuation WHERE id = ?`, [eerste]).balance, 71_000);
    run(`UPDATE Valuation SET source = 'manual'`);
    await assert.rejects(recordLightningBalance(kluis, { valuedOn: '2026-10-19', fiatRate: 60_000 }),
      e => e.key === 'valuations.lightningSameDay');
  });

  it('weigert een account zonder bijgewerkte lightning-bron, een dag zonder vorm en een koers van nul', async () => {
    await assert.rejects(recordLightningBalance(kluis, { valuedOn: '2026-10-19', fiatRate: 1 }), /no updated lightning source/);
    bron('lnd', 70_000);
    await assert.rejects(recordLightningBalance(kluis, { valuedOn: '19-10-2026', fiatRate: 1 }), /needs its day/);
    await assert.rejects(recordLightningBalance(kluis, { valuedOn: '2026-10-19', fiatRate: 0 }), /rate above zero/);
  });
});