/**
 * A function that produces a value property descriptor, which assumes that properties are enumerable, writable and configurable
 * unless specified
 *
 * @param value The value for the descriptor
 * @param writable Defaults to `true` if not specified
 * @param enumerable Defaults to `true` if not specified
 * @param configurable Defaults to `true` if not specified
 */
function createValuePropertyDescriptor(value: any, writable: boolean = true, enumerable: boolean = true, configurable: boolean = true): PropertyDescriptor {
	return assign(objectCreate(null), {
		value,
		writable,
		enumerable,
		configurable
	});
}

function patchConstruct(target: any, record: ConstructRecord): any {
	const { args, descriptor = defaultConstructDescriptor, Ctor, name, propertyRecords } = record;
	const value = new Ctor(...(args || []));
	if (propertyRecords) {
		propertyRecords.forEach((record) => isConstructRecord(record) ? patchConstruct(value, record) : patchPatch(value, record));
	}
	defineProperty(target, name, assign({ value }, descriptor));
	return target;
}

export function createConstructRecord(Ctor: Constructor, args?: any[], descriptor?: ConstructDescriptor): AnonymousConstructRecord {
	const record: AnonymousConstructRecord = assign(objectCreate(null), { Ctor });
	if (args) {
		record.args = args;
	}
	if (descriptor) {
		record.descriptor = descriptor;
	}
	return record;
}

/**
 * An internal function that returns a new splice record
 *
 * @param start Where in the array to start the splice
 * @param deleteCount The number of elements to delete from the array
 * @param add Elements to be added to the target
 */
function createSpliceRecord(start: number, deleteCount: number, add?: any[]): SpliceRecord {
	const spliceRecord: SpliceRecord = assign(objectCreate(null), {
		type: 'splice',
		start,
		deleteCount
	});

	if (add && add.length) {
		spliceRecord.add = add;
	}

	return spliceRecord;
}

/* tslint:enable:variable-name */

/**
 * An internal function that returns a new patch record
 *
 * @param type The type of patch record
 * @param name The property name the record refers to
 * @param descriptor The property descriptor to be installed on the object
 * @param valueRecords Any subsequenet patch recrds to be applied to the value of the descriptor
 */
function createPatchRecord(type: PatchTypes, name: string, descriptor?: PropertyDescriptor, valueRecords?: (ConstructRecord | PatchRecord | SpliceRecord)[]): PatchRecord {
	const patchRecord = assign(objectCreate(null), {
		type,
		name
	});

	if (descriptor) {
		patchRecord.descriptor = descriptor;
	}
	if (valueRecords) {
		patchRecord.valueRecords = valueRecords;
	}

	return patchRecord as PatchRecord;
}

	/**
	 * Get the difference of the `value`
	 * @param value The value to diff
	 * @param nameOrIndex A `string` if comparing a property or a `number` if comparing an array element
	 * @param parent The outer parent that this value is part of
	 */
	diff(value: T, nameOrIndex: string | number, parent: object): ConstructRecord | void {
		const record = this._differ(value, nameOrIndex, parent);
		if (record && typeof nameOrIndex === 'string') {
			return assign(record, { name: nameOrIndex });
		}
	}