/* eslint-disable
    camelcase,
    no-return-assign,
    no-undef,
    no-unused-vars,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * DS205: Consider reworking code to avoid use of IIFEs
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
// This file is shared between document-updater and web, so that the server and client share
// an identical track changes implementation. Do not edit it directly in web or document-updater,
// instead edit it at https://github.com/sharelatex/ranges-tracker, where it has a suite of tests
const load = function() {
	let RangesTracker;
	return RangesTracker = class RangesTracker {
		// The purpose of this class is to track a set of inserts and deletes to a document, like
		// track changes in Word. We store these as a set of ShareJs style ranges:
		//   {i: "foo", p: 42} # Insert 'foo' at offset 42
		//   {d: "bar", p: 37} # Delete 'bar' at offset 37
		// We only track the inserts and deletes, not the whole document, but by being given all
		// updates that are applied to a document, we can update these appropriately.
		// 
		// Note that the set of inserts and deletes we store applies to the document as-is at the moment.
		// So inserts correspond to text which is in the document, while deletes correspond to text which
		// is no longer there, so their lengths do not affect the position of later offsets.
		// E.g.
		//             this is the current text of the document
		//                         |-----|            |
		//  {i: "current ", p:12} -^                   ^- {d: "old ", p: 31}
		//
		// Track changes rules (should be consistent with Word):
		//   * When text is inserted at a delete, the text goes to the left of the delete
		//       I.e. "foo|bar" -> "foobaz|bar", where | is the delete, and 'baz' is inserted
		//   * Deleting content flagged as 'inserted' does not create a new delete marker, it only
		//     removes the insert marker. E.g.
		//       * "abdefghijkl"        -> "abfghijkl"        when 'de' is deleted. No delete marker added
		//           |---| <- inserted       |-| <- inserted
		//       * Deletes overlapping regular text and inserted text will insert a delete marker for the
		//         regular text:
		//         "abcdefghijkl"    ->    "abcdejkl"   when 'fghi' is deleted
		//           |----|                  |--||
		//           ^- inserted 'bcdefg'      \ ^- deleted 'hi'
		//                                      \--inserted 'bcde'
		//   * Deletes overlapping other deletes are merged. E.g.
		//      "abcghijkl"        ->   "ahijkl"     when 'bcg is deleted'
		//          | <- delete 'def'     | <- delete 'bcdefg'
		//   * Deletes by another user will consume deletes by the first user
		//   * Inserts by another user will not combine with inserts by the first user. If they are in the
		//     middle of a previous insert by the first user, the original insert will be split into two.
		constructor(changes, comments) {
			if (changes == null) { changes = []; }
			this.changes = changes;
			if (comments == null) { comments = []; }
			this.comments = comments;
			this.setIdSeed(RangesTracker.generateIdSeed());
			this.resetDirtyState();
		}

		getIdSeed() {
			return this.id_seed;
		}

		setIdSeed(seed) {
			this.id_seed = seed;
			return this.id_increment = 0;
		}
		
		static generateIdSeed() {
			// Generate a the first 18 characters of Mongo ObjectId, leaving 6 for the increment part
			// Reference: https://github.com/dreampulse/ObjectId.js/blob/master/src/main/javascript/Objectid.js
			const pid = Math.floor(Math.random() * (32767)).toString(16);
			const machine = Math.floor(Math.random() * (16777216)).toString(16);
			const timestamp = Math.floor(new Date().valueOf() / 1000).toString(16);
			return '00000000'.substr(0, 8 - timestamp.length) + timestamp +
				'000000'.substr(0, 6 - machine.length) + machine +
				'0000'.substr(0, 4 - pid.length) + pid;
		}
		
		static generateId() {
			return this.generateIdSeed() + "000001";
		}

		newId() {
			this.id_increment++;
			const increment = this.id_increment.toString(16);
			const id = this.id_seed + '000000'.substr(0, 6 - increment.length) + increment;
			return id;
		}
		
		getComment(comment_id) {
			let comment = null;
			for (const c of Array.from(this.comments)) {
				if (c.id === comment_id) {
					comment = c;
					break;
				}
			}
			return comment;
		}
		
		removeCommentId(comment_id) {
			const comment = this.getComment(comment_id);
			if ((comment == null)) { return; }
			this.comments = this.comments.filter(c => c.id !== comment_id);
			return this._markAsDirty(comment, "comment", "removed");
		}
		
		moveCommentId(comment_id, position, text) {
			return (() => {
				const result = [];
				for (const comment of Array.from(this.comments)) {
					if (comment.id === comment_id) {
						comment.op.p = position;
						comment.op.c = text;
						result.push(this._markAsDirty(comment, "comment", "moved"));
					} else {
						result.push(undefined);
					}
				}
				return result;
			})();
		}

		getChange(change_id) {
			let change = null;
			for (const c of Array.from(this.changes)) {
				if (c.id === change_id) {
					change = c;
					break;
				}
			}
			return change;
		}

		getChanges(change_ids) {
			const changes_response = [];
			const ids_map = {};

			for (const change_id of Array.from(change_ids)) {
				ids_map[change_id] = true;
			}

			for (const change of Array.from(this.changes)) {
				if (ids_map[change.id]) {
					delete ids_map[change.id];
					changes_response.push(change);
				}
			}

			return changes_response;
		}

		removeChangeId(change_id) {
			const change = this.getChange(change_id);
			if ((change == null)) { return; }
			return this._removeChange(change);
		}

		removeChangeIds(change_to_remove_ids) {
			if (!(change_to_remove_ids != null ? change_to_remove_ids.length : undefined) > 0) { return; }
			const i = this.changes.length;
			const remove_change_id = {}; 
			for (const change_id of Array.from(change_to_remove_ids)) {
				remove_change_id[change_id] = true;
			}

			const remaining_changes = [];

			for (const change of Array.from(this.changes)) {
				if (remove_change_id[change.id]) {
					delete remove_change_id[change.id];
					this._markAsDirty(change, "change", "removed");
				} else {
					remaining_changes.push(change);
				}
			}

			return this.changes = remaining_changes;
		}
		
		validate(text) {
			let content;
			for (const change of Array.from(this.changes)) {
				if (change.op.i != null) {
					content = text.slice(change.op.p, change.op.p + change.op.i.length);
					if (content !== change.op.i) {
						throw new Error(`Change (${JSON.stringify(change)}) doesn't match text (${JSON.stringify(content)})`);
					}
				}
			}
			for (const comment of Array.from(this.comments)) {
				content = text.slice(comment.op.p, comment.op.p + comment.op.c.length);
				if (content !== comment.op.c) {
					throw new Error(`Comment (${JSON.stringify(comment)}) doesn't match text (${JSON.stringify(content)})`);
				}
			}
			return true;
		}

		applyOp(op, metadata) {
			if (metadata == null) { metadata = {}; }
			if (metadata.ts == null) { metadata.ts = new Date(); }
			// Apply an op that has been applied to the document to our changes to keep them up to date
			if (op.i != null) {
				this.applyInsertToChanges(op, metadata);
				return this.applyInsertToComments(op);
			} else if (op.d != null) {
				this.applyDeleteToChanges(op, metadata);
				return this.applyDeleteToComments(op);
			} else if (op.c != null) {
				return this.addComment(op, metadata);
			} else {
				throw new Error("unknown op type");
			}
		}

		applyOps(ops, metadata) {
			if (metadata == null) { metadata = {}; }
			return Array.from(ops).map((op) =>
				this.applyOp(op, metadata));
		}

		addComment(op, metadata) {
			const existing = this.getComment(op.t);
			if (existing != null) {
				this.moveCommentId(op.t, op.p, op.c);
				return existing;
			} else {
				let comment;
				this.comments.push(comment = {
					id: op.t || this.newId(),
					op: { // Copy because we'll modify in place
						c: op.c,
						p: op.p,
						t: op.t
					},
					metadata
				});
				this._markAsDirty(comment, "comment", "added");
				return comment;
			}
		}
		
		applyInsertToComments(op) {
			return (() => {
				const result = [];
				for (const comment of Array.from(this.comments)) {
					if (op.p <= comment.op.p) {
						comment.op.p += op.i.length;
						result.push(this._markAsDirty(comment, "comment", "moved"));
					} else if (op.p < (comment.op.p + comment.op.c.length)) {
						const offset = op.p - comment.op.p;
						comment.op.c = comment.op.c.slice(0, +(offset-1) + 1 || undefined) + op.i + comment.op.c.slice(offset);
						result.push(this._markAsDirty(comment, "comment", "moved"));
					} else {
						result.push(undefined);
					}
				}
				return result;
			})();
		}

		applyDeleteToComments(op) {
			const op_start = op.p;
			const op_length = op.d.length;
			const op_end = op.p + op_length;
			return (() => {
				const result = [];
				for (const comment of Array.from(this.comments)) {
					const comment_start = comment.op.p;
					const comment_end = comment.op.p + comment.op.c.length;
					const comment_length = comment_end - comment_start;
					if (op_end <= comment_start) {
						// delete is fully before comment
						comment.op.p -= op_length;
						result.push(this._markAsDirty(comment, "comment", "moved"));
					} else if (op_start >= comment_end) {
						// delete is fully after comment, nothing to do
					} else {
						// delete and comment overlap
						var remaining_after, remaining_before;
						if (op_start <= comment_start) {
							remaining_before = "";
						} else {
							remaining_before = comment.op.c.slice(0, op_start - comment_start);
						}
						if (op_end >= comment_end) {
							remaining_after = "";
						} else {
							remaining_after = comment.op.c.slice(op_end - comment_start);
						}
					
						// Check deleted content matches delete op
						const deleted_comment = comment.op.c.slice(remaining_before.length, comment_length - remaining_after.length);
						const offset = Math.max(0, comment_start - op_start);
						const deleted_op_content = op.d.slice(offset).slice(0, deleted_comment.length);
						if (deleted_comment !== deleted_op_content) {
							throw new Error("deleted content does not match comment content");
						}
					
						comment.op.p = Math.min(comment_start, op_start);
						comment.op.c = remaining_before + remaining_after;
						result.push(this._markAsDirty(comment, "comment", "moved"));
					}
				}
				return result;
			})();
		}

		applyInsertToChanges(op, metadata) {
			let change;
			const op_start = op.p;
			const op_length = op.i.length;
			const op_end = op.p + op_length;
			const undoing = !!op.u;


			let already_merged = false;
			let previous_change = null;
			const moved_changes = [];
			const remove_changes = [];
			const new_changes = [];

			for (let i = 0; i < this.changes.length; i++) {
				change = this.changes[i];
				const change_start = change.op.p;
				
				if (change.op.d != null) {
					// Shift any deletes after this along by the length of this insert
					if (op_start < change_start) {
						change.op.p += op_length;
						moved_changes.push(change);
					} else if (op_start === change_start) {
						// If we are undoing, then we want to cancel any existing delete ranges if we can.
						// Check if the insert matches the start of the delete, and just remove it from the delete instead if so.
						if (undoing && (change.op.d.length >= op.i.length) && (change.op.d.slice(0, op.i.length) === op.i)) {
							change.op.d = change.op.d.slice(op.i.length);
							change.op.p += op.i.length;
							if (change.op.d === "") {
								remove_changes.push(change);
							} else {
								moved_changes.push(change);
							}
							already_merged = true;
						} else {
							change.op.p += op_length;
							moved_changes.push(change);
						}
					}
				} else if (change.op.i != null) {
					var offset;
					const change_end = change_start + change.op.i.length;
					const is_change_overlapping = ((op_start >= change_start) && (op_start <= change_end));
					
					// Only merge inserts if they are from the same user
					const is_same_user = metadata.user_id === change.metadata.user_id;
					
					// If we are undoing, then our changes will be removed from any delete ops just after. In that case, if there is also
					// an insert op just before, then we shouldn't append it to this insert, but instead only cancel the following delete.
					// E.g.
					//                   foo|<--- about to insert 'b' here
					//  inserted 'foo'  --^ ^-- deleted 'bar'
					// should become just 'foo' not 'foob' (with the delete marker becoming just 'ar'), .
					const next_change = this.changes[i+1];
					const is_op_adjacent_to_next_delete = (next_change != null) && (next_change.op.d != null) && (op.p === change_end) && (next_change.op.p === op.p);
					const will_op_cancel_next_delete = undoing && is_op_adjacent_to_next_delete && (next_change.op.d.slice(0, op.i.length) === op.i);
					
					// If there is a delete at the start of the insert, and we're inserting
					// at the start, we SHOULDN'T merge since the delete acts as a partition.
					// The previous op will be the delete, but it's already been shifted by this insert
					//
					// I.e.
					// Originally: |-- existing insert --|
					//             | <- existing delete at same offset
					//
					// Now:        |-- existing insert --| <- not shifted yet
					//             |-- this insert --|| <- existing delete shifted along to end of this op
					// 
					// After:                         |-- existing insert --|  
					//             |-- this insert --|| <- existing delete
					// 
					// Without the delete, the inserts would be merged.
					const is_insert_blocked_by_delete = ((previous_change != null) && (previous_change.op.d != null) && (previous_change.op.p === op_end));

					// If the insert is overlapping another insert, either at the beginning in the middle or touching the end,
					// then we merge them into one.
					if (this.track_changes &&
							is_change_overlapping &&
							!is_insert_blocked_by_delete &&
							!already_merged &&
							!will_op_cancel_next_delete &&
							is_same_user) {
						offset = op_start - change_start;
						change.op.i = change.op.i.slice(0, offset) + op.i + change.op.i.slice(offset);
						change.metadata.ts = metadata.ts;
						already_merged = true;
						moved_changes.push(change);
					} else if (op_start <= change_start) {
						// If we're fully before the other insert we can just shift the other insert by our length.
						// If they are touching, and should have been merged, they will have been above.
						// If not merged above, then it must be blocked by a delete, and will be after this insert, so we shift it along as well
						change.op.p += op_length;
						moved_changes.push(change);
					} else if ((!is_same_user || !this.track_changes) && (change_start < op_start && op_start < change_end)) {
						// This user is inserting inside a change by another user, so we need to split the
						// other user's change into one before and after this one.
						offset = op_start - change_start;
						const before_content = change.op.i.slice(0, offset);
						const after_content = change.op.i.slice(offset);
						
						// The existing change can become the 'before' change
						change.op.i = before_content;
						moved_changes.push(change);
						
						// Create a new op afterwards
						const after_change = {
							op: {
								i: after_content,
								p: change_start + offset + op_length
							},
							metadata: {}
						};
						for (const key in change.metadata) { const value = change.metadata[key]; after_change.metadata[key] = value; }
						new_changes.push(after_change);
					}
				}
						
				previous_change = change;
			}

			if (this.track_changes && !already_merged) {
				this._addOp(op, metadata);
			}
			for ({op, metadata} of Array.from(new_changes)) {
				this._addOp(op, metadata);
			}
		
			for (change of Array.from(remove_changes)) {
				this._removeChange(change);
			}
			
			return (() => {
				const result = [];
				for (change of Array.from(moved_changes)) {
					result.push(this._markAsDirty(change, "change", "moved"));
				}
				return result;
			})();
		}
		
		applyDeleteToChanges(op, metadata) {
			let change;
			const op_start = op.p;
			const op_length = op.d.length;
			const op_end = op.p + op_length;
			const remove_changes = [];
			let moved_changes = [];
			
			// We might end up modifying our delete op if it merges with existing deletes, or cancels out
			// with an existing insert. Since we might do multiple modifications, we record them and do
			// all the modifications after looping through the existing changes, so as not to mess up the
			// offset indexes as we go.
			const op_modifications = [];
			for (change of Array.from(this.changes)) {
				var change_start;
				if (change.op.i != null) {
					change_start = change.op.p;
					const change_end = change_start + change.op.i.length;
					if (op_end <= change_start) {
						// Shift ops after us back by our length
						change.op.p -= op_length;
						moved_changes.push(change);
					} else if (op_start >= change_end) {
						// Delete is after insert, nothing to do
					} else {
						// When the new delete overlaps an insert, we should remove the part of the insert that
						// is now deleted, and also remove the part of the new delete that overlapped. I.e.
						// the two cancel out where they overlap.
						var delete_remaining_after, delete_remaining_before, insert_remaining_after, insert_remaining_before;
						if (op_start >= change_start) {
							//                            |-- existing insert --|
							// insert_remaining_before -> |.....||--   new delete   --|
							delete_remaining_before = "";
							insert_remaining_before = change.op.i.slice(0, op_start - change_start);
						} else {
							// delete_remaining_before -> |.....||-- existing insert --|
							//                            |-- new delete   --|
							delete_remaining_before = op.d.slice(0, change_start - op_start);
							insert_remaining_before = "";
						}

						if (op_end <= change_end) {
							//    |--  existing insert  --|
							// |--  new delete   --||.....| <- insert_remaining_after
							delete_remaining_after = "";
							insert_remaining_after = change.op.i.slice(op_end - change_start);
						} else {
							// |--  existing insert  --||.....| <- delete_remaining_after
							//            |--  new delete   --|
							delete_remaining_after = op.d.slice(change_end - op_start);
							insert_remaining_after = "";
						}

						const insert_remaining = insert_remaining_before + insert_remaining_after;
						if (insert_remaining.length > 0) {
							change.op.i = insert_remaining;
							change.op.p = Math.min(change_start, op_start);
							change.metadata.ts = metadata.ts;
							moved_changes.push(change);
						} else {
							remove_changes.push(change);
						}

						// We know what we want to preserve of our delete op before (delete_remaining_before) and what we want to preserve
						// afterwards (delete_remaining_before). Now we need to turn that into a modification which deletes the 
						// chunk in the middle not covered by these.
						const delete_removed_length = op.d.length - delete_remaining_before.length - delete_remaining_after.length;
						const delete_removed_start = delete_remaining_before.length;
						const modification = {
							d: op.d.slice(delete_removed_start, delete_removed_start + delete_removed_length),
							p: delete_removed_start
						};
						if (modification.d.length > 0) {
							op_modifications.push(modification);
						}
					}
				} else if (change.op.d != null) {
					change_start = change.op.p;
					if ((op_end < change_start) || (!this.track_changes && (op_end === change_start))) {
						// Shift ops after us back by our length.
						// If we're tracking changes, it must be strictly before, since we'll merge 
						// below if they are touching. Otherwise, touching is fine.
						change.op.p -= op_length;
						moved_changes.push(change);
					} else if (op_start <= change_start && change_start <= op_end) {
						if (this.track_changes) {
							// If we overlap a delete, add it in our content, and delete the existing change.
							// It's easier to do it this way, rather than modifying the existing delete in case
							// we overlap many deletes and we'd need to track that. We have a workaround to
							// update the delete in place if possible below.
							const offset = change_start - op_start;
							op_modifications.push({ i: change.op.d, p: offset });
							remove_changes.push(change);
						} else {
							change.op.p = op_start;
							moved_changes.push(change);
						}
					}
				}
			}

			// Copy rather than modify because we still need to apply it to comments
			op = {
				p: op.p,
				d: this._applyOpModifications(op.d, op_modifications)
			};

			for (change of Array.from(remove_changes)) {
				// This is a bit of hack to avoid removing one delete and replacing it with another.
				// If we don't do this, it causes the UI to flicker
				if ((op.d.length > 0) && (change.op.d != null) && (op.p <= change.op.p && change.op.p <= op.p + op.d.length)) {
					change.op.p = op.p;
					change.op.d = op.d;
					change.metadata = metadata;
					moved_changes.push(change);
					op.d = ""; // stop it being added
				} else {
					this._removeChange(change);
				}
			}

			if (this.track_changes && (op.d.length > 0)) {
				this._addOp(op, metadata);
			} else {
				// It's possible that we deleted an insert between two other inserts. I.e.
				// If we delete 'user_2 insert' in:
				//   |-- user_1 insert --||-- user_2 insert --||-- user_1 insert --|
				// it becomes:
				//   |-- user_1 insert --||-- user_1 insert --|
				// We need to merge these together again
				const results = this._scanAndMergeAdjacentUpdates();
				moved_changes = moved_changes.concat(results.moved_changes);
				for (change of Array.from(results.remove_changes)) {
					this._removeChange(change);
					moved_changes = moved_changes.filter(c => c !== change);
				}
			}
			
			return (() => {
				const result = [];
				for (change of Array.from(moved_changes)) {
					result.push(this._markAsDirty(change, "change", "moved"));
				}
				return result;
			})();
		}

		_addOp(op, metadata) {
			const change = {
				id: this.newId(),
				op: this._clone(op), // Don't take a reference to the existing op since we'll modify this in place with future changes
				metadata: this._clone(metadata)
			};
			this.changes.push(change);

			// Keep ops in order of offset, with deletes before inserts
			this.changes.sort(function(c1, c2) {
				const result = c1.op.p - c2.op.p;
				if (result !== 0) {
					return result;
				} else if ((c1.op.i != null) && (c2.op.d != null)) {
					return 1;
				} else {
					return -1;
				}
			});

			return this._markAsDirty(change, "change", "added");
		}
		
		_removeChange(change) {
			this.changes = this.changes.filter(c => c.id !== change.id);
			return this._markAsDirty(change, "change", "removed");
		}
			
		_applyOpModifications(content, op_modifications) {
			// Put in descending position order, with deleting first if at the same offset 
			// (Inserting first would modify the content that the delete will delete)
			op_modifications.sort(function(a, b) {
				const result = b.p - a.p; 
				if (result !== 0) {
					return result;
				} else if ((a.i != null) && (b.d != null)) {
					return 1;
				} else {
					return -1;
				}
			});

			for (const modification of Array.from(op_modifications)) {
				if (modification.i != null) {
					content = content.slice(0, modification.p) + modification.i + content.slice(modification.p);
				} else if (modification.d != null) {
					if (content.slice(modification.p, modification.p + modification.d.length) !== modification.d) {
						throw new Error(`deleted content does not match. content: ${JSON.stringify(content)}; modification: ${JSON.stringify(modification)}`);
					}
					content = content.slice(0, modification.p) + content.slice(modification.p + modification.d.length);
				}
			}
			return content;
		}
		
		_scanAndMergeAdjacentUpdates() {
			// This should only need calling when deleting an update between two
			// other updates. There's no other way to get two adjacent updates from the
			// same user, since they would be merged on insert.
			let previous_change = null;
			const remove_changes = [];
			const moved_changes = [];
			for (const change of Array.from(this.changes)) {
				if (((previous_change != null ? previous_change.op.i : undefined) != null) && (change.op.i != null)) {
					const previous_change_end = previous_change.op.p + previous_change.op.i.length;
					const previous_change_user_id = previous_change.metadata.user_id;
					const change_start = change.op.p;
					const change_user_id = change.metadata.user_id;
					if ((previous_change_end === change_start) && (previous_change_user_id === change_user_id)) {
						remove_changes.push(change);
						previous_change.op.i += change.op.i;
						moved_changes.push(previous_change);
					}
				} else if (((previous_change != null ? previous_change.op.d : undefined) != null) && (change.op.d != null) && (previous_change.op.p === change.op.p)) {
					// Merge adjacent deletes
					previous_change.op.d += change.op.d;
					remove_changes.push(change);
					moved_changes.push(previous_change);
				} else { // Only update to the current change if we haven't removed it.
					previous_change = change;
				}
			}
			return { moved_changes, remove_changes };
		}
		
		resetDirtyState() {
			return this._dirtyState = {
				comment: {
					moved: {},
					removed: {},
					added: {}
				},
				change: {
					moved: {},
					removed: {},
					added: {}
				}
			};
		}
		
		getDirtyState() {
			return this._dirtyState;
		}
		
		_markAsDirty(object, type, action) {
			return this._dirtyState[type][action][object.id] = object;
		}
		
		_clone(object) {
			const clone = {};
			for (const k in object) { const v = object[k]; clone[k] = v; }
			return clone;
		}
	};
};

if (typeof define !== 'undefined' && define !== null) {
	define([], load);
} else {
	module.exports = load();
}