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

/**

 * Backbone-relational.js 0.8.5

 * (c) 2011-2013 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.

 */

( function( undefined ) {

	"use strict";

	/**

	 * CommonJS shim

	 **/

	var _, Backbone, exports;

	if ( typeof window === 'undefined' ) {

		_ = require( 'underscore' );

		Backbone = require( 'backbone' );

		exports = module.exports = Backbone;

	}

	else {

		_ = window._;

		Backbone = window.Backbone;

		exports = window;

	}

	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();

			}

		},

		process: function() {

			while ( this._queue && this._queue.length ) {

				this._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 ) {

				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 _.find( 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 );

			}, 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;

				}

				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 = _.findWhere( this._collections, { 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 ) {

				type = type.constructor;

			}

			// Type should inherit from Backbone.RelationalModel.

			if ( type.prototype instanceof Backbone.RelationalModel ) {

				coll = new Backbone.Collection();

				coll.model = type;

				this._collections.push( coll );

			}

			return coll;

		},

		/**

		 * Find the attribute that is to be used as the `id` on a given object

		 * @param type

		 * @param {String|Number|Object|Backbone.RelationalModel} item

		 * @return {String|Number}

		 */

		resolveIdForItem: function( type, item ) {

			var id = _.isString( item ) || _.isNumber( item ) ? item : null;

			if ( id === null ) {

				if ( item instanceof Backbone.RelationalModel ) {

					id = item.id;

				}

				else if ( _.isObject( item ) ) {

					id = item[ type.prototype.idAttribute ];

				}

			}

			// Make all falsy values `null` (except for 0, which could be an id.. see '/issues/179')

			if ( !id && id !== 0 ) {

				id = null;

			}

			return id;

		},

		/**

		 * Find a specific model of a certain `type` in the store