/* vim: set tabstop=4 softtabstop=4 shiftwidth=4 noexpandtab: */

/**

 * Backbone-relational.js 0.10.0

 * (c) 2011-2014 Paul Uithol and contributors (https://github.com/PaulUithol/Backbone-relational/graphs/contributors)

 *

 * Backbone-relational may be freely distributed under the MIT license; see the accompanying LICENSE.txt.

 * For details and documentation: https://github.com/PaulUithol/Backbone-relational.

 * Depends on Backbone (and thus on Underscore as well): https://github.com/documentcloud/backbone.

 *

 * Example:

 *

	Zoo = Backbone.RelationalModel.extend({

		relations: [ {

			type: Backbone.HasMany,

			key: 'animals',

			relatedModel: 'Animal',

			reverseRelation: {

				key: 'livesIn',

				includeInJSON: 'id'

				// 'relatedModel' is automatically set to 'Zoo'; the 'relationType' to 'HasOne'.

			}

		} ],

		toString: function() {

			return this.get( 'name' );

		}

	});

	Animal = Backbone.RelationalModel.extend({

		toString: function() {

			return this.get( 'species' );

		}

	});

	// Creating the zoo will give it a collection with one animal in it: the monkey.

	// The animal created after that has a relation `livesIn` that points to the zoo it's currently associated with.

	// If you instantiate (or fetch) the zebra later, it will automatically be added.

	var zoo = new Zoo({

		name: 'Artis',

		animals: [ { id: 'monkey-1', species: 'Chimp' }, 'lion-1', 'zebra-1' ]

	});

	var lion = new Animal( { id: 'lion-1', species: 'Lion' } ),

		monkey = zoo.get( 'animals' ).first(),

		sameZoo = lion.get( 'livesIn' );

 */

