"use strict";

describe("Zotero.Sync.Data.Local", function() {
	describe("#getAPIKey()/#setAPIKey()", function () {
		it("should get and set an API key", function* () {
			var apiKey1 = Zotero.Utilities.randomString(24);
			var apiKey2 = Zotero.Utilities.randomString(24);
			Zotero.Sync.Data.Local.setAPIKey(apiKey1);
			assert.equal(Zotero.Sync.Data.Local.getAPIKey(apiKey1), apiKey1);
			Zotero.Sync.Data.Local.setAPIKey(apiKey2);
			assert.equal(Zotero.Sync.Data.Local.getAPIKey(apiKey2), apiKey2);
		})
		
		
		it("should clear an API key by setting an empty string", function* () {
			var apiKey = Zotero.Utilities.randomString(24);
			Zotero.Sync.Data.Local.setAPIKey(apiKey);
			Zotero.Sync.Data.Local.setAPIKey("");
			assert.strictEqual(Zotero.Sync.Data.Local.getAPIKey(apiKey), "");
		})
	})
	
	
	describe("#checkUser()", function () {
		var win;
		
		beforeEach(function* () {
			win = yield loadBrowserWindow();
		});
		
		afterEach(function () {
			win.close();
		});
		
		it("should prompt for user update and perform on accept", function* () {
			yield Zotero.Users.setCurrentUserID(1);
			yield Zotero.Users.setCurrentUsername("A");
			
			var handled = false;
			waitForDialog(function (dialog) {
				var text = dialog.document.documentElement.textContent;
				var matches = text.match(/‘[^’]*’/g);
				assert.equal(matches.length, 4);
				assert.equal(matches[0], "‘A’");
				assert.equal(matches[1], "‘B’");
				assert.equal(matches[2], "‘B’");
				assert.equal(matches[3], "‘A’");
				handled = true;
			});
			var cont = yield Zotero.Sync.Data.Local.checkUser(win, 2, "B");
			assert.isTrue(handled);
			assert.isTrue(cont);
			
			assert.equal(Zotero.Users.getCurrentUserID(), 2);
			assert.equal(Zotero.Users.getCurrentUsername(), "B");
		})
		
		it("should prompt for user update and cancel", function* () {
			yield Zotero.Users.setCurrentUserID(1);
			yield Zotero.Users.setCurrentUsername("A");
			
			waitForDialog(false, 'cancel');
			var cont = yield Zotero.Sync.Data.Local.checkUser(win, 2, "B");
			assert.isFalse(cont);
			
			assert.equal(Zotero.Users.getCurrentUserID(), 1);
			assert.equal(Zotero.Users.getCurrentUsername(), "A");
		})
		
		it("should update local relations when syncing for the first time", function* () {
			yield resetDB({
				thisArg: this,
				skipBundledFiles: true
			});
			
			var item1 = yield createDataObject('item');
			var item2 = yield createDataObject(
				'item', { libraryID: Zotero.Libraries.publicationsLibraryID }
			);
			
			yield item1.addLinkedItem(item2);
			
			var cont = yield Zotero.Sync.Data.Local.checkUser(win, 1, "A");
			assert.isTrue(cont);
			
			var json = item1.toJSON();
			var uri = json.relations[Zotero.Relations.linkedObjectPredicate][0];
			assert.notInclude(uri, 'users/local');
			assert.include(uri, 'users/1/publications');
		})
	});
	
	
	describe("#getLatestCacheObjectVersions", function () {
		before(function* () {
			yield resetDB({
				thisArg: this,
				skipBundledFiles: true
			});
			
			yield Zotero.Sync.Data.Local.saveCacheObjects(
				'item',
				Zotero.Libraries.userLibraryID,
				[
					{
						key: 'AAAAAAAA',
						version: 2,
						title: "A2"
					},
					{
						key: 'AAAAAAAA',
						version: 1,
						title: "A1"
					},
					{
						key: 'BBBBBBBB',
						version: 1,
						title: "B1"
					},
					{
						key: 'BBBBBBBB',
						version: 2,
						title: "B2"
					},
					{
						key: 'CCCCCCCC',
						version: 3,
						title: "C"
					}
				]
			);
		})
		
		it("should return latest version of all objects if no keys passed", function* () {
			var versions = yield Zotero.Sync.Data.Local.getLatestCacheObjectVersions(
				'item',
				Zotero.Libraries.userLibraryID
			);
			var keys = Object.keys(versions);
			assert.lengthOf(keys, 3);
			assert.sameMembers(keys, ['AAAAAAAA', 'BBBBBBBB', 'CCCCCCCC']);
			assert.equal(versions.AAAAAAAA, 2);
			assert.equal(versions.BBBBBBBB, 2);
			assert.equal(versions.CCCCCCCC, 3);
		})
		
		it("should return latest version of objects with passed keys", function* () {
			var versions = yield Zotero.Sync.Data.Local.getLatestCacheObjectVersions(
				'item',
				Zotero.Libraries.userLibraryID,
				['AAAAAAAA', 'CCCCCCCC']
			);
			var keys = Object.keys(versions);
			assert.lengthOf(keys, 2);
			assert.sameMembers(keys, ['AAAAAAAA', 'CCCCCCCC']);
			assert.equal(versions.AAAAAAAA, 2);
			assert.equal(versions.CCCCCCCC, 3);
		})
	})
	
	
	describe("#processObjectsFromJSON()", function () {
		var types = Zotero.DataObjectUtilities.getTypes();
		
		beforeEach(function* () {
			yield resetDB({
				thisArg: this,
				skipBundledFiles: true
			});
		})
		
		it("should update local version number and mark as synced if remote version is identical", function* () {
			var libraryID = Zotero.Libraries.userLibraryID;
			
			for (let type of types) {
				let objectsClass = Zotero.DataObjectUtilities.getObjectsClassForObjectType(type);
				let obj = yield createDataObject(type);
				let data = obj.toJSON();
				data.key = obj.key;
				data.version = 10;
				let json = {
					key: obj.key,
					version: 10,
					data: data
				};
				yield Zotero.Sync.Data.Local.processObjectsFromJSON(
					type, libraryID, [json], { stopOnError: true }
				);
				let localObj = objectsClass.getByLibraryAndKey(libraryID, obj.key);
				assert.equal(localObj.version, 10);
				assert.isTrue(localObj.synced);
			}
		})
		
		it("should keep local item changes while applying non-conflicting remote changes", function* () {
			var libraryID = Zotero.Libraries.userLibraryID;
			
			var type = 'item';
			let obj = yield createDataObject(type, { version: 5 });
			let data = obj.toJSON();
			yield Zotero.Sync.Data.Local.saveCacheObjects(
				type, libraryID, [data]
			);
			
			// Change local title
			yield modifyDataObject(obj)
			var changedTitle = obj.getField('title');
			
			// Save remote version to cache without title but with changed place
			data.key = obj.key;
			data.version = 10;
			var changedPlace = data.place = 'New York';
			let json = {
				key: obj.key,
				version: 10,
				data: data
			};
			yield Zotero.Sync.Data.Local.processObjectsFromJSON(
				type, libraryID, [json], { stopOnError: true }
			);
			assert.equal(obj.version, 10);
			assert.equal(obj.getField('title'), changedTitle);
			assert.equal(obj.getField('place'), changedPlace);
		})
		
		it("should delete older versions in sync cache after processing", function* () {
			var libraryID = Zotero.Libraries.userLibraryID;
			
			for (let type of types) {
				let objectsClass = Zotero.DataObjectUtilities.getObjectsClassForObjectType(type);
				
				// Save original version
				let obj = yield createDataObject(type, { version: 5 });
				let data = obj.toJSON();
				yield Zotero.Sync.Data.Local.saveCacheObjects(
					type, libraryID, [data]
				);
				
				// Save newer version
				data.version = 10;
				yield Zotero.Sync.Data.Local.processObjectsFromJSON(
					type, libraryID, [data], { stopOnError: true }
				);
				
				let localObj = objectsClass.getByLibraryAndKey(libraryID, obj.key);
				assert.equal(localObj.version, 10);
				
				let versions = yield Zotero.Sync.Data.Local.getCacheObjectVersions(
					type, libraryID, obj.key
				);
				assert.sameMembers(
					versions,
					[10],
					"should have only latest version of " + type + " in cache"
				);
			}
		});
		
		it("should delete object from sync queue after processing", function* () {
			var objectType = 'item';
			var libraryID = Zotero.Libraries.userLibraryID;
			var key = Zotero.DataObjectUtilities.generateKey();
			
			yield Zotero.Sync.Data.Local.addObjectsToSyncQueue(objectType, libraryID, [key]);
			
			var versions = yield Zotero.Sync.Data.Local.getObjectsFromSyncQueue(objectType, libraryID);
			assert.include(versions, key);
			
			var json = {
				key,
				version: 10,
				data: {
					key,
					version: 10,
					itemType: "book",
					title: "Test"
				}
			};
			
			yield Zotero.Sync.Data.Local.processObjectsFromJSON(
				objectType, libraryID, [json], { stopOnError: true }
			);
			
			var versions = yield Zotero.Sync.Data.Local.getObjectsFromSyncQueue(objectType, libraryID);
			assert.notInclude(versions, key);
		});
		
		it("should mark new attachment items for download", function* () {
			var libraryID = Zotero.Libraries.userLibraryID;
			Zotero.Sync.Storage.Local.setModeForLibrary(libraryID, 'zfs');
			
			var key = Zotero.DataObjectUtilities.generateKey();
			var version = 10;
			var json = {
				key,
				version,
				data: {
					key,
					version,
					itemType: 'attachment',
					linkMode: 'imported_file',
					md5: '57f8a4fda823187b91e1191487b87fe6',
					mtime: 1442261130615
				}
			};
			
			yield Zotero.Sync.Data.Local.processObjectsFromJSON(
				'item', libraryID, [json], { stopOnError: true }
			);
			var item = Zotero.Items.getByLibraryAndKey(libraryID, key);
			assert.equal(item.attachmentSyncState, Zotero.Sync.Storage.Local.SYNC_STATE_TO_DOWNLOAD);
		})
		
		it("should mark updated attachment items for download", function* () {
			var libraryID = Zotero.Libraries.userLibraryID;
			Zotero.Sync.Storage.Local.setModeForLibrary(libraryID, 'zfs');
			
			var item = yield importFileAttachment('test.png');
			item.version = 5;
			item.synced = true;
			yield item.saveTx();
			
			// Set file as synced
			item.attachmentSyncedModificationTime = yield item.attachmentModificationTime;
			item.attachmentSyncedHash = yield item.attachmentHash;
			item.attachmentSyncState = "in_sync";
			yield item.saveTx({ skipAll: true });
			
			// Simulate download of version with updated attachment
			var json = item.toResponseJSON();
			json.version = 10;
			json.data.version = 10;
			json.data.md5 = '57f8a4fda823187b91e1191487b87fe6';
			json.data.mtime = new Date().getTime() + 10000;
			yield Zotero.Sync.Data.Local.processObjectsFromJSON(
				'item', libraryID, [json], { stopOnError: true }
			);
			
			assert.equal(item.attachmentSyncState, Zotero.Sync.Storage.Local.SYNC_STATE_TO_DOWNLOAD);
		})
		
		it("should ignore attachment metadata when resolving metadata conflict", function* () {
			var libraryID = Zotero.Libraries.userLibraryID;
			Zotero.Sync.Storage.Local.setModeForLibrary(libraryID, 'zfs');
			
			var item = yield importFileAttachment('test.png');
			item.version = 5;
			yield item.saveTx();
			var json = item.toResponseJSON();
			yield Zotero.Sync.Data.Local.saveCacheObjects('item', libraryID, [json]);
			
			// Set file as synced
			item.attachmentSyncedModificationTime = yield item.attachmentModificationTime;
			item.attachmentSyncedHash = yield item.attachmentHash;
			item.attachmentSyncState = "in_sync";
			yield item.saveTx({ skipAll: true });
			
			// Modify title locally, leaving item unsynced
			var newTitle = Zotero.Utilities.randomString();
			item.setField('title', newTitle);
			yield item.saveTx();
			
			// Simulate download of version with original title but updated attachment
			json.version = 10;
			json.data.version = 10;
			json.data.md5 = '57f8a4fda823187b91e1191487b87fe6';
			json.data.mtime = new Date().getTime() + 10000;
			yield Zotero.Sync.Data.Local.processObjectsFromJSON(
				'item', libraryID, [json], { stopOnError: true }
			);
			
			assert.equal(item.getField('title'), newTitle);
			assert.equal(item.attachmentSyncState, Zotero.Sync.Storage.Local.SYNC_STATE_TO_DOWNLOAD);
		})
		
		it("should roll back partial object changes on error", function* () {
			var libraryID = Zotero.Libraries.publicationsLibraryID;
			var key1 = "AAAAAAAA";
			var key2 = "BBBBBBBB";
			var json = [
				{
					key: key1,
					version: 1,
					data: {
						key: key1,
						version: 1,
						itemType: "book",
						title: "Test A"
					}
				},
				{
					key: key2,
					version: 1,
					data: {
						key: key2,
						version: 1,
						itemType: "journalArticle",
						title: "Test B",
						deleted: true // Not allowed in My Publications
					}
				}
			];
			yield Zotero.Sync.Data.Local.processObjectsFromJSON('item', libraryID, json);
			
			// Shouldn't roll back the successful item
			yield assert.eventually.equal(Zotero.DB.valueQueryAsync(
				"SELECT COUNT(*) FROM items WHERE libraryID=? AND key=?", [libraryID, key1]
			), 1);
			// Should rollback the unsuccessful item
			yield assert.eventually.equal(Zotero.DB.valueQueryAsync(
				"SELECT COUNT(*) FROM items WHERE libraryID=? AND key=?", [libraryID, key2]
			), 0);
		});
	})
	
	describe("Sync Queue", function () {
		var lib1, lib2;
		
		before(function* () {
			lib1 = Zotero.Libraries.userLibraryID;
			lib2 = Zotero.Libraries.publicationsLibraryID;
		});
		
		beforeEach(function* () {
			yield Zotero.DB.queryAsync("DELETE FROM syncQueue");
		});
		
		after(function* () {
			yield Zotero.DB.queryAsync("DELETE FROM syncQueue");
		});
		
		describe("#addObjectsToSyncQueue()", function () {
			it("should add new objects and update lastCheck and tries for existing objects", function* () {
				var objectType = 'item';
				var syncObjectTypeID = Zotero.Sync.Data.Utilities.getSyncObjectTypeID(objectType);
				var now = Zotero.Date.getUnixTimestamp();
				var key1 = Zotero.DataObjectUtilities.generateKey();
				var key2 = Zotero.DataObjectUtilities.generateKey();
				var key3 = Zotero.DataObjectUtilities.generateKey();
				var key4 = Zotero.DataObjectUtilities.generateKey();
				yield Zotero.DB.queryAsync(
					"INSERT INTO syncQueue (libraryID, key, syncObjectTypeID, lastCheck, tries) "
						+ "VALUES (?, ?, ?, ?, ?), (?, ?, ?, ?, ?), (?, ?, ?, ?, ?)",
					[
						lib1, key1, syncObjectTypeID, now - 3700, 0,
						lib1, key2, syncObjectTypeID, now - 7000, 1,
						lib2, key3, syncObjectTypeID, now - 86400, 2
					]
				);
				
				yield Zotero.Sync.Data.Local.addObjectsToSyncQueue(objectType, lib1, [key1, key2]);
				yield Zotero.Sync.Data.Local.addObjectsToSyncQueue(objectType, lib2, [key4]);
				
				var sql = "SELECT lastCheck, tries FROM syncQueue WHERE libraryID=? "
					+ `AND syncObjectTypeID=${syncObjectTypeID} AND key=?`;
				var row;
				// key1
				row = yield Zotero.DB.rowQueryAsync(sql, [lib1, key1]);
				assert.approximately(row.lastCheck, now, 1);
				assert.equal(row.tries, 1);
				// key2
				row = yield Zotero.DB.rowQueryAsync(sql, [lib1, key2]);
				assert.approximately(row.lastCheck, now, 1);
				assert.equal(row.tries, 2);
				// key3
				row = yield Zotero.DB.rowQueryAsync(sql, [lib2, key3]);
				assert.equal(row.lastCheck, now - 86400);
				assert.equal(row.tries, 2);
				// key4
				row = yield Zotero.DB.rowQueryAsync(sql, [lib2, key4]);
				assert.approximately(row.lastCheck, now, 1);
				assert.equal(row.tries, 0);
			});
		});
		
		describe("#getObjectsToTryFromSyncQueue()", function () {
			it("should get objects that should be retried", function* () {
				var objectType = 'item';
				var syncObjectTypeID = Zotero.Sync.Data.Utilities.getSyncObjectTypeID(objectType);
				var now = Zotero.Date.getUnixTimestamp();
				var key1 = Zotero.DataObjectUtilities.generateKey();
				var key2 = Zotero.DataObjectUtilities.generateKey();
				var key3 = Zotero.DataObjectUtilities.generateKey();
				var key4 = Zotero.DataObjectUtilities.generateKey();
				yield Zotero.DB.queryAsync(
					"INSERT INTO syncQueue (libraryID, key, syncObjectTypeID, lastCheck, tries) "
						+ "VALUES (?, ?, ?, ?, ?), (?, ?, ?, ?, ?), (?, ?, ?, ?, ?)",
					[
						lib1, key1, syncObjectTypeID, now - (30 * 60) - 10, 0, // more than half an hour, so should be retried
						lib1, key2, syncObjectTypeID, now - (16 * 60 * 60) + 10, 4, // less than 16 hours, shouldn't be retried
						lib2, key3, syncObjectTypeID, now - 86400 * 7, 20 // more than 64 hours, so should be retried
					]
				);
				
				var keys = yield Zotero.Sync.Data.Local.getObjectsToTryFromSyncQueue('item', lib1);
				assert.sameMembers(keys, [key1]);
				var keys = yield Zotero.Sync.Data.Local.getObjectsToTryFromSyncQueue('item', lib2);
				assert.sameMembers(keys, [key3]);
			});
		});
		
		describe("#removeObjectsFromSyncQueue()", function () {
			it("should remove objects from the sync queue", function* () {
				var objectType = 'item';
				var syncObjectTypeID = Zotero.Sync.Data.Utilities.getSyncObjectTypeID(objectType);
				var now = Zotero.Date.getUnixTimestamp();
				var key1 = Zotero.DataObjectUtilities.generateKey();
				var key2 = Zotero.DataObjectUtilities.generateKey();
				var key3 = Zotero.DataObjectUtilities.generateKey();
				yield Zotero.DB.queryAsync(
					"INSERT INTO syncQueue (libraryID, key, syncObjectTypeID, lastCheck, tries) "
						+ "VALUES (?, ?, ?, ?, ?), (?, ?, ?, ?, ?), (?, ?, ?, ?, ?)",
					[
						lib1, key1, syncObjectTypeID, now, 0,
						lib1, key2, syncObjectTypeID, now, 4,
						lib2, key3, syncObjectTypeID, now, 20
					]
				);
				
				yield Zotero.Sync.Data.Local.removeObjectsFromSyncQueue('item', lib1, [key1]);
				
				var sql = "SELECT COUNT(*) FROM syncQueue WHERE libraryID=? "
					+ `AND syncObjectTypeID=${syncObjectTypeID} AND key=?`;
				assert.notOk(yield Zotero.DB.valueQueryAsync(sql, [lib1, key1]));
				assert.ok(yield Zotero.DB.valueQueryAsync(sql, [lib1, key2]));
				assert.ok(yield Zotero.DB.valueQueryAsync(sql, [lib2, key3]));
			})
		});
		
		describe("#resetSyncQueueTries", function () {
			var spy;
			
			after(function () {
				if (spy) {
					spy.restore();
				}
			})
			
			it("should be run on version upgrade", function* () {
				var sql = "REPLACE INTO settings (setting, key, value) VALUES ('client', 'lastVersion', ?)";
				yield Zotero.DB.queryAsync(sql, "5.0foo");
				
				spy = sinon.spy(Zotero.Sync.Data.Local, "resetSyncQueueTries");
				yield Zotero.Schema.updateSchema();
				assert.ok(spy.called);
			});
		});
	});
	
	
	describe("#_reconcileChanges()", function () {
		describe("items", function () {
			it("should ignore non-conflicting local changes and return remote changes", function () {
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					itemType: "book",
					title: "Title 1",
					url: "http://zotero.org/",
					publicationTitle: "Publisher", // Remove locally
					extra: "Extra", // Removed on both
					dateModified: "2015-05-14 12:34:56",
					collections: [
						'AAAAAAAA', // Removed locally
						'DDDDDDDD', // Removed remotely,
						'EEEEEEEE' // Removed from both
					],
					relations: {
						a: 'A', // Unchanged string
						c: ['C1', 'C2'], // Unchanged array
						d: 'D', // String removed locally
						e: ['E'], // Array removed locally
						f: 'F1', // String changed locally
						g: [
							'G1', // Unchanged
							'G2', // Removed remotely
							'G3' // Removed from both
						],
						h: 'H', // String removed remotely
						i: ['I'], // Array removed remotely
					},
					tags: [
						{ tag: 'A' }, // Removed locally
						{ tag: 'D' }, // Removed remotely
						{ tag: 'E' } // Removed from both
					]
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					itemType: "book",
					title: "Title 2", // Changed locally
					url: "https://www.zotero.org/", // Same change on local and remote
					place: "Place", // Added locally
					dateModified: "2015-05-14 14:12:34", // Changed locally and remotely, but ignored
					collections: [
						'BBBBBBBB', // Added locally
						'DDDDDDDD',
						'FFFFFFFF' // Added on both
					],
					relations: {
						'a': 'A',
						'b': 'B', // String added locally
						'f': 'F2',
						'g': [
							'G1',
							'G2',
							'G6' // Added locally and remotely
						],
						h: 'H', // String removed remotely
						i: ['I'], // Array removed remotely
	
					},
					tags: [
						{ tag: 'B' },
						{ tag: 'D' },
						{ tag: 'F', type: 1 }, // Added on both
						{ tag: 'G' }, // Added on both, but with different types
						{ tag: 'H', type: 1 } // Added on both, but with different types
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1235,
					itemType: "book",
					title: "Title 1",
					url: "https://www.zotero.org/",
					publicationTitle: "Publisher",
					date: "2015-05-15", // Added remotely
					dateModified: "2015-05-14 13:45:12",
					collections: [
						'AAAAAAAA',
						'CCCCCCCC', // Added remotely
						'FFFFFFFF'
					],
					relations: {
						'a': 'A',
						'd': 'D',
						'e': ['E'],
						'f': 'F1',
						'g': [
							'G1',
							'G4', // Added remotely
							'G6'
						],
					},
					tags: [
						{ tag: 'A' },
						{ tag: 'C' },
						{ tag: 'F', type: 1 },
						{ tag: 'G', type: 1 },
						{ tag: 'H' }
					]
				};
				var ignoreFields = ['dateAdded', 'dateModified'];
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'item', cacheJSON, json1, json2, ignoreFields
				);
				assert.sameDeepMembers(
					result.changes,
					[
						{
							field: "date",
							op: "add",
							value: "2015-05-15"
						},
						{
							field: "collections",
							op: "member-add",
							value: "CCCCCCCC"
						},
						{
							field: "collections",
							op: "member-remove",
							value: "DDDDDDDD"
						},
						// Relations
						{
							field: "relations",
							op: "property-member-remove",
							value: {
								key: 'g',
								value: 'G2'
							}
						},
						{
							field: "relations",
							op: "property-member-add",
							value: {
								key: 'g',
								value: 'G4'
							}
						},
						{
							field: "relations",
							op: "property-member-remove",
							value: {
								key: 'h',
								value: 'H'
							}
						},
						{
							field: "relations",
							op: "property-member-remove",
							value: {
								key: 'i',
								value: 'I'
							}
						},
						// Tags
						{
							field: "tags",
							op: "member-add",
							value: {
								tag: 'C'
							}
						},
						{
							field: "tags",
							op: "member-remove",
							value: {
								tag: 'D'
							}
						},
						{
							field: "tags",
							op: "member-remove",
							value: {
								tag: 'H',
								type: 1
							}
						},
						{
							field: "tags",
							op: "member-add",
							value: {
								tag: 'H'
							}
						}
					]
				);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should return empty arrays when no remote changes to apply", function () {
				// Similar to above but without differing remote changes
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					itemType: "book",
					title: "Title 1",
					url: "http://zotero.org/",
					publicationTitle: "Publisher", // Remove locally
					extra: "Extra", // Removed on both
					dateModified: "2015-05-14 12:34:56",
					collections: [
						'AAAAAAAA', // Removed locally
						'DDDDDDDD',
						'EEEEEEEE' // Removed from both
					],
					tags: [
						{
							tag: 'A' // Removed locally
						},
						{
							tag: 'D' // Removed remotely
						},
						{
							tag: 'E' // Removed from both
						}
					]
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					itemType: "book",
					title: "Title 2", // Changed locally
					url: "https://www.zotero.org/", // Same change on local and remote
					place: "Place", // Added locally
					dateModified: "2015-05-14 14:12:34", // Changed locally and remotely, but ignored
					collections: [
						'BBBBBBBB', // Added locally
						'DDDDDDDD',
						'FFFFFFFF' // Added on both
					],
					tags: [
						{
							tag: 'B'
						},
						{
							tag: 'D'
						},
						{
							tag: 'F', // Added on both
							type: 1
						},
						{
							tag: 'G' // Added on both, but with different types
						}
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1235,
					itemType: "book",
					title: "Title 1",
					url: "https://www.zotero.org/",
					publicationTitle: "Publisher",
					dateModified: "2015-05-14 13:45:12",
					collections: [
						'AAAAAAAA',
						'DDDDDDDD',
						'FFFFFFFF'
					],
					tags: [
						{
							tag: 'A'
						},
						{
							tag: 'D'
						},
						{
							tag: 'F',
							type: 1
						},
						{
							tag: 'G',
							type: 1
						}
					]
				};
				var ignoreFields = ['dateAdded', 'dateModified'];
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'item', cacheJSON, json1, json2, ignoreFields
				);
				assert.lengthOf(result.changes, 0);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should return conflict when changes can't be automatically resolved", function () {
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					title: "Title 1",
					dateModified: "2015-05-14 12:34:56"
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					title: "Title 2",
					dateModified: "2015-05-14 14:12:34"
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1235,
					title: "Title 3",
					dateModified: "2015-05-14 13:45:12"
				};
				var ignoreFields = ['dateAdded', 'dateModified'];
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'item', cacheJSON, json1, json2, ignoreFields
				);
				Zotero.debug('=-=-=-=');
				Zotero.debug(result);
				assert.lengthOf(result.changes, 0);
				assert.sameDeepMembers(
					result.conflicts,
					[
						[
							{
								field: "title",
								op: "modify",
								value: "Title 2"
							},
							{
								field: "title",
								op: "modify",
								value: "Title 3"
							}
						]
					]
				);
			})
			
			it("should automatically merge array/object members and generate conflicts for field changes in absence of cached version", function () {
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					itemType: "book",
					title: "Title",
					creators: [
						{
							name: "Center for History and New Media",
							creatorType: "author"
						}
					],
					place: "Place", // Local
					dateModified: "2015-05-14 14:12:34", // Changed on both, but ignored
					collections: [
						'AAAAAAAA' // Local
					],
					relations: {
						'a': 'A',
						'b': 'B', // Local
						'e': 'E1',
						'f': [
							'F1',
							'F2' // Local
						],
						h: 'H', // String removed remotely
						i: ['I'], // Array removed remotely
					},
					tags: [
						{ tag: 'A' }, // Local
						{ tag: 'C' },
						{ tag: 'F', type: 1 },
						{ tag: 'G' }, // Different types
						{ tag: 'H', type: 1 } // Different types
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1235,
					itemType: "book",
					title: "Title",
					creators: [
						{
							creatorType: "author", // Different property order shouldn't matter
							name: "Center for History and New Media"
						}
					],
					date: "2015-05-15", // Remote
					dateModified: "2015-05-14 13:45:12",
					collections: [
						'BBBBBBBB' // Remote
					],
					relations: {
						'a': 'A',
						'c': 'C', // Remote
						'd': ['D'], // Remote
						'e': 'E2',
						'f': [
							'F1',
							'F3' // Remote
						],
					},
					tags: [
						{ tag: 'B' }, // Remote
						{ tag: 'C' },
						{ tag: 'F', type: 1 },
						{ tag: 'G', type: 1 }, // Different types
						{ tag: 'H' } // Different types
					]
				};
				var ignoreFields = ['dateAdded', 'dateModified'];
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'item', false, json1, json2, ignoreFields
				);
				Zotero.debug(result);
				assert.sameDeepMembers(
					result.changes,
					[
						// Collections
						{
							field: "collections",
							op: "member-add",
							value: "BBBBBBBB"
						},
						// Relations
						{
							field: "relations",
							op: "property-member-add",
							value: {
								key: 'c',
								value: 'C'
							}
						},
						{
							field: "relations",
							op: "property-member-add",
							value: {
								key: 'd',
								value: 'D'
							}
						},
						{
							field: "relations",
							op: "property-member-add",
							value: {
								key: 'e',
								value: 'E2'
							}
						},
						{
							field: "relations",
							op: "property-member-add",
							value: {
								key: 'f',
								value: 'F3'
							}
						},
						// Tags
						{
							field: "tags",
							op: "member-add",
							value: {
								tag: 'B'
							}
						},
						{
							field: "tags",
							op: "member-add",
							value: {
								tag: 'G',
								type: 1
							}
						},
						{
							field: "tags",
							op: "member-add",
							value: {
								tag: 'H'
							}
						}
					]
				);
				assert.sameDeepMembers(
					result.conflicts,
					[
						[
							{
								field: "place",
								op: "add",
								value: "Place"
							},
							{
								field: "place",
								op: "delete"
							}
						],
						[
							{
								field: "date",
								op: "delete"
							},
							{
								field: "date",
								op: "add",
								value: "2015-05-15"
							}
						]
					]
				);
			})
		})
		
		
		describe("collections", function () {
			it("should ignore non-conflicting local changes and return remote changes", function () {
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					parentCollection: null,
					relations: {
						A: "A", // Removed locally
						C: "C" // Removed on both
					}
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2", // Changed locally
					parentCollection: null,
					relations: {}
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					parentCollection: "BBBBBBBB", // Added remotely
					relations: {
						A: "A",
						B: "B" // Added remotely
					}
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'collection', cacheJSON, json1, json2
				);
				assert.sameDeepMembers(
					result.changes,
					[
						{
							field: "parentCollection",
							op: "add",
							value: "BBBBBBBB"
						},
						{
							field: "relations",
							op: "property-member-add",
							value: {
								key: "B",
								value: "B"
							}
						}
					]
				);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should return empty arrays when no remote changes to apply", function () {
				// Similar to above but without differing remote changes
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2", // Changed locally
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						// Added locally
						{
							condition: "place",
							operator: "is",
							value: "New York"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'search', cacheJSON, json1, json2
				);
				assert.lengthOf(result.changes, 0);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should automatically resolve conflicts with remote version", function () {
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1"
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2"
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 3"
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'search', cacheJSON, json1, json2
				);
				assert.sameDeepMembers(
					result.changes,
					[
						{
							field: "name",
							op: "modify",
							value: "Name 3"
						}
					]
				);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should automatically resolve conflicts in absence of cached version", function () {
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "New York"
						}
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'search', false, json1, json2
				);
				assert.sameDeepMembers(
					result.changes,
					[
						{
							field: "name",
							op: "modify",
							value: "Name 2"
						},
						{
							field: "conditions",
							op: "member-add",
							value: {
								condition: "place",
								operator: "is",
								value: "Chicago"
							}
						}
					]
				);
				assert.lengthOf(result.conflicts, 0);
			})
		})
		
		
		describe("searches", function () {
			it("should ignore non-conflicting local changes and return remote changes", function () {
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2", // Changed locally
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						// Removed remotely
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						// Added remotely
						{
							condition: "place",
							operator: "is",
							value: "New York"
						}
					]
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'search', cacheJSON, json1, json2
				);
				assert.sameDeepMembers(
					result.changes,
					[
						{
							field: "conditions",
							op: "member-add",
							value: {
								condition: "place",
								operator: "is",
								value: "New York"
							}
						},
						{
							field: "conditions",
							op: "member-remove",
							value: {
								condition: "place",
								operator: "is",
								value: "Chicago"
							}
						}
					]
				);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should return empty arrays when no remote changes to apply", function () {
				// Similar to above but without differing remote changes
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2", // Changed locally
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						// Added locally
						{
							condition: "place",
							operator: "is",
							value: "New York"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'search', cacheJSON, json1, json2
				);
				assert.lengthOf(result.changes, 0);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should automatically resolve conflicts with remote version", function () {
				var cacheJSON = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1"
				};
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2"
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 3"
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'search', cacheJSON, json1, json2
				);
				assert.sameDeepMembers(
					result.changes,
					[
						{
							field: "name",
							op: "modify",
							value: "Name 3"
						}
					]
				);
				assert.lengthOf(result.conflicts, 0);
			})
			
			it("should automatically resolve conflicts in absence of cached version", function () {
				var json1 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 1",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "New York"
						}
					]
				};
				var json2 = {
					key: "AAAAAAAA",
					version: 1234,
					name: "Name 2",
					conditions: [
						{
							condition: "title",
							operator: "contains",
							value: "A"
						},
						{
							condition: "place",
							operator: "is",
							value: "Chicago"
						}
					]
				};
				var result = Zotero.Sync.Data.Local._reconcileChanges(
					'search', false, json1, json2
				);
				assert.sameDeepMembers(
					result.changes,
					[
						{
							field: "name",
							op: "modify",
							value: "Name 2"
						},
						{
							field: "conditions",
							op: "member-add",
							value: {
								condition: "place",
								operator: "is",
								value: "Chicago"
							}
						}
					]
				);
				assert.lengthOf(result.conflicts, 0);
			})
		})
	})
	
	
	describe("#reconcileChangesWithoutCache()", function () {
		it("should return conflict for conflicting fields", function () {
			var json1 = {
				key: "AAAAAAAA",
				version: 1234,
				title: "Title 1",
				pages: 10,
				dateModified: "2015-05-14 14:12:34"
			};
			var json2 = {
				key: "AAAAAAAA",
				version: 1235,
				title: "Title 2",
				place: "New York",
				dateModified: "2015-05-14 13:45:12"
			};
			var ignoreFields = ['dateAdded', 'dateModified'];
			var result = Zotero.Sync.Data.Local._reconcileChangesWithoutCache(
				'item', json1, json2, ignoreFields
			);
			assert.lengthOf(result.changes, 0);
			assert.sameDeepMembers(
				result.conflicts,
				[
					[
						{
							field: "title",
							op: "add",
							value: "Title 1"
						},
						{
							field: "title",
							op: "add",
							value: "Title 2"
						}
					],
					[
						{
							field: "pages",
							op: "add",
							value: 10
						},
						{
							field: "pages",
							op: "delete"
						}
					],
					[
						{
							field: "place",
							op: "delete"
						},
						{
							field: "place",
							op: "add",
							value: "New York"
						}
					]
				]
			);
		})
	})
})