define([
	'intern!tdd',
	'intern/chai!assert',
	'dojo/_base/lang',
	'dojo/_base/declare',
	'dojo/aspect',
	'dojo/Deferred',
	'dijit/form/TextBox',
	'dgrid/Editor',
	'dgrid/OnDemandList',
	// column.set can't be tested independently from a Grid,
	// so we are testing through OnDemandGrid for now.
	'dgrid/OnDemandGrid',
	'dgrid/ColumnSet',
	'dgrid/test/data/createSyncStore',
	'dgrid/test/data/genericData',
	'dojo/domReady!'
], function (test, assert, lang, declare, aspect, Deferred, TextBox, Editor,
		OnDemandList, OnDemandGrid, ColumnSet, createSyncStore, genericData) {

	// Helper method used to set column set() methods for various grid compositions
	function testSetMethod(grid, dfd) {
		var store = createSyncStore({ data: genericData });
		grid.set('collection', store);
		document.body.appendChild(grid.domNode);
		grid.startup();

		var changes = [
				{
					objectId: 0,
					field: 'col1',
					newValue: 'sleepy',
					expectedSavedValue: 'SLEEPY'
				},
				{
					objectId: 1,
					field: 'col3',
					newValue: 'dopey',
					expectedSavedValue: 'DOPEY'
				},
				{
					objectId: 2,
					field: 'col4',
					newValue: 'rutherford',
					expectedSavedValue: 'RUTHERFORD'
				}
			],
			len = changes.length,
			i,
			change;

		for (i = 0; i < len; i++) {
			change = changes[i];
			grid.updateDirty(change.objectId, change.field, change.newValue);
		}

		grid.save().then(
			dfd.callback(function () {
				for (var i = 0, change; i < changes.length; i++) {
					change = changes[i];
					assert.strictEqual(store.getSync(change.objectId)[change.field],
						change.expectedSavedValue);
				}
			}),
			lang.hitch(dfd, 'reject')
		);

		return dfd;
	}

	// the set() method to use for column.set() tests
	function sampleSetMethod(item) {
		return item[this.field].toUpperCase();
	}

	test.suite('_StoreMixin', function () {
		var grid; // Reused for each test and common afterEach logic

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

		test.suite('_StoreMixin#_setCollection', function () {
			var store;

			test.beforeEach(function () {
				store = createSyncStore({ data: genericData });
				grid = new OnDemandList({
					collection: store
				});
				document.body.appendChild(grid.domNode);
				grid.startup();
			});

			test.test('null', function () {
				assert.isDefined(grid._renderedCollection,
					'grid._renderedCollection should be defined');
				assert.notStrictEqual(grid.contentNode.children.length, 0,
					'grid.contentNode should contain children when refreshing with a store');

				grid.set('collection', null);
				assert.isNull(grid._renderedCollection,
					'grid._renderedCollection should be null after setting collection to null');
				assert.strictEqual(grid.contentNode.children.length, 1,
					'grid.contentNode should contain one child when refreshing with a null collection');
				assert.strictEqual(grid.contentNode.children[0], grid.noDataNode,
					'grid.contentNode should contain the noDataNode');

				grid.set('collection', store);
				assert.isNotNull(grid._renderedCollection,
					'grid._renderedCollection should not be null after setting collection to store again');
				assert.notStrictEqual(grid.contentNode.children.length, 0,
					'grid.contentNode should contain children when refreshing with a store');
			});

			test.test('dirty data preservation/cleanup', function () {
				grid.updateDirty(0, 'col1', 'modified');
				assert.isDefined(grid.dirty[0], 'Dirty hash should contain entry for item 0 after updateDirty');
				grid.set('sort', 'col3');
				assert.isDefined(grid.dirty[0], 'Dirty hash should still contain entry for item 0 after sort');
				grid.set('collection', store.filter({ col2: false }));
				assert.isDefined(grid.dirty[0], 'Dirty hash should still contain entry for item 0 after filter');
				grid.set('collection', createSyncStore({ data: genericData }));
				assert.isUndefined(grid.dirty[0],
					'Dirty hash should be cleared after setting collection based on different store');
			});
		});


		test.suite('set collection before startup', function () {
			test.test('should not cause superfluous refresh',  function () {
				var numCalls = 0;

				grid = new OnDemandList();

				aspect.before(grid, 'refresh', function () {
					numCalls++;
				});

				grid.set('collection', createSyncStore(genericData));
				document.body.appendChild(grid.domNode);
				grid.startup();

				assert.strictEqual(numCalls, 1, 'refresh should only have been called once');
			});

			test.test('store modifications before startup', function () {
				var numCalls = 0;
				var store = createSyncStore({ data: genericData });

				grid = new OnDemandList({
					columns: {
						col1: 'Column 1',
						col2: 'Column 2'
					}
				});

				var insertHandle = aspect.after(grid, 'insertRow', function (row) {
					numCalls++;
					return row;
				});

				var removeHandle = aspect.after(grid, 'removeRow', function () {
					numCalls++;
				});

				var destroyHandle = aspect.after(grid, 'destroy', function () {
					destroyHandle.remove();
					insertHandle.remove();
					removeHandle.remove();
				});

				document.body.appendChild(grid.domNode);

				grid.set('collection', store);
				store.addSync({
					col1: 'inserted value',
					col2: true
				});

				var item = store.getSync(1);
				item.col1 = 'this has changed';
				store.putSync(item);

				assert.strictEqual(numCalls, 0,
					'Should not react to store item modifications');

				grid.startup();
				assert.isTrue(numCalls > 0,
					'Rows should appear inserted after startup');
			});
		});

		test.test('_StoreMixin#_onNotification', function () {
			var store = createSyncStore({ data: genericData }),
				notificationCount = 0,
				lastNotificationEvent = null;

			grid = new OnDemandList({
				collection: store,
				_onNotification: function (rows, event) {
					notificationCount++;
					lastNotificationEvent = event;
				}
			});
			document.body.appendChild(grid.domNode);
			grid.startup();

			var item = store.getSync(1);
			store.removeSync(item.id);
			assert.equal(notificationCount, 1);
			assert.isNotNull(lastNotificationEvent);
			assert.equal(lastNotificationEvent.type, 'delete');
			assert.equal(lastNotificationEvent.id, item.id);

			lastNotificationEvent = null;
			store.addSync(item);
			assert.equal(notificationCount, 2);
			assert.isNotNull(lastNotificationEvent);
			assert.equal(lastNotificationEvent.type, 'add');
			assert.equal(lastNotificationEvent.target, item);

			item.col1 = 'changed';
			lastNotificationEvent = null;
			store.putSync(item);
			assert.equal(notificationCount, 3);
			assert.isNotNull(lastNotificationEvent);
			assert.equal(lastNotificationEvent.type, 'update');
			assert.equal(lastNotificationEvent.target, item);
		});

		test.suite('_StoreMixin#_trackError', function () {
			var emittedErrorCount,
				lastEmittedError,
				expectedValue;

			function expectedSuccess(actualValue) {
				assert.strictEqual(actualValue, expectedValue,
					'Resolved promise should yield expected value');
				assert.strictEqual(emittedErrorCount, 0,
					'dgrid-error event should not have fired');
			}
			function expectedError(error) {
				assert.strictEqual(error.message, expectedValue,
					'An error with the expected message should be thrown');
				assert.strictEqual(emittedErrorCount, 1,
					'A dgrid-error event should have fired');
				assert.strictEqual(lastEmittedError, error,
					'The error should be accessible from the dgrid-error event');
			}
			function unexpectedSuccess() {
				throw new Error('Unexpected resolution');
			}

			test.beforeEach(function () {
				grid = new OnDemandList();

				grid.on('dgrid-error', function (event) {
					emittedErrorCount++;
					lastEmittedError = event.error;
				});

				emittedErrorCount = 0;
				lastEmittedError = null;
			});

			test.test('_StoreMixin#_trackError - sync value', function () {
				expectedValue = 'expected';
				return grid._trackError(function () {
					return expectedValue;
				}).then(expectedSuccess);
			});

			test.test('_StoreMixin#_trackError - async value', function () {
				expectedValue = 'expected-async';
				return grid._trackError(function () {
					var dfd = new Deferred();
					setTimeout(function () {
						dfd.resolve(expectedValue);
					}, 100);
					return dfd.promise;
				}).then(expectedSuccess);
			});

			test.test('_StoreMixin#_trackError - sync error', function () {
				expectedValue = 'expected-error';
				return grid._trackError(function () {
					throw new Error(expectedValue);
				}).then(unexpectedSuccess, expectedError);
			});

			test.test('_StoreMixin#_trackError - async error', function () {
				// async error
				expectedValue = 'expected-async-error';
				return grid._trackError(function () {
					var dfd = new Deferred();
					setTimeout(function () {
						dfd.reject(new Error(expectedValue));
					}, 100);
					return dfd.promise;
				}).then(unexpectedSuccess, expectedError);
			});
		});

		test.suite('_StoreMixin#refreshCell', function () {
			var store;

			test.beforeEach(function () {
				store = createSyncStore({ data: genericData });
				grid = new (declare([ OnDemandGrid, Editor ]))({
					columns: {
						col1: 'Column 1',
						col3: {
							label: 'Column 3',
							editor: TextBox
						}
					},
					collection: store,
					shouldTrackCollection: false
				});
				document.body.appendChild(grid.domNode);
				grid.startup();
			});

			test.test('no change', function () {
				var cell = grid.cell('2', 'col1');
				var oldValue = cell.element.innerHTML;

				return grid.refreshCell(cell).then(function () {
					assert.strictEqual(cell.element.innerHTML, oldValue, 'Displayed cell value should not change');
				});
			});

			test.test('dirty change', function () {
				var cell = grid.cell('2', 'col1');
				var newValue = 'new value';

				grid.updateDirty(2, 'col1', newValue);
				return grid.refreshCell(cell).then(function () {
					assert.strictEqual(cell.element.innerHTML, newValue, 'Displayed cell value should change');
				});
			});

			test.test('store change', function () {
				var cell = grid.cell('2', 'col1');
				var oldValue = cell.element.innerHTML;
				var newValue = 'new value';

				var item = cell.row.data;
				item.col1 = newValue;
				grid.collection.putSync(item);
				assert.strictEqual(cell.element.innerHTML, oldValue, 'Displayed cell value should not change');

				return grid.refreshCell(cell).then(function () {
					assert.strictEqual(cell.element.innerHTML, newValue, 'Displayed cell value should change');
				});
			});
		});

		test.suite('_StoreMixin#save', function () {
			var store;

			test.beforeEach(function () {
				store = createSyncStore({ data: genericData });
				grid = new OnDemandList({
					collection: store
				});
				document.body.appendChild(grid.domNode);
				grid.startup();
			});

			test.test('API', function () {
				this.async(1000);
				grid.updateDirty(0, 'col1', 'important');
				grid.updateDirty(1, 'col1', 'normal');

				return grid.save().then(function (results) {
					assert.strictEqual(results.toString(), '[object Object]', 'Resolved value should be an object');
					assert.strictEqual(results[0], store.getSync(0),
						'Each key in results should correspond to a saved item (0)');
					assert.strictEqual(results[1], store.getSync(1),
						'Each key in results should correspond to a saved item (1)');
				});
			});

			test.test('Should return promise even if nothing needs to be put', function () {
				this.async(1000);
				var promise = grid.save();
				assert.isDefined(promise.then, 'grid.save() should return a promise');
				return promise.then(function (results) {
					assert.strictEqual(results.toString(), '[object Object]', 'Resolved value should be an object');
					var count = 0;
					// jshint unused: false
					for (var k in results) {
						count++;
					}
					assert.strictEqual(count, 0, 'Resolved object should have no keys');
				});
			});
		});

		test.suite('_StoreMixin#save / column.set tests', function () {
			test.test('column.set in subRows', function () {
				grid = new OnDemandGrid({
					subRows: [
						[
							{ label: 'Column 1', field: 'col1', set: sampleSetMethod },
							{ label: 'Column 2', field: 'col2', sortable: false },
							{ label: 'Column 1', field: 'col1', rowSpan: 2 },
							{ label: 'Column 4', field: 'col4', set: sampleSetMethod }
						],
						[
							{ label: 'Column 3', field: 'col3', colSpan: 2, set: sampleSetMethod },
							{ label: 'Column 5', field: 'col5' }
						]
					]
				});
				testSetMethod(grid, this.async(1000));
			});

			test.test('column.set in columnSets', function () {
				grid = new (declare([OnDemandGrid, ColumnSet]))({
					columnSets: [
						[
							[
								{ label: 'Column 1', field: 'col1', set: sampleSetMethod },
								{ label: 'Column 2', field: 'col2', sortable: false }
							],
							[
								{label: 'Column 3', field: 'col3', colSpan: 2, set: sampleSetMethod }
							]
						],
						[
							[
								{ label: 'Column 1', field: 'col1', rowSpan: 2 },
								{ label: 'Column 4', field: 'col4', set: sampleSetMethod }
							],
							[
								{ label: 'Column 5', field: 'col5' }
							]
						]
					]
				});
				testSetMethod(grid, this.async(1000));
			});
		});
	});
});