( function( root, factory ) {

	// Set up Backbone-relational for the environment. Start with AMD.

	if ( typeof define === 'function' && define.amd ) {

		define( [ 'exports', 'backbone', 'underscore' ], factory );

	}

	// Next for Node.js or CommonJS.

	else if ( typeof exports !== 'undefined' ) {

		factory( exports, require( 'backbone' ), require( 'underscore' ) );

	}

	// Finally, as a browser global. Use `root` here as it references `window`.

	else {

		factory( root, root.Backbone, root._ );

	}

}( this, function( exports, Backbone, _ ) {

	"use strict";

	Backbone.Relational = {

		showWarnings: true

	};

	/**

	 * Semaphore mixin; can be used as both binary and counting.

	 **/

	Backbone.Semaphore = {

		_permitsAvailable: null,

		_permitsUsed: 0,

		acquire: function() {

			if ( this._permitsAvailable && this._permitsUsed >= this._permitsAvailable ) {

				throw new Error( 'Max permits acquired' );

			}

			else {

				this._permitsUsed++;

			}

		},

		release: function() {

			if ( this._permitsUsed === 0 ) {

				throw new Error( 'All permits released' );

			}

			else {

				this._permitsUsed--;

			}

		},

		isLocked: function() {

			return this._permitsUsed > 0;

		},

		setAvailablePermits: function( amount ) {

			if ( this._permitsUsed > amount ) {

				throw new Error( 'Available permits cannot be less than used permits' );

			}

			this._permitsAvailable = amount;

		}

	};

	/**

	 * A BlockingQueue that accumulates items while blocked (via 'block'),

	 * and processes them when unblocked (via 'unblock').

	 * Process can also be called manually (via 'process').

	 */

	Backbone.BlockingQueue = function() {

		this._queue = [];

	};

	_.extend( Backbone.BlockingQueue.prototype, Backbone.Semaphore, {

		_queue: null,

		add: function( func ) {

			if ( this.isBlocked() ) {

				this._queue.push( func );

			}

			else {

				func();

			}

		},

		// Some of the queued events may trigger other blocking events. By

		// copying the queue here it allows queued events to process closer to

		// the natural order.

		//

		// queue events [ 'A', 'B', 'C' ]

		// A handler of 'B' triggers 'D' and 'E'

		// By copying `this._queue` this executes:

		// [ 'A', 'B', 'D', 'E', 'C' ]

		// The same order the would have executed if they didn't have to be

		// delayed and queued.

		process: function() {

			var queue = this._queue;

			this._queue = [];

			while ( queue && queue.length ) {

				queue.shift()();

			}

		},

		block: function() {

			this.acquire();

		},

		unblock: function() {

			this.release();

			if ( !this.isBlocked() ) {

				this.process();

			}

		},

		isBlocked: function() {

			return this.isLocked();

		}

	});

	/**

	 * Global event queue. Accumulates external events ('add:<key>', 'remove:<key>' and 'change:<key>')

	 * until the top-level object is fully initialized (see 'Backbone.RelationalModel').

	 */

	Backbone.Relational.eventQueue = new Backbone.BlockingQueue();

	/**

	 * Backbone.Store keeps track of all created (and destruction of) Backbone.RelationalModel.

	 * Handles lookup for relations.

	 */

	Backbone.Store = function() {

		this._collections = [];

		this._reverseRelations = [];

		this._orphanRelations = [];

		this._subModels = [];

		this._modelScopes = [ exports ];

	};

	_.extend( Backbone.Store.prototype, Backbone.Events, {

		/**

		 * Create a new `Relation`.

		 * @param {Backbone.RelationalModel} [model]

		 * @param {Object} relation

		 * @param {Object} [options]

		 */

		initializeRelation: function( model, relation, options ) {

			var type = !_.isString( relation.type ) ? relation.type : Backbone[ relation.type ] || this.getObjectByName( relation.type );

			if ( type && type.prototype instanceof Backbone.Relation ) {

				var rel = new type( model, relation, options ); // Also pushes the new Relation into `model._relations`

			}

			else {

				Backbone.Relational.showWarnings && typeof console !== 'undefined' && console.warn( 'Relation=%o; missing or invalid relation type!', relation );

			}

		},

		/**

		 * Add a scope for `getObjectByName` to look for model types by name.

		 * @param {Object} scope

		 */

		addModelScope: function( scope ) {

			this._modelScopes.push( scope );

		},

		/**

		 * Remove a scope.

		 * @param {Object} scope

		 */

		removeModelScope: function( scope ) {

			this._modelScopes = _.without( this._modelScopes, scope );

		},

		/**

		 * Add a set of subModelTypes to the store, that can be used to resolve the '_superModel'

		 * for a model later in 'setupSuperModel'.

		 *

		 * @param {Backbone.RelationalModel} subModelTypes

		 * @param {Backbone.RelationalModel} superModelType

		 */

		addSubModels: function( subModelTypes, superModelType ) {

			this._subModels.push({

				'superModelType': superModelType,

				'subModels': subModelTypes

			});

		},

		/**

		 * Check if the given modelType is registered as another model's subModel. If so, add it to the super model's

		 * '_subModels', and set the modelType's '_superModel', '_subModelTypeName', and '_subModelTypeAttribute'.

		 *

		 * @param {Backbone.RelationalModel} modelType

		 */

		setupSuperModel: function( modelType ) {

			_.find( this._subModels, function( subModelDef ) {

				return _.filter( subModelDef.subModels || [], function( subModelTypeName, typeValue ) {

					var subModelType = this.getObjectByName( subModelTypeName );

					if ( modelType === subModelType ) {

						// Set 'modelType' as a child of the found superModel

						subModelDef.superModelType._subModels[ typeValue ] = modelType;

						// Set '_superModel', '_subModelTypeValue', and '_subModelTypeAttribute' on 'modelType'.

						modelType._superModel = subModelDef.superModelType;

						modelType._subModelTypeValue = typeValue;

						modelType._subModelTypeAttribute = subModelDef.superModelType.prototype.subModelTypeAttribute;

						return true;

					}

				}, this ).length;

			}, this );

		},

		/**

		 * Add a reverse relation. Is added to the 'relations' property on model's prototype, and to

		 * existing instances of 'model' in the store as well.

		 * @param {Object} relation

		 * @param {Backbone.RelationalModel} relation.model

		 * @param {String} relation.type

		 * @param {String} relation.key

		 * @param {String|Object} relation.relatedModel

		 */

		addReverseRelation: function( relation ) {

			var exists = _.any( this._reverseRelations, function( rel ) {

				return _.all( relation || [], function( val, key ) {

					return val === rel[ key ];

				});

			});

			if ( !exists && relation.model && relation.type ) {

				this._reverseRelations.push( relation );

				this._addRelation( relation.model, relation );

				this.retroFitRelation( relation );

			}

		},

		/**

		 * Deposit a `relation` for which the `relatedModel` can't be resolved at the moment.

		 *

		 * @param {Object} relation

		 */

		addOrphanRelation: function( relation ) {

			var exists = _.any( this._orphanRelations, function( rel ) {

				return _.all( relation || [], function( val, key ) {

					return val === rel[ key ];

				});

			});

			if ( !exists && relation.model && relation.type ) {

				this._orphanRelations.push( relation );

			}

		},

		/**

		 * Try to initialize any `_orphanRelation`s

		 */

		processOrphanRelations: function() {

			// Make sure to operate on a copy since we're removing while iterating

			_.each( this._orphanRelations.slice( 0 ), function( rel ) {

				var relatedModel = Backbone.Relational.store.getObjectByName( rel.relatedModel );

				if ( relatedModel ) {

					this.initializeRelation( null, rel );

					this._orphanRelations = _.without( this._orphanRelations, rel );

				}

			}, this );

		},

		/**

		 *

		 * @param {Backbone.RelationalModel.constructor} type

		 * @param {Object} relation

		 * @private

		 */

		_addRelation: function( type, relation ) {

			if ( !type.prototype.relations ) {

				type.prototype.relations = [];

			}

			type.prototype.relations.push( relation );

			_.each( type._subModels || [], function( subModel ) {

				this._addRelation( subModel, relation );

			}, this );

		},

		/**

		 * Add a 'relation' to all existing instances of 'relation.model' in the store

		 * @param {Object} relation

		 */

		retroFitRelation: function( relation ) {

			var coll = this.getCollection( relation.model, false );

			coll && coll.each( function( model ) {

				if ( !( model instanceof relation.model ) ) {

					return;

				}

				var rel = new relation.type( model, relation );

			}, this );

		},

		/**

		 * Find the Store's collection for a certain type of model.

		 * @param {Backbone.RelationalModel} type

		 * @param {Boolean} [create=true] Should a collection be created if none is found?

		 * @return {Backbone.Collection} A collection if found (or applicable for 'model'), or null

		 */

		getCollection: function( type, create ) {

			if ( type instanceof Backbone.RelationalModel ) {

				type = type.constructor;

			}

			var rootModel = type;

			while ( rootModel._superModel ) {

				rootModel = rootModel._superModel;

			}

			var coll = _.find( this._collections, function( item ) {

				return item.model === rootModel;

			});

			if ( !coll && create !== false ) {

				coll = this._createCollection( rootModel );

			}

			return coll;

		},

		/**

		 * Find a model type on one of the modelScopes by name. Names are split on dots.

		 * @param {String} name

		 * @return {Object}

		 */

		getObjectByName: function( name ) {

			var parts = name.split( '.' ),

				type = null;

			_.find( this._modelScopes, function( scope ) {

				type = _.reduce( parts || [], function( memo, val ) {

					return memo ? memo[ val ] : undefined;

				}, scope );

				if ( type && type !== scope ) {

					return true;

				}

			}, this );

			return type;

		},

		_createCollection: function( type ) {

			var coll;

			// If 'type' is an instance, take its constructor

			if ( type instanceof Backbone.RelationalModel ) {