// Knockout Mapping plugin v2.1.2

// (c) 2012 Steven Sanderson, Roy Jacobs - http://knockoutjs.com/

// License: MIT (http://www.opensource.org/licenses/mit-license.php)

(function (factory) {

	// Module systems magic dance.

	if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {

		// CommonJS or Node: hard-coded dependency on "knockout"

		factory(require("knockout"), exports);

	} else if (typeof define === "function" && define["amd"]) {

		// AMD anonymous module with hard-coded dependency on "knockout"

		define(["knockout", "exports"], factory);

	} else {

		// <script> tag: use the global `ko` object, attaching a `mapping` property

		factory(ko, ko.mapping = {});

	}

}(function (ko, exports) {

	var DEBUG=true;

	var mappingProperty = "__ko_mapping__";

	var realKoDependentObservable = ko.dependentObservable;

	var mappingNesting = 0;

	var dependentObservables;

	var visitedObjects;

	var _defaultOptions = {

		include: ["_destroy"],

		ignore: [],

		copy: []

	};

	var defaultOptions = _defaultOptions;

	exports.isMapped = function (viewModel) {

		var unwrapped = ko.utils.unwrapObservable(viewModel);

		return unwrapped && unwrapped[mappingProperty];

	}

	exports.fromJS = function (jsObject /*, inputOptions, target*/ ) {

		if (arguments.length == 0) throw new Error("When calling ko.fromJS, pass the object you want to convert.");

		// When mapping is completed, even with an exception, reset the nesting level

		window.setTimeout(function () {

			mappingNesting = 0;

		}, 0);

		if (!mappingNesting++) {

			dependentObservables = [];

			visitedObjects = new objectLookup();

		}

		var options;

		var target;

		if (arguments.length == 2) {

			if (arguments[1][mappingProperty]) {

				target = arguments[1];

			} else {

				options = arguments[1];

			}

		}

		if (arguments.length == 3) {

			options = arguments[1];

			target = arguments[2];

		}

		if (target) {

			options = mergeOptions(target[mappingProperty], options);

		} else {

			options = mergeOptions(options);

		}

		options.mappedProperties = options.mappedProperties || {};

		var result = updateViewModel(target, jsObject, options);

		if (target) {

			result = target;

		}

		// Evaluate any dependent observables that were proxied.

		// Do this in a timeout to defer execution. Basically, any user code that explicitly looks up the DO will perform the first evaluation. Otherwise,

		// it will be done by this code.

		if (!--mappingNesting) {

			window.setTimeout(function () {

				while (dependentObservables.length) {

					var DO = dependentObservables.pop();

					if (DO) DO();

				}

			}, 0);

		}

		// Save any new mapping options in the view model, so that updateFromJS can use them later.

		result[mappingProperty] = mergeOptions(result[mappingProperty], options);

		return result;

	};

	exports.fromJSON = function (jsonString /*, options, target*/ ) {

		var parsed = ko.utils.parseJson(jsonString);

		arguments[0] = parsed;

		return exports.fromJS.apply(this, arguments);

	};

	exports.updateFromJS = function (viewModel) {

		throw new Error("ko.mapping.updateFromJS, use ko.mapping.fromJS instead. Please note that the order of parameters is different!");

	};

	exports.updateFromJSON = function (viewModel) {

		throw new Error("ko.mapping.updateFromJSON, use ko.mapping.fromJSON instead. Please note that the order of parameters is different!");

	};

	exports.toJS = function (rootObject, options) {

		if (arguments.length == 0) throw new Error("When calling ko.mapping.toJS, pass the object you want to convert.");

		// Merge in the options used in fromJS

		options = mergeOptions(rootObject[mappingProperty], options);

		// We just unwrap everything at every level in the object graph

		return visitModel(rootObject, function (x) {

			return ko.utils.unwrapObservable(x)

		}, options);

	};

	exports.toJSON = function (rootObject, options) {

		var plainJavaScriptObject = exports.toJS(rootObject, options);

		return ko.utils.stringifyJson(plainJavaScriptObject);

	};

	exports.visitModel = function (rootObject, callback, options) {

		if (arguments.length == 0) throw new Error("When calling ko.mapping.visitModel, pass the object you want to visit.");

		// Merge in the options used in fromJS

		options = mergeOptions(rootObject[mappingProperty], options);

		return visitModel(rootObject, callback, options);

	};

	exports.defaultOptions = function () {

		if (arguments.length > 0) {

			defaultOptions = arguments[0];

		} else {

			return defaultOptions;

		}

	};

	exports.resetDefaultOptions = function () {

		defaultOptions = {

			include: _defaultOptions.include.slice(0),

			ignore: _defaultOptions.ignore.slice(0),

			copy: _defaultOptions.copy.slice(0)

		};

	};

	exports.getType = function(x) {

		if ((x) && (typeof (x) === "object")) {

			if (x.constructor == (new Date).constructor) return "date";

			if (x.constructor == (new Array).constructor) return "array";

		}

		return typeof x;

	}

	function extendOptionsArray(distArray, sourceArray) {

		return ko.utils.arrayGetDistinctValues(

			ko.utils.arrayPushAll(distArray, sourceArray)

		);

	}

	function extendOptionsObject(target, options) {

		var type = exports.getType,

			name, special = { "include": true, "ignore": true, "copy": true },

			t, o, i = 1, l = arguments.length;

		if (type(target) !== "object") {

			target = {};

		}

		for (; i < l; i++) {

			options = arguments[i];

			if (type(options) !== "object") {

				options = {};

			}

			for (name in options) {

				t = target[name]; o = options[name];

				if (name !== "constructor" && special[name] && type(o) !== "array") {

					if (type(o) !== "string") {

						throw new Error("ko.mapping.defaultOptions()." + name + " should be an array or string.");

					}

					o = [o];

				}

				switch (type(o)) {

				case "object": // Recurse

					t = type(t) === "object" ? t : {};

					target[name] = extendOptionsObject(t, o);

					break;

				case "array":

					t = type(t) === "array" ? t : [];

					target[name] = extendOptionsArray(t, o);

					break;

				default:

					target[name] = o;

				}

			}

		}

		return target;

	}

	function mergeOptions() {

		var options = ko.utils.arrayPushAll([{}, defaultOptions], arguments); // Always use empty object as target to avoid changing default options

		options = extendOptionsObject.apply(this, options);

		return options;

	}

	// When using a 'create' callback, we proxy the dependent observable so that it doesn't immediately evaluate on creation.

	// The reason is that the dependent observables in the user-specified callback may contain references to properties that have not been mapped yet.

	function withProxyDependentObservable(dependentObservables, callback) {

		var localDO = ko.dependentObservable;

		ko.dependentObservable = function (read, owner, options) {

			options = options || {};

			if (read && typeof read == "object") { // mirrors condition in knockout implementation of DO's

				options = read;

			}

			var realDeferEvaluation = options.deferEvaluation;

			var isRemoved = false;

			// We wrap the original dependent observable so that we can remove it from the 'dependentObservables' list we need to evaluate after mapping has

			// completed if the user already evaluated the DO themselves in the meantime.

			var wrap = function (DO) {

				var wrapped = realKoDependentObservable({

					read: function () {

						if (!isRemoved) {

							ko.utils.arrayRemoveItem(dependentObservables, DO);

							isRemoved = true;

						}

						return DO.apply(DO, arguments);

					},

					write: function (val) {

						return DO(val);

					},

					deferEvaluation: true

				});

				if(DEBUG) wrapped._wrapper = true;

				return wrapped;

			};

			options.deferEvaluation = true; // will either set for just options, or both read/options.

			var realDependentObservable = new realKoDependentObservable(read, owner, options);

			if (!realDeferEvaluation) {

				realDependentObservable = wrap(realDependentObservable);

				dependentObservables.push(realDependentObservable);

			}

			return realDependentObservable;

		}

		ko.dependentObservable.fn = realKoDependentObservable.fn;

		ko.computed = ko.dependentObservable;

		var result = callback();

		ko.dependentObservable = localDO;

		ko.computed = ko.dependentObservable;

		return result;

	}

	function updateViewModel(mappedRootObject, rootObject, options, parentName, parent, parentPropertyName) {

		var isArray = ko.utils.unwrapObservable(rootObject) instanceof Array;

		// If nested object was already mapped previously, take the options from it

		if (parentName !== undefined && exports.isMapped(mappedRootObject)) {

			options = ko.utils.unwrapObservable(mappedRootObject)[mappingProperty];

			parentName = "";

			parentPropertyName = "";

		}

		parentName = parentName || "";

		parentPropertyName = parentPropertyName || "";

		var callbackParams = {

			data: rootObject,

			parent: parent

		};

		var getCallback = function (name) {

			var callback;

			if (parentName === "") {

				callback = options[name];

			} else if (callback = options[parentName]) {

				callback = callback[name]

			}

			return callback;

		};

		var hasCreateCallback = function () {

			return getCallback("create") instanceof Function;

		};

		var createCallback = function (data) {

			return withProxyDependentObservable(dependentObservables, function () {

				return getCallback("create")({

					data: data || callbackParams.data,

					parent: callbackParams.parent

				});

			});

		};

		var hasUpdateCallback = function () {

			return getCallback("update") instanceof Function;

		};

		var updateCallback = function (obj, data) {

			var params = {

				data: data || callbackParams.data,

				parent: callbackParams.parent,

				target: ko.utils.unwrapObservable(obj)

			};

			if (ko.isWriteableObservable(obj)) {

				params.observable = obj;

			}

			return getCallback("update")(params);

		}

		var alreadyMapped = visitedObjects.get(rootObject);

		if (alreadyMapped) {

			return alreadyMapped;

		}

		if (!isArray) {

			// For atomic types, do a direct update on the observable

			if (!canHaveProperties(rootObject)) {

				switch (exports.getType(rootObject)) {

				case "function":

					if (hasUpdateCallback()) {

						if (ko.isWriteableObservable(rootObject)) {

							rootObject(updateCallback(rootObject));

							mappedRootObject = rootObject;

						} else {

							mappedRootObject = updateCallback(rootObject);

						}

					} else {

						mappedRootObject = rootObject;

					}

					break;

				default:

					if (ko.isWriteableObservable(mappedRootObject)) {

						if (hasUpdateCallback()) {

							mappedRootObject(updateCallback(mappedRootObject));

						} else {

							mappedRootObject(ko.utils.unwrapObservable(rootObject));

						}

					} else {

						if (hasCreateCallback()) {

							mappedRootObject = createCallback();

						} else {

							mappedRootObject = ko.observable(ko.utils.unwrapObservable(rootObject));

						}

						if (hasUpdateCallback()) {

							mappedRootObject(updateCallback(mappedRootObject));

						}

					}

					break;

				}

			} else {

				mappedRootObject = ko.utils.unwrapObservable(mappedRootObject);

				if (!mappedRootObject) {

					if (hasCreateCallback()) {

						var result = createCallback();

						if (hasUpdateCallback()) {

							result = updateCallback(result);

						}

						return result;

					} else {

						if (hasUpdateCallback()) {

							return updateCallback(result);

						}

						mappedRootObject = {};

					}

				}

				if (hasUpdateCallback()) {

					mappedRootObject = updateCallback(mappedRootObject);

				}

				visitedObjects.save(rootObject, mappedRootObject);

				// For non-atomic types, visit all properties and update recursively

				visitPropertiesOrArrayEntries(rootObject, function (indexer) {

					var fullPropertyName = getPropertyName(parentPropertyName, rootObject, indexer);

					if (ko.utils.arrayIndexOf(options.ignore, fullPropertyName) != -1) {

						return;

					}

					if (ko.utils.arrayIndexOf(options.copy, fullPropertyName) != -1) {

						mappedRootObject[indexer] = rootObject[indexer];

						return;

					}

					// In case we are adding an already mapped property, fill it with the previously mapped property value to prevent recursion.

					// If this is a property that was generated by fromJS, we should use the options specified there

					var prevMappedProperty = visitedObjects.get(rootObject[indexer]);

					var value = prevMappedProperty || updateViewModel(mappedRootObject[indexer], rootObject[indexer], options, indexer, mappedRootObject, fullPropertyName);

					if (ko.isWriteableObservable(mappedRootObject[indexer])) {

						mappedRootObject[indexer](ko.utils.unwrapObservable(value));

					} else {

						mappedRootObject[indexer] = value;

					}

					options.mappedProperties[fullPropertyName] = true;

				});

			}

		} else {

			var changes = [];

			var hasKeyCallback = getCallback("key") instanceof Function;

			var keyCallback = hasKeyCallback ? getCallback("key") : function (x) {

				return x;

			};

			if (!ko.isObservable(mappedRootObject)) {

				// When creating the new observable array, also add a bunch of utility functions that take the 'key' of the array items into account.

				mappedRootObject = ko.observableArray([]);

				mappedRootObject.mappedRemove = function (valueOrPredicate) {

					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {

							return value === keyCallback(valueOrPredicate);

						};

					return mappedRootObject.remove(function (item) {

						return predicate(keyCallback(item));

					});

				}

				mappedRootObject.mappedRemoveAll = function (arrayOfValues) {

					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);

					return mappedRootObject.remove(function (item) {

						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;

					});

				}

				mappedRootObject.mappedDestroy = function (valueOrPredicate) {

					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {

							return value === keyCallback(valueOrPredicate);

						};

					return mappedRootObject.destroy(function (item) {

						return predicate(keyCallback(item));

					});

				}

				mappedRootObject.mappedDestroyAll = function (arrayOfValues) {

					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);

					return mappedRootObject.destroy(function (item) {

						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;

					});

				}

				mappedRootObject.mappedIndexOf = function (item) {

					var keys = filterArrayByKey(mappedRootObject(), keyCallback);

					var key = keyCallback(item);

					return ko.utils.arrayIndexOf(keys, key);

				}

				mappedRootObject.mappedCreate = function (value) {

					if (mappedRootObject.mappedIndexOf(value) !== -1) {

						throw new Error("There already is an object with the key that you specified.");

					}

					var item = hasCreateCallback() ? createCallback(value) : value;

					if (hasUpdateCallback()) {

						var newValue = updateCallback(item, value);

						if (ko.isWriteableObservable(item)) {

							item(newValue);

						} else {

							item = newValue;

						}

					}

					mappedRootObject.push(item);

					return item;

				}

			}

			var currentArrayKeys = filterArrayByKey(ko.utils.unwrapObservable(mappedRootObject), keyCallback).sort();

			var newArrayKeys = filterArrayByKey(rootObject, keyCallback);

			if (hasKeyCallback) newArrayKeys.sort();

			var editScript = ko.utils.compareArrays(currentArrayKeys, newArrayKeys);

			var ignoreIndexOf = {};

			var newContents = [];

			for (var i = 0, j = editScript.length; i < j; i++) {

				var key = editScript[i];

				var mappedItem;

				var fullPropertyName = getPropertyName(parentPropertyName, rootObject, i);

				switch (key.status) {

				case "added":

					var item = getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);

					mappedItem = updateViewModel(undefined, item, options, parentName, mappedRootObject, fullPropertyName);

					if(!hasCreateCallback()) {

						mappedItem = ko.utils.unwrapObservable(mappedItem);

					}

					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);

					newContents[index] = mappedItem;

					ignoreIndexOf[index] = true;

					break;

				case "retained":

					var item = getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);

					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);

					updateViewModel(mappedItem, item, options, parentName, mappedRootObject, fullPropertyName);

					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);

					newContents[index] = mappedItem;

					ignoreIndexOf[index] = true;

					break;

				case "deleted":

					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);

					break;

				}

				changes.push({

					event: key.status,

					item: mappedItem

				});

			}

			mappedRootObject(newContents);

			var arrayChangedCallback = getCallback("arrayChanged");

			if (arrayChangedCallback instanceof Function) {

				ko.utils.arrayForEach(changes, function (change) {

					arrayChangedCallback(change.event, change.item);

				});

			}

		}

		return mappedRootObject;

	}

	function ignorableIndexOf(array, item, ignoreIndices) {

		for (var i = 0, j = array.length; i < j; i++) {

			if (ignoreIndices[i] === true) continue;

			if (array[i] === item) return i;

		}

		return null;

	}

	function mapKey(item, callback) {

		var mappedItem;

		if (callback) mappedItem = callback(item);

		if (exports.getType(mappedItem) === "undefined") mappedItem = item;

		return ko.utils.unwrapObservable(mappedItem);

	}

	function getItemByKey(array, key, callback) {

		var filtered = ko.utils.arrayFilter(ko.utils.unwrapObservable(array), function (item) {

			return mapKey(item, callback) === key;

		});

		if (filtered.length == 0) throw new Error("When calling ko.update*, the key '" + key + "' was not found!");

		if ((filtered.length > 1) && (canHaveProperties(filtered[0]))) throw new Error("When calling ko.update*, the key '" + key + "' was not unique!");

		return filtered[0];

	}

	function filterArrayByKey(array, callback) {

		return ko.utils.arrayMap(ko.utils.unwrapObservable(array), function (item) {

			if (callback) {

				return mapKey(item, callback);

			} else {

				return item;

			}

		});

	}

	function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {

		if (rootObject instanceof Array) {

			for (var i = 0; i < rootObject.length; i++)

			visitorCallback(i);

		} else {

			for (var propertyName in rootObject)

			visitorCallback(propertyName);

		}

	};

	function canHaveProperties(object) {

		var type = exports.getType(object);

		return (type === "object" || type === "array") && (object !== null) && (type !== "undefined");

	}

	// Based on the parentName, this creates a fully classified name of a property

	function getPropertyName(parentName, parent, indexer) {

		var propertyName = parentName || "";

		if (parent instanceof Array) {

			if (parentName) {

				propertyName += "[" + indexer + "]";

			}

		} else {

			if (parentName) {

				propertyName += ".";

			}

			propertyName += indexer;

		}

		return propertyName;

	}

	function visitModel(rootObject, callback, options, parentName, fullParentName) {

		// If nested object was already mapped previously, take the options from it

		if (parentName !== undefined && exports.isMapped(rootObject)) {

			//options = ko.utils.unwrapObservable(rootObject)[mappingProperty];

			options = mergeOptions(ko.utils.unwrapObservable(rootObject)[mappingProperty], options);

			parentName = "";

		}

		if (parentName === undefined) { // the first call

			visitedObjects = new objectLookup();

		}

		parentName = parentName || "";

		var mappedRootObject;

		var unwrappedRootObject = ko.utils.unwrapObservable(rootObject);

		if (!canHaveProperties(unwrappedRootObject)) {

			return callback(rootObject, fullParentName);

		} else {

			// Only do a callback, but ignore the results

			callback(rootObject, fullParentName);

			mappedRootObject = unwrappedRootObject instanceof Array ? [] : {};

		}

		visitedObjects.save(rootObject, mappedRootObject);

		var origFullParentName = fullParentName;

		visitPropertiesOrArrayEntries(unwrappedRootObject, function (indexer) {

			if (options.ignore && ko.utils.arrayIndexOf(options.ignore, indexer) != -1) return;

			var propertyValue = unwrappedRootObject[indexer];

			var fullPropertyName = getPropertyName(parentName, unwrappedRootObject, indexer);

			// If we don't want to explicitly copy the unmapped property...

			if (ko.utils.arrayIndexOf(options.copy, indexer) === -1) {

				// ...find out if it's a property we want to explicitly include

				if (ko.utils.arrayIndexOf(options.include, indexer) === -1) {

					// Options contains all the properties that were part of the original object.

					// If a property does not exist, and it is not because it is part of an array (e.g. "myProp[3]"), then it should not be unmapped.

					if (options.mappedProperties && !options.mappedProperties[fullPropertyName] && !(unwrappedRootObject instanceof Array)) {

						return;

					}

				}

			}

			fullParentName = getPropertyName(origFullParentName, unwrappedRootObject, indexer);

			var propertyType = exports.getType(ko.utils.unwrapObservable(propertyValue));

			switch (propertyType) {

			case "object":

			case "array":

			case "undefined":

				var previouslyMappedValue = visitedObjects.get(propertyValue);

				mappedRootObject[indexer] = (exports.getType(previouslyMappedValue) !== "undefined") ? previouslyMappedValue : visitModel(propertyValue, callback, options, fullPropertyName, fullParentName);

				break;

			default:

				mappedRootObject[indexer] = callback(propertyValue, fullParentName);

			}

		});

		return mappedRootObject;

	}

	function objectLookup() {

		var keys = [];

		var values = [];

		this.save = function (key, value) {

			var existingIndex = ko.utils.arrayIndexOf(keys, key);

			if (existingIndex >= 0) values[existingIndex] = value;

			else {

				keys.push(key);

				values.push(value);

			}

		};

		this.get = function (key) {

			var existingIndex = ko.utils.arrayIndexOf(keys, key);

			return (existingIndex >= 0) ? values[existingIndex] : undefined;

		};

	};

}));