// large checks stream partial diagnostics, and a check is dropped when newer input is already waiting.
// usage: node tests/drivers/stream_test.js path/to/zclsp
const assert = require('assert');
const cp = require('child_process');
const server = process.argv[2];
const frame = m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); };
const doc = (n, tail) => { let t = ''; for (let i = 0; i < n; i++) t += `int f${i}(int a) { return a + ${i}; }\n`; return t + tail; };
function messages(out) {
    const res = [];
    let d = out;
    while (d.length) {
        const e = d.indexOf('\r\n\r\n'), n = Number(/Content-Length:\s*(\d+)/i.exec(d.subarray(0, e).toString())[1]);
        res.push(JSON.parse(d.subarray(e + 4, e + 4 + n))); d = d.subarray(e + 4 + n);
    }
    return res;
}
const published = (msgs, uri) => msgs.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri);
// spawn the server and write each step after the previous one has had time to run (delay in ms)
function session(steps) {
    return new Promise(resolve => {
        const p = cp.spawn(server, process.argv.slice(3));
        let out = Buffer.alloc(0);
        p.stdout.on('data', c => { out = Buffer.concat([out, c]); });
        p.on('exit', () => resolve(messages(out)));
        let at = 0;
        const next = () => {
            if (at >= steps.length) { p.stdin.write(frame({ jsonrpc: '2.0', method: 'exit' })); return; }
            const [delay, msgs] = steps[at++];
            p.stdin.write(Buffer.concat(msgs.map(frame)));
            setTimeout(next, delay);
        };
        next();
    });
}
const init = { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} };
const open = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version, languageId: 'zc', text } } });
const change = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version }, contentChanges: [{ text }] } });
(async () => {
    const A = 'file:///stream.zc';
    // a large document with an error at the top: partial lists arrive before the end, the last holds everything
    const bad = 'int broken( { }\n' + doc(1500, 'fn main() { return f0(1); }\n');
    let msgs = published(await session([[3000, [init, open(A, 1, bad)]]]), A);
    assert.ok(msgs.length >= 2, 'a large check streams several lists: ' + msgs.length);
    assert.ok(msgs[0].params.diagnostics.some(d => d.severity === 1), 'the first list already has the error');
    assert.ok(msgs[msgs.length - 1].params.diagnostics.length >= msgs[0].params.diagnostics.length, 'later lists grow');
    // a change that is already waiting drops the stale check: only the newer version is published
    const ok = doc(1500, 'fn main() { return f0(1); }\n');
    msgs = published(await session([[3000, [init, open(A, 1, ok), change(A, 2, 'fn main() { return 0; }\n')]]]), A);
    assert.ok(msgs.length >= 1 && msgs.every(m => m.params.version === 2), 'the stale version 1 is never published: ' + JSON.stringify(msgs.map(m => m.params.version)));
    // an interrupted open of another document is still answered once nothing newer waits
    const B = 'file:///other.zc';
    msgs = await session([[3000, [init, open(A, 1, ok), open(B, 1, 'fn main() { return 0; }\n')]]]);
    assert.ok(published(msgs, A).length >= 1 && published(msgs, B).length >= 1, 'both documents are published');
    console.log('ok   large checks stream partial diagnostics and drop stale checks');
})();