import diff, { DELETE, EQUAL, ICursorInfo, INSERT } from '../diff';
import { compose, diff as attr_diff, IAttributeMap, invert, transform } from './AttributeMap';
import { IOp, iterator as opiterator, length as oplen } from './Op';

function equal(a: unknown, b: unknown) {
	return JSON.stringify(a) === JSON.stringify(b);
}

const NULL_CHARACTER = String.fromCharCode(0); // Placeholder char for embed in diff()

class Delta {
	public ops: IOp[];
	constructor(ops?: IOp[] | { ops: IOp[] }) {
		// Assume we are given a well formed ops
		if (Array.isArray(ops)) {
			this.ops = ops;
		} else if (ops != null && Array.isArray(ops.ops)) {
			this.ops = ops.ops;
		} else {
			this.ops = [];
		}
	}

	public insert(arg: string | object, attributes?: IAttributeMap): this {
		const newOp: IOp = {};
		if (typeof arg === 'string' && arg.length === 0) {
			return this;
		}
		newOp.insert = arg;
		if (
			attributes != null &&
			typeof attributes === 'object' &&
			Object.keys(attributes).length > 0
		) {
			newOp.attributes = attributes;
		}
		return this.push(newOp);
	}

	public delete(length: number): this {
		if (length <= 0) {
			return this;
		}
		return this.push({ delete: length });
	}

	public retain(length: number, attributes?: IAttributeMap): this {
		if (length <= 0) {
			return this;
		}
		const newOp: IOp = { retain: length };
		if (
			attributes != null &&
			typeof attributes === 'object' &&
			Object.keys(attributes).length > 0
		) {
			newOp.attributes = attributes;
		}
		return this.push(newOp);
	}

	public push(newOp: IOp): this {
		let index = this.ops.length;
		let lastOp = this.ops[index - 1];
		newOp = { ...newOp };
		if (typeof lastOp === 'object') {
			if (
				typeof newOp.delete === 'number' &&
				typeof lastOp.delete === 'number'
			) {
				this.ops[index - 1] = { delete: lastOp.delete + newOp.delete };
				return this;
			}
			// Since it does not matter if we insert before or after deleting at the same index,
			// always prefer to insert first
			if (typeof lastOp.delete === 'number' && newOp.insert != null) {
				index -= 1;
				lastOp = this.ops[index - 1];
				if (typeof lastOp !== 'object') {
					this.ops.unshift(newOp);
					return this;
				}
			}
			if (equal(newOp.attributes, lastOp.attributes)) {
				if (
					typeof newOp.insert === 'string' &&
					typeof lastOp.insert === 'string'
				) {
					this.ops[index - 1] = { insert: lastOp.insert + newOp.insert };
					if (typeof newOp.attributes === 'object') {
						this.ops[index - 1].attributes = newOp.attributes;
					}
					return this;
				} else if (
					typeof newOp.retain === 'number' &&
					typeof lastOp.retain === 'number'
				) {
					this.ops[index - 1] = { retain: lastOp.retain + newOp.retain };
					if (typeof newOp.attributes === 'object') {
						this.ops[index - 1].attributes = newOp.attributes;
					}
					return this;
				}
			}
		}
		if (index === this.ops.length) {
			this.ops.push(newOp);
		} else {
			this.ops.splice(index, 0, newOp);
		}
		return this;
	}

	public chop(): this {
		const lastOp = this.ops[this.ops.length - 1];
		if (lastOp && lastOp.retain && !lastOp.attributes) {
			this.ops.pop();
		}
		return this;
	}

	public filter(predicate: (op: IOp, index: number) => boolean): IOp[] {
		return this.ops.filter(predicate);
	}

	public forEach(predicate: (op: IOp, index: number) => void): void {
		this.ops.forEach(predicate);
	}

	public map<T>(predicate: (op: IOp, index: number) => T): T[] {
		return this.ops.map(predicate);
	}

	public partition(predicate: (op: IOp) => boolean): [IOp[], IOp[]] {
		const passed: IOp[] = [];
		const failed: IOp[] = [];
		this.forEach((op) => {
			const target = predicate(op) ? passed : failed;
			target.push(op);
		});
		return [passed, failed];
	}

	public reduce<T>(
		predicate: (accum: T, curr: IOp, index: number) => T,
		initialValue: T
	): T {
		return this.ops.reduce(predicate, initialValue);
	}

