import { assert } from 'chai';
import { PriorityQueue } from '../../../lib/containers/PriorityQueue';

const ascending = (a: number, b: number) => a - b;
const descending = (a: number, b: number) => b - a;

describe('containers.PriorityQueue', () => {
    it('empty contructor', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const result = [1, 3, 5, 7, 8, 9];
        const output = [];
        const pq = new PriorityQueue();
        assert.strictEqual(pq.capacity, 0);
        assert.strictEqual(pq.size, 0);
        pq.push(...input);
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, input.length);
        while (!pq.isEmpty()) {
            const value = pq.top();
            assert.strictEqual(pq.top(), pq.pop());
            output.push(value);
        }
        assert.deepEqual(output, result);
        assert.isUndefined(pq.pop());
        assert.strictEqual(pq.size, 0);
    });

    it('length contructor', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const result = [1, 3, 5, 7, 8, 9];
        const output = [];
        const pq = new PriorityQueue(input.length);
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, 0);
        pq.push(...input);
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, input.length);
        while (!pq.isEmpty()) {
            const value = pq.top();
            assert.strictEqual(pq.top(), pq.pop());
            output.push(value);
        }
        assert.deepEqual(output, result);
    });

    it('values contructor', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const result = [1, 3, 5, 7, 8, 9];
        const output = [];
        const pq = new PriorityQueue(input);
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, input.length);
        while (!pq.isEmpty()) {
            const value = pq.top();
            assert.strictEqual(pq.top(), pq.pop());
            output.push(value);
        }
        assert.deepEqual(output, result);
    });

    it('array-like contructor', () => {
        const input = { 0: 3, 1: 7, 2: 9, 3: 5, 4: 1, 5: 8, length: 6 };
        const result = [1, 3, 5, 7, 8, 9];
        const output = [];
        const pq = new PriorityQueue(input);
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, input.length);
        while (!pq.isEmpty()) {
            const value = pq.top();
            assert.strictEqual(pq.top(), pq.pop());
            output.push(value);
        }
        assert.deepEqual(output, result);
    });

    it('custom compare', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const result = [9, 8, 7, 5, 3, 1];
        const output = [];
        const pq = new PriorityQueue(descending);
        assert.strictEqual(pq.capacity, 0);
        assert.strictEqual(pq.size, 0);
        pq.push(...input);
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, input.length);
        while (!pq.isEmpty()) {
            const value = pq.top();
            assert.strictEqual(pq.top(), pq.pop());
            output.push(value);
        }
        assert.deepEqual(output, result);
    });

    it('replace', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const result = [1, 2, 3, 7, 8, 9];
        const output = [];
        const pq = new PriorityQueue(input);
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, input.length);
        pq.replace(3, 2);
        while (!pq.isEmpty()) {
            const value = pq.top();
            assert.strictEqual(pq.top(), pq.pop());
            output.push(value);
        }
        assert.deepEqual(output, result);
    });

    it('Symbol.iterator', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const pq = new PriorityQueue(input);
        assert.deepEqual([...pq], [1, 3, 8, 5, 7, 9]);
    });

    it('slice', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const pq = new PriorityQueue(input);
        assert.deepEqual(pq.slice(), [1, 3, 8, 5, 7, 9]);
        assert.deepEqual(pq.slice(1, 4), [3, 8, 5]);
    });

    it('shrinkToFit', () => {
        const input = [3, 7, 9, 5, 1, 8];
        const result = [1, 3, 5, 7, 8, 9];
        const output = [];
        const capacity = 2 * input.length;
        const pq = new PriorityQueue(capacity);
        assert.strictEqual(pq.capacity, capacity);
        assert.strictEqual(pq.size, 0);
        pq.push(...input);
        assert.strictEqual(pq.capacity, capacity);
        assert.strictEqual(pq.size, input.length);
        pq.shrinkToFit();
        assert.strictEqual(pq.capacity, input.length);
        assert.strictEqual(pq.size, input.length);
        while (!pq.isEmpty()) {
            const value = pq.top();
            assert.strictEqual(pq.top(), pq.pop());
            output.push(value);
        }
        assert.deepEqual(output, result);
    });
});