define([
	'intern!tdd',
	'intern/chai!assert',
	'dojo/_base/declare',
	'dojo/keys',
	'dojo/on',
	'dojo/query',
	'dojo/string',
	'dgrid/Grid',
	'dgrid/OnDemandList',
	'dgrid/extensions/Pagination',
	'dgrid/test/data/createSyncStore',
	'dgrid/test/data/genericData',
	'dojo/domReady!'
], function (test, assert, declare, keys, on, query, string, Grid, OnDemandList, Pagination, createSyncStore,
			 genericData) {
	var grid,
		PaginationGrid = declare([Grid, Pagination]);

	function getColumns() {
		return {
			id: 'id',
			col1: 'Column 1',
			col2: 'Column 2',
			col5: 'Column 5'
		};
	}

	function createTestStore() {
		return createSyncStore({ data: genericData });
	}

	function createGrid(factoryFn) {
		// Make sure there is only one grid on the page at a time.
		if (grid) {
			grid.destroy();
		}
		grid = factoryFn();
		document.body.appendChild(grid.domNode);
		grid.startup();
	}

	test.suite('Pagination', function () {
		test.beforeEach(function () {
			createGrid(function () {
				return new PaginationGrid({
					collection: createTestStore(),
					columns: getColumns()
				});
			});
		});

		test.afterEach(function () {
			grid.destroy();
		});

		test.test('Pagination info updates on page switch', function () {
			// switch pages and ensure that the status message and links are
			// updated
			var disabledLinks = query('span.dgrid-page-disabled', grid.paginationLinksNode),
				expectedText = string.substitute(grid.i18nPagination.status,
					{ start: 1, end: 10, total: 100 });

			function testAssertions(expectedPage) {
				assert.strictEqual(grid.paginationStatusNode.innerHTML, expectedText,
					'should find expected status message; received \'' + status + '\'');
				assert.strictEqual(disabledLinks.length, 1,
					'should find expected number of disabled page links: found ' +
					disabledLinks.length);
				assert.strictEqual(string.trim(disabledLinks[0].innerHTML), expectedPage,
					'link for active page (' + expectedPage + ') should be disabled');
				for (var i = 0; i < disabledLinks.length; i++) {
					assert.equal(disabledLinks[i].tabIndex, -1, 'disabled link should have -1 tabIndex');
				}
			}

			testAssertions('1');

			grid.gotoPage(2);
			disabledLinks = query('span.dgrid-page-disabled', grid.paginationLinksNode);
			expectedText = string.substitute(grid.i18nPagination.status, {start: 11, end: 20, total: 100});

			testAssertions('2');
		});

		test.test('Pagination info updates when an item is added/removed', function () {
			function testAssertions(expectedTotal, expectedLastPage) {
				assert.strictEqual(grid.paginationStatusNode.innerHTML,
					string.substitute(grid.i18nPagination.status, {
						start: 1,
						end: 10,
						total: expectedTotal
					}),
					'total displayed in status area should be ' + expectedTotal
				);
				assert.strictEqual(grid.paginationLinksNode.lastChild.innerHTML, '' + expectedLastPage,
					'last page number displayed should be ' + expectedLastPage);
			}

			testAssertions(100, 10);

			grid.collection.addSync({ id: 100 });
			testAssertions(101, 11);

			grid.collection.removeSync(100);
			testAssertions(100, 10);
		});

		test.test('Should not pass 0 to gotoPage when removing last item (#1192)', function() {
			var store = createSyncStore({ data: [ { id: 1 } ] });
			grid.set('collection', store);

			var pageNumber;
			grid.gotoPage = function (page) {
				pageNumber = page;
			};

			store.removeSync(1);
			assert.strictEqual(pageNumber, 1, 'Should have refreshed page 1 after removing the last item');

			store.putSync({ id: 2 });
			assert.strictEqual(pageNumber, 1, 'Should have refreshed page 1 after adding the first item');
		});
	});

	test.suite('Pagination size selector initialization tests', function () {
		// Each test in this suite is responsible for instantiating the grid
		test.afterEach(function () {
			grid.destroy();
		});

		test.test('pageSizeOptions + unique rowsPerPage during creation', function () {
			createGrid(function () {
				return new PaginationGrid({
					collection: createTestStore(),
					columns: getColumns(),
					// Purposely set pageSizeOptions out of order to test setter
					pageSizeOptions: [25, 15, 5],
					// Purposely set rowsPerPage to a value not in pageSizeOptions
					rowsPerPage: 10
				});
			});

			assert.strictEqual(grid.paginationSizeSelect.tagName, 'SELECT',
				'paginationSizeSelect should reference a SELECT element');
			assert.lengthOf(grid.pageSizeOptions, 4,
				'pageSizeOptions should have additional item for unique rowsPerPage');
			assert.strictEqual(grid.pageSizeOptions[0], 5,
				'pageSizeOptions should be sorted ascending');

			// Now empty pageSizeOptions and confirm that the select was removed
			grid.set('pageSizeOptions', null);
			assert.isNull(grid.paginationSizeSelect,
				'paginationSizeSelect reference should be cleared after setting empty pageSizeOptions');
			assert.strictEqual(query('select', grid.footerNode).length, 0,
				'paginationSizeSelect node should have been destroyed');
		});

		test.test('pageSizeOptions added after creation', function () {
			createGrid(function () {
				return new PaginationGrid({
					collection: createTestStore(),
					columns: getColumns(),
					rowsPerPage: 10
				});
			});

			assert.isUndefined(grid.paginationSizeSelect,
				'paginationSizeSelect should not exist yet (no options)');

			// Now add pageSizeOptions (purposely out of order) and confirm it
			// is properly added
			grid.set('pageSizeOptions', [25, 15, 5]);

			assert.strictEqual(grid.paginationSizeSelect.tagName, 'SELECT',
				'paginationSizeSelect should reference a SELECT element');
			assert.lengthOf(grid.pageSizeOptions, 4,
				'pageSizeOptions should have additional item for unique rowsPerPage');
			assert.strictEqual(grid.pageSizeOptions[0], 5,
				'pageSizeOptions should be sorted ascending');
		});

		test.test('hitting "Enter" key in pagination page input changes page', function () {
			createGrid(function () {
				return new PaginationGrid({
					collection: createTestStore(),
					columns: getColumns(),
					pagingTextBox: true
				});
			});

			var textbox = query('.dgrid-page-input', grid.paginationLinksNode)[0];
			assert.strictEqual(grid._currentPage, 1, 'Initial page should be 1');
			textbox.value = '2';
			on.emit(textbox, 'keypress', { keyCode: keys.ENTER });
			assert.strictEqual(grid._currentPage, 2, 'Grid should change to page 2');
		});
	});

	test.suite('Pagination size selector', function () {
		test.before(function () {
			createGrid(function () {
				return new PaginationGrid({
					collection: createTestStore(),
					columns: getColumns(),
					pageSizeOptions: [5, 10, 15]
				});
			});
		});
		test.after(function () {
			if (grid) {
				grid.destroy();
				grid = undefined;
			}
		});

		function verifyOptions(options, expectedCount) {
			// verify that the values of the given set of options are in increasing order
			// optionally verify that there are the expected number of options
			var opt,
				lastVal = options[0].value;
			for (var i = 1; i < options.length; i++) {
				opt = options[i];
				assert.isTrue(+lastVal < +opt.value, 'values should be in order');
				lastVal = opt.value;
			}
			if (expectedCount !== undefined) {
				assert.lengthOf(options, expectedCount,
					'selector should have expected number of options');
			}
		}

		function rowsPerPageTest(rowsPerPage) {
			// update the grid's rowsPerPage and ensure that the selector value
			// is correct afterwards
			var select = grid.paginationSizeSelect;
			grid.set('rowsPerPage', rowsPerPage);
			assert.strictEqual(select.value, '' + rowsPerPage,
				'size select should have expected value ' + select.value);
			verifyOptions(select.options);
		}

		function getNonSelectedValue(options) {
			// return a value that isn't selected, assuming there are at least
			// two options and unique option values
			if (options[0].selected) {
				return options[1].value;
			} else {
				return options[0].value;
			}
		}

		test.test('setting rowsPerPage to a low value properly updates select', function () {
			rowsPerPageTest(2);
		});

		test.test('setting rowsPerPage properly updates select', function () {
			rowsPerPageTest(7);
		});

		test.test('setting rowsPerPage to a high value properly updates select', function () {
			rowsPerPageTest(20);
		});

		test.test('setting rowsPerPage to an existing value doesn\'t add a value', function () {
			var selector = grid.paginationSizeSelect,
				initialCount = selector.options.length,
				value = getNonSelectedValue(selector.options);
			grid.set('rowsPerPage', +value);
			assert.strictEqual(selector.value, value,
				'size select should have expected value ' + selector.value);
			verifyOptions(selector.options, initialCount);
		});

		test.test('selecting a value from the selector doesn\'t change the selector options', function () {
			var selector = grid.paginationSizeSelect,
				initialCount = selector.options.length,
				targetValue = getNonSelectedValue(selector.options);

			// TODO: this would do better as a functional test;
			// as-is, we need to emit a change event manually
			selector.value = targetValue;
			on.emit(selector, 'change', {});
			assert.strictEqual(selector.value, targetValue,
				'size select should have expected value ' + selector.value);
			assert.strictEqual(+targetValue, grid.rowsPerPage,
				'rowsPerPage should have numeric value equivalent to the selected value');
			verifyOptions(selector.options, initialCount);
		});
	});

	test.suite('Pagination with OnDemandGrid', function () {
		var badList;
		var builtInWarn;

		test.afterEach(function () {
			if (badList) {
				badList.destroy();
				badList = undefined;
			}
			if (builtInWarn) {
				console.warn = builtInWarn;
				builtInWarn = undefined;
			}
		});

		test.test('Invalid list+pagination combination', function () {
			// When the Pagination extension is used with OnDemandList, a warning should appear in the console
			// telling the dev that they have constructed an invalid class combination.
			var warnCalled = true;
			builtInWarn = console.warn;
			console.warn = function (message) {
				warnCalled = true;
				assert.strictEqual('The Pagination extension is not compatible with dgrid/OnDemandList and ' +
					'dgrid/OnDemandGrid. Please use dgrid/List or dgrid/Grid as a base class.', message);
			};

			var BadList = declare([OnDemandList, Pagination]);
			badList = new BadList({});
			document.body.appendChild(badList.domNode);
			badList.startup();

			// Make sure OnDemandList implements the method the Pagination extension is looking for.  If
			// the method is missing, the warning will not be generated.
			assert.isTrue(badList._processScroll != null);
			assert.isTrue(warnCalled);
		});
	});
});