	public changeLength(): number {
		return this.reduce((length, elem) => {
			if (elem.insert) {
				return length + oplen(elem);
			} else if (elem.delete) {
				return length - elem.delete;
			}
			return length;
		}, 0);
	}

	public length(): number {
		return this.reduce((length, elem) => {
			return length + oplen(elem);
		}, 0);
	}

	public slice(start: number = 0, end: number = Infinity): Delta {
		const ops = [];
		const iter = opiterator(this.ops);
		let index = 0;
		while (index < end && iter.hasNext()) {
			let nextOp;
			if (index < start) {
				nextOp = iter.next(start - index);
			} else {
				nextOp = iter.next(end - index);
				ops.push(nextOp);
			}
			index += oplen(nextOp);
		}
		return new Delta(ops);
	}

	public compose(other: Delta): Delta {
		const thisIter = opiterator(this.ops);
		const otherIter = opiterator(other.ops);
		const ops = [];
		const firstOther = otherIter.peek();
		if (
			firstOther != null &&
			typeof firstOther.retain === 'number' &&
			firstOther.attributes == null
		) {
			let firstLeft = firstOther.retain;
			while (
				thisIter.peekType() === 'insert' &&
				thisIter.peekLength() <= firstLeft
			) {
				firstLeft -= thisIter.peekLength();
				ops.push(thisIter.next());
			}
			if (firstOther.retain - firstLeft > 0) {
				otherIter.next(firstOther.retain - firstLeft);
			}
		}
		const delta = new Delta(ops);
		while (thisIter.hasNext() || otherIter.hasNext()) {
			if (otherIter.peekType() === 'insert') {
				delta.push(otherIter.next());
			} else if (thisIter.peekType() === 'delete') {
				delta.push(thisIter.next());
			} else {
				const length = Math.min(thisIter.peekLength(), otherIter.peekLength());
				const thisOp = thisIter.next(length);
				const otherOp = otherIter.next(length);
				if (typeof otherOp.retain === 'number') {
					const newOp: IOp = {};
					if (typeof thisOp.retain === 'number') {
						newOp.retain = length;
					} else {
						newOp.insert = thisOp.insert;
					}
					// Preserve null when composing with a retain, otherwise remove it for inserts
					const attributes = compose(
						thisOp.attributes,
						otherOp.attributes,
						typeof thisOp.retain === 'number'
					);
					if (attributes) {
						newOp.attributes = attributes;
					}
					delta.push(newOp);

					// Optimization if rest of other is just retain
					if (
						!otherIter.hasNext() &&
						equal(delta.ops[delta.ops.length - 1], newOp)
					) {
						const rest = new Delta(thisIter.rest());
						return delta.concat(rest).chop();
					}

					// Other op should be delete, we could be an insert or retain
					// Insert + delete cancels out
				} else if (
					typeof otherOp.delete === 'number' &&
					typeof thisOp.retain === 'number'
				) {
					delta.push(otherOp);
				}
			}
		}
		return delta.chop();
	}

	public concat(other: Delta): Delta {
		const delta = new Delta(this.ops.slice());
		if (other.ops.length > 0) {
			delta.push(other.ops[0]);
			delta.ops = delta.ops.concat(other.ops.slice(1));
		}
		return delta;
	}

	public diff(other: Delta, cursor?: number | ICursorInfo): Delta {
		if (this.ops === other.ops) {
			return new Delta();
		}
		const strings = [this, other].map((delta) => {
			return delta
				.map((op) => {
					if (op.insert != null) {
						return typeof op.insert === 'string' ? op.insert : NULL_CHARACTER;
					}
					const prep = delta === other ? 'on' : 'with';
					throw new Error('diff() called ' + prep + ' non-document');
				})
				.join('');
		});
		const retDelta = new Delta();
		const diffResult = diff(strings[0], strings[1], cursor);
		const thisIter = opiterator(this.ops);
		const otherIter = opiterator(other.ops);
		diffResult.forEach((component) => {
			let length = component[1].length;
			while (length > 0) {
				let opLength = 0;
				switch (component[0]) {
					case INSERT:
						opLength = Math.min(otherIter.peekLength(), length);
						retDelta.push(otherIter.next(opLength));
						break;
					case DELETE:
						opLength = Math.min(length, thisIter.peekLength());
						thisIter.next(opLength);
						retDelta.delete(opLength);
						break;
					case EQUAL:
						opLength = Math.min(
							thisIter.peekLength(),
							otherIter.peekLength(),
							length
						);
						const thisOp = thisIter.next(opLength);
						const otherOp = otherIter.next(opLength);
						if (equal(thisOp.insert, otherOp.insert)) {
							retDelta.retain(
								opLength,
								attr_diff(thisOp.attributes, otherOp.attributes)
							);
						} else {
							retDelta.push(otherOp).delete(opLength);
						}
						break;
				}
				length -= opLength;
			}
		});
		return retDelta.chop();
	}

	public eachLine(
		predicate: (
			line: Delta,
			attributes: IAttributeMap,
			index: number
		) => boolean | void,
		newline: string = '\n'
	): void {
		const iter = opiterator(this.ops);
		let line = new Delta();
		let i = 0;
		while (iter.hasNext()) {
			if (iter.peekType() !== 'insert') {
				return;
			}
			const thisOp = iter.peek();
			const start = oplen(thisOp) - iter.peekLength();
			const index =
				typeof thisOp.insert === 'string'
					? thisOp.insert.indexOf(newline, start) - start
					: -1;
			if (index < 0) {
				line.push(iter.next());
			} else if (index > 0) {
				line.push(iter.next(index));
			} else {
				if (predicate(line, iter.next(1).attributes || {}, i) === false) {
					return;
				}
				i += 1;
				line = new Delta();
			}
		}
		if (line.length() > 0) {
			predicate(line, {}, i);
		}
	}

	public invert(base: Delta): Delta {
		const inverted = new Delta();
		this.reduce((baseIndex, op) => {
			if (op.insert) {
				inverted.delete(oplen(op));
			} else if (op.retain && op.attributes == null) {
				inverted.retain(op.retain);
				return baseIndex + op.retain;
			} else if (op.delete || (op.retain && op.attributes)) {
				const length = (op.delete || op.retain) as number;
				const slice = base.slice(baseIndex, baseIndex + length);
				slice.forEach((baseOp) => {
					if (op.delete) {
						inverted.push(baseOp);
					} else if (op.retain && op.attributes) {
						inverted.retain(
							op.retain,
							invert(op.attributes, baseOp.attributes)
						);
					}
				});
				return baseIndex + length;
			}
			return baseIndex;
		}, 0);
		return inverted.chop();
	}

	public transform(index: number, priority?: boolean): number;
	public transform(other: Delta, priority?: boolean): Delta;
	public transform(arg: number | Delta, priority: boolean = false): typeof arg {
		priority = !!priority;
		if (typeof arg === 'number') {
			return this.transformPosition(arg, priority);
		}
		const other: Delta = arg;
		const thisIter = opiterator(this.ops);
		const otherIter = opiterator(other.ops);
		const delta = new Delta();
		while (thisIter.hasNext() || otherIter.hasNext()) {
			if (
				thisIter.peekType() === 'insert' &&
				(priority || otherIter.peekType() !== 'insert')
			) {
				delta.retain(oplen(thisIter.next()));
			} else if (otherIter.peekType() === 'insert') {
				delta.push(otherIter.next());
			} else {
				const length = Math.min(thisIter.peekLength(), otherIter.peekLength());
				const thisOp = thisIter.next(length);
				const otherOp = otherIter.next(length);
				if (thisOp.delete) {
					// Our delete either makes their delete redundant or removes their retain
					continue;
				} else if (otherOp.delete) {
					delta.push(otherOp);
				} else {
					// We retain either their retain or insert
					delta.retain(
						length,
						transform(
							thisOp.attributes,
							otherOp.attributes,
							priority
						)
					);
				}
			}
		}
		return delta.chop();
	}

	public transformPosition(index: number, priority: boolean = false): number {
		priority = !!priority;
		const thisIter = opiterator(this.ops);
		let offset = 0;
		while (thisIter.hasNext() && offset <= index) {
			const length = thisIter.peekLength();
			const nextType = thisIter.peekType();
			thisIter.next();
			if (nextType === 'delete') {
				index -= Math.min(length, index - offset);
				continue;
			} else if (nextType === 'insert' && (offset < index || !priority)) {
				index += length;
			}
			offset += length;
		}
		return index;
	}
}

export = Delta;