/*
 * Tests the "filter", "filterSeries", and "filterLimit" functions
 */

var mod_util = require('util');

var mod_tap = require('tap');
var mod_vasync = require('..');

mod_tap.test('filterSeries', function (test) {
	var inputs = [0, 1, 2, 3, 4, 5];
	var curTasks = 0;
	var maxTasks = 0;
	// filterSeries has an implicit limit of 1 concurrent operation
	var limit = 1;

	function filterFunc(input, cb) {
		curTasks++;
		if (curTasks > maxTasks) {
			maxTasks = curTasks;
		}
		test.ok(curTasks <= limit, mod_util.format(
		    'input %d: current tasks %d <= %d',
		    input, curTasks, limit));

		setTimeout(function () {
			curTasks--;
			cb(null, input < 2 || input === 4);
		}, 50);
	}

	mod_vasync.filterSeries(inputs, filterFunc,
	    function filterDone(err, results) {

		test.ok(!err, 'error unset');
		test.equal(maxTasks, limit, 'max tasks reached limit');
		test.deepEqual(results, [0, 1, 4], 'results array correct');
		test.end();
	});
});

mod_tap.test('filterLimit', function (test) {
	var inputs = [0, 1, 2, 3, 4, 5];
	var curTasks = 0;
	var maxTasks = 0;
	var limit = 2;

	function filterFunc(input, cb) {
		curTasks++;
		if (curTasks > maxTasks) {
			maxTasks = curTasks;
		}
		test.ok(curTasks <= limit, mod_util.format(
		    'input %d: current tasks %d <= %d',
		    input, curTasks, limit));

		setTimeout(function () {
			curTasks--;
			cb(null, input < 2 || input === 4);
		}, 50);
	}

	mod_vasync.filterLimit(inputs, limit, filterFunc,
	    function filterDone(err, results) {

		test.ok(!err, 'error unset');
		test.equal(maxTasks, limit, 'max tasks reached limit');
		test.deepEqual(results, [0, 1, 4], 'results array correct');
		test.end();
	});
});

mod_tap.test('filter (maintain order)', function (test) {
	var inputs = [0, 1, 2, 3, 4, 5];
	var limit = inputs.length;
	var storedValues = [];

	function filterFunc(input, cb) {
		/*
		 * Hold every callback in an array to be called when all
		 * filterFunc's have run.  This way, we can ensure that all
		 * tasks have started without waiting for any others to finish.
		 */
		storedValues.push({
			input: input,
			cb: cb
		});

		test.ok(storedValues.length <= limit, mod_util.format(
		    'input %d: current tasks %d <= %d',
		    input, storedValues.length, limit));

		/*
		 * When this constraint is true, all filterFunc's have run for
		 * each input.  We now call all callbacks in a pre-determined
		 * order (out of order of the original) to ensure the final
		 * array is in the correct order.
		 */
		if (storedValues.length === inputs.length) {
			[5, 2, 0, 1, 4, 3].forEach(function (i) {
				var o = storedValues[i];
				o.cb(null, o.input < 2 || o.input === 4);
			});
		}
	}

	mod_vasync.filter(inputs, filterFunc,
	    function filterDone(err, results) {

		test.ok(!err, 'error unset');
		test.equal(storedValues.length, inputs.length,
		    'max tasks reached limit');
		test.deepEqual(results, [0, 1, 4], 'results array correct');
		test.end();
	});
});

mod_tap.test('filterSeries error handling', function (test) {
	/*
	 * We will error half way through the list of inputs to ensure that
	 * first half are processed while the second half are ignored.
	 */
	var inputs = [0, 1, 2, 3, 4, 5];

	function filterFunc(input, cb) {
		switch (input) {
		case 0:
		case 1:
		case 2:
			cb(null, true);
			break;
		case 3:
			cb(new Error('error on ' + input));
			break;
		case 4:
		case 5:
			test.ok(false, 'processed too many inputs');
			cb(new Error('processed too many inputs'));
			break;
		default:
			test.ok(false, 'unexpected input: ' + input);
			cb(new Error('unexpected input'));
			break;
		}
	}

	mod_vasync.filterSeries(inputs, filterFunc,
	    function filterDone(err, results) {

		test.ok(err, 'error set');
		test.ok(err.message === 'error on 3', 'error on input 3');
		test.ok(results === undefined, 'results is unset');
		test.end();
	});
});

mod_tap.test('filterSeries double callback', function (test) {
	var inputs = [0, 1, 2, 3, 4, 5];

	function filterFunc(input, cb) {
		switch (input) {
		case 0:
		case 1:
		case 2:
			cb(null, true);
			break;
		case 3:
			/*
			 * The first call to cb() should "win" - meaning this
			 * value will be filtered out of the final array of
			 * results.
			 */
			cb(null, false);
			test.throws(function () {
				cb(null, true);
			});
			break;
		case 4:
			/*
			 * Like input 3, all subsequent calls to cb() will
			 * throw an error and not affect the original call to
			 * cb().
			 */
			cb(null, true);
			test.throws(function () {
				cb(new Error('uh oh'));
			});
			break;
		case 5:
			cb(null, true);
			break;
		default:
			test.ok(false, 'unexpected input: ' + input);
			cb(new Error('unexpected input'));
			break;
		}
	}

	mod_vasync.filterSeries(inputs, filterFunc,
	    function filterDone(err, results) {

		test.ok(!err, 'error not set');
		test.deepEqual(results, [0, 1, 2, 4, 5],
		    'results array correct');
		test.end();
	});
});

mod_tap.test('filter push to queue object error', function (test) {
	var inputs = [0, 1, 2, 3, 4, 5];

	function filterFunc(input, cb) {
		cb(null, true);
	}

	var q = mod_vasync.filterSeries(inputs, filterFunc,
	    function filterDone(err, results) {

		test.end();
	});

	test.equal(q.closed, true, 'queue is closed');
	test.throws(function () {
		q.push(6);
	});
});