import { expect } from "chai";
import sinon from "sinon";
import { PingPongState } from "../lib/PingPongState";

function createAndStart({ PING_INTERVAL_MS, PONG_TIMEOUT_MS, PING_FLOOD_THRESHOLD }: any) {
    const peerClient = {
        reconnect: sinon.stub(),
        disconnect: sinon.stub(),
        sendMessage: sinon.stub(),
        logger: {
            debug: sinon.stub(),
        },
    };
    const sut = new PingPongState(peerClient as any);
    if (PING_INTERVAL_MS) {
        sut.PING_INTERVAL_MS = PING_INTERVAL_MS;
    }
    if (PONG_TIMEOUT_MS) {
        sut.PONG_TIMEOUT_MS = PONG_TIMEOUT_MS;
    }
    if (PING_FLOOD_THRESHOLD) {
        sut.PING_FLOOD_THRESHOLD = PING_FLOOD_THRESHOLD;
    }
    sut.start();
    return sut;
}

function wait(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

describe("pingpong-state", () => {
    let sut;

    afterEach(() => {
        sut.onDisconnecting();
    });

    describe("when ping interval expires", () => {
        describe("when no message has been received", () => {
            it("it should send a ping", async () => {
                sut = createAndStart({ PING_INTERVAL_MS: 10 });
                await wait(15);
                expect(sut._peerClient.sendMessage.args[0][0]).to.deep.equal({
                    type: 18,
                    numPongBytes: 1,
                    ignored: Buffer.alloc(0),
                });
            });
        });
        describe("when last message is old", () => {
            it("it should send a ping", async () => {
                sut = createAndStart({ PING_INTERVAL_MS: 10 });
                await wait(15);
                sut.onMessage({ type: 258 });
                expect(sut._peerClient.sendMessage.args[0][0]).to.deep.equal({
                    type: 18,
                    numPongBytes: 1,
                    ignored: Buffer.alloc(0),
                });
            });
        });
        describe("when message has been received", () => {
            it("it should not send ping", async () => {
                sut = createAndStart({ PING_INTERVAL_MS: 10 });
                await wait(5);
                sut.onMessage({ type: 258 });
                await wait(10);
                expect(sut._peerClient.sendMessage.callCount).to.equal(0);
            });
        });
    });

    describe("when pong expires", () => {
        it("it should reconnect", async () => {
            sut = createAndStart({ PING_INTERVAL_MS: 10, PONG_TIMEOUT_MS: 1 });
            await wait(15);
            expect(sut._peerClient.reconnect.callCount).to.equal(1);
        });
    });

    describe("when pong received", () => {
        it("it should cancel pong timeout", async () => {
            sut = createAndStart({ PING_INTERVAL_MS: 10, PONG_TIMEOUT_MS: 3 });
            await wait(12);
            sut.onMessage({ type: 19, ignored: Buffer.alloc(1) });
            await wait(5);
            expect(sut._peerClient.disconnect.callCount).to.equal(0);
        });
        it("it should be happy if valid pong", async () => {
            sut = createAndStart({ PING_INTERVAL_MS: 10, PONG_TIMEOUT_MS: 3 });
            await wait(12);
            sut.onMessage({ type: 19, ignored: Buffer.alloc(1) });
            expect(sut._peerClient.disconnect.callCount).to.equal(0);
        });
        it("it should disconnect if invalid pong", async () => {
            sut = createAndStart({ PING_INTERVAL_MS: 10, PONG_TIMEOUT_MS: 3 });
            await wait(12);
            sut.onMessage({ type: 19, ignored: Buffer.alloc(2) });
            expect(sut._peerClient.disconnect.callCount).to.equal(1);
        });
    });

    describe("when ping received", () => {
        it("it should not send ping when numPongBytes gte 65532", () => {
            sut = createAndStart({ PING_INTERVAL_MS: 10, PONG_TIMEOUT_MS: 3 });
            sut.onMessage({ type: 18, numPongBytes: 65532 });
            expect(sut._peerClient.disconnect.callCount).to.equal(0);
        });
        it("it should send correct pong", () => {
            sut = createAndStart({ PING_INTERVAL_MS: 10, PONG_TIMEOUT_MS: 3 });
            sut.onMessage({ type: 18, numPongBytes: 1 });
            expect(sut._peerClient.sendMessage.args[0][0]).to.deep.equal({
                type: 19,
                ignored: Buffer.alloc(1),
            });
        });
        it("it should disconnect if ping flood", () => {
            sut = createAndStart({ PING_FLOOD_THRESHOLD: 2 });
            sut.onMessage({ type: 18, numPongBytes: 1 });
            sut.onMessage({ type: 18, numPongBytes: 1 });
            sut.onMessage({ type: 18, numPongBytes: 1 });
            expect(sut._peerClient.disconnect.callCount).to.equal(1);
        });
    });

    describe("normal ping frequency", () => {
        it("should not trigger disconnect", async () => {
            sut = createAndStart({ PING_FLOOD_THRESHOLD: 2, PING_INTERVAL_MS: 10 });
            sut.onMessage({ type: 18, numPongBytes: 1 });
            await wait(10);
            sut.onMessage({ type: 18, numPongBytes: 1 });
            await wait(10);
            sut.onMessage({ type: 18, numPongBytes: 1 });
            await wait(10);
            sut.onMessage({ type: 18, numPongBytes: 1 });
            await wait(10);
            expect(sut._peerClient.disconnect.callCount).to.equal(0);
        });
    });
});