/**

 * Backbone-relational.js 0.6.0

 * (c) 2011 Paul Uithol

 * 

 * 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 'update:<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._subModels = [];

		this._modelScopes = [ exports ];

	};

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

		addModelScope: function( scope ) {

			this._modelScopes.push( 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 );

				var addRelation = function( model, relation ) {

					if ( !model.prototype.relations ) {

						model.prototype.relations = [];

					}

					model.prototype.relations.push( relation );

					_.each( model._subModels, function( subModel ) {

							addRelation( subModel, relation );

						}, this );

				};

				addRelation( relation.model, relation );

				this.retroFitRelation( relation );

			}

		},

		/**

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

			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} model

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

		 */

		getCollection: function( model ) {

			if ( model instanceof Backbone.RelationalModel ) {

				model = model.constructor;

			}

			var rootModel = model;

			while ( rootModel._superModel ) {

				rootModel = rootModel._superModel;

			}

			var coll = _.detect( this._collections, function( c ) {

					return c.model === rootModel;

				});

			if ( !coll ) {

				coll = this._createCollection( rootModel );

			}

			return coll;

		},

		/**

		 * Find a type on the global object by name. Splits name 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[ val ];

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

		},

		/**

		 *

		 * @param type

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

		 */

		find: function( type, item ) {

			var id = this.resolveIdForItem( type, item );

			var coll = this.getCollection( type );

			// Because the found object could be of any of the type's superModel

			// types, only return it if it's actually of the type asked for.

			if ( coll ) {

				var obj = coll.get( id );

				if ( obj instanceof type ) {

					return obj;

				}

			}

			return null;

		},

		/**

		 * Add a 'model' to it's appropriate collection. Retain the original contents of 'model.collection'.

		 * @param {Backbone.RelationalModel} model

		 */

		register: function( model ) {

			var coll = this.getCollection( model );

			if ( coll ) {

				if ( coll.get( model ) ) {

					throw new Error( "Cannot instantiate more than one Backbone.RelationalModel with the same id per type!" );

				}

				var modelColl = model.collection;

				coll.add( model );

				model.bind( 'destroy', this.unregister, this );

				model.collection = modelColl;

			}

		},

		/**

		 * Explicitly update a model's id in it's store collection

		 * @param {Backbone.RelationalModel} model

		 */

		update: function( model ) {

			var coll = this.getCollection( model );

			coll._onModelEvent( 'change:' + model.idAttribute, model, coll );

		},

		/**

		 * Remove a 'model' from the store.

		 * @param {Backbone.RelationalModel} model

		 */

		unregister: function( model ) {

			model.unbind( 'destroy', this.unregister );

			var coll = this.getCollection( model );

			coll && coll.remove( model );

		}

	});

	Backbone.Relational.store = new Backbone.Store();

	/**

	 * The main Relation class, from which 'HasOne' and 'HasMany' inherit. Internally, 'relational:<key>' events

	 * are used to regulate addition and removal of models from relations.

	 *

	 * @param {Backbone.RelationalModel} instance

	 * @param {Object} options

	 * @param {string} options.key

	 * @param {Backbone.RelationalModel.constructor} options.relatedModel