/* eslint-disable @typescript-eslint/ban-ts-comment */

// @ts-check

/* eslint-env browser, es2020 */

import Replicache from '../out/mod.js';

const valSize = 1024;

function randomString(len) {

var arr = new Uint8Array(len);

crypto.getRandomValues(arr);

return new TextDecoder('ascii').decode(arr);

}

/**

* @param {string} name

*/

function deleteDatabase(name) {

return new Promise((resolve, reject) => {

const req = indexedDB.deleteDatabase(name);

req.onsuccess = resolve;

req.onerror = reject;

});

}

let counter = 0;

async function makeRep() {

const name = `bench${counter++}`;

await deleteDatabase(name);

return new Replicache({

diffServerURL: '',

name,

syncInterval: null,

});

}

/**

* @param {Replicache} rep

*/

async function populate(rep, {numKeys}) {

const set = rep.register('populate', async tx => {

for (let i = 0; i < numKeys; i++) {

await tx.put(`key${i}`, randomString(valSize));

}

});

await set({});

}

async function benchmarkPopulate(bench, opts) {

const rep = await makeRep();

if (!opts.clean) {

await populate(rep, opts);

}

bench.reset();

bench.setName(

`populate ${valSize}x${opts.numKeys} (${opts.clean ? 'clean' : 'dirty'})`,

);

bench.setSize(opts.numKeys * valSize);

await populate(rep, opts);

}

async function benchmarkScan(bench, opts) {

const rep = await makeRep();

bench.setName(`scan ${valSize}x${opts.numKeys}`);

bench.setSize(opts.numKeys * valSize);

await populate(rep, opts);

bench.reset();

await rep.query(async tx => {

let count = 0;

for await (const value of tx.scan()) {

// use the value to be confident we're not optimizing away.

// @ts-ignore

count += value.length;

}

console.log(count);

});

}

async function benchmark(fn) {

const runs = 5;

const times = [];

let sum = 0;

let name = String(fn);

let size = 0;

for (let i = 0; i < runs; i++) {

let t0 = Date.now();

await fn({

reset: () => {

t0 = Date.now();

},

setName: n => (name = n),

setSize: s => (size = s),

});

const dur = Date.now() - t0;

times.push(dur);

sum += dur;

}

console.log(sum);

times.sort();

const median = times[Math.floor(runs / 2)];

const value = toMB((size / median) * 1000) + '/s';

return {name, value, median};

}

const benchmarks = [

bench => benchmarkPopulate(bench, {numKeys: 1000, clean: true}),

bench => benchmarkPopulate(bench, {numKeys: 1000, clean: false}),

bench => benchmarkScan(bench, {numKeys: 1000}),

bench => benchmarkScan(bench, {numKeys: 5000}),

];

function toMB(bytes) {

return (bytes / 2 ** 20).toFixed(2) + ' MB';

}

let current = 0;

async function nextTest() {

if (current < benchmarks.length) {

return await benchmark(benchmarks[current++]);

}

return null;

}

// @ts-ignore

window.nextTest = nextTest;