window.wp = window.wp || {};

(function( exports, $ ){

	var api = {}, ctor, inherits,

		slice = Array.prototype.slice;

	// Shared empty constructor function to aid in prototype-chain creation.

	ctor = function() {};

	/**

	 * Helper function to correctly set up the prototype chain, for subclasses.

	 * Similar to `goog.inherits`, but uses a hash of prototype properties and

	 * class properties to be extended.

	 *

	 * @param  object parent      Parent class constructor to inherit from.

	 * @param  object protoProps  Properties to apply to the prototype for use as class instance properties.

	 * @param  object staticProps Properties to apply directly to the class constructor.

	 * @return child              The subclassed constructor.

	 */

	inherits = function( parent, protoProps, staticProps ) {

		var child;

		// The constructor function for the new subclass is either defined by you

		// (the "constructor" property in your `extend` definition), or defaulted

		// by us to simply call `super()`.

		if ( protoProps && protoProps.hasOwnProperty( 'constructor' ) ) {

			child = protoProps.constructor;

		} else {

			child = function() {

				// Storing the result `super()` before returning the value

				// prevents a bug in Opera where, if the constructor returns

				// a function, Opera will reject the return value in favor of

				// the original object. This causes all sorts of trouble.

				var result = parent.apply( this, arguments );

				return result;

			};

		}

		// Inherit class (static) properties from parent.

		$.extend( child, parent );

		// Set the prototype chain to inherit from `parent`, without calling

		// `parent`'s constructor function.

		ctor.prototype  = parent.prototype;

		child.prototype = new ctor();

		// Add prototype properties (instance properties) to the subclass,

		// if supplied.

		if ( protoProps )

			$.extend( child.prototype, protoProps );

		// Add static properties to the constructor function, if supplied.

		if ( staticProps )

			$.extend( child, staticProps );

		// Correctly set child's `prototype.constructor`.

		child.prototype.constructor = child;

		// Set a convenience property in case the parent's prototype is needed later.

		child.__super__ = parent.prototype;

		return child;

	};

	/**

	 * Base class for object inheritance.

	 */

	api.Class = function( applicator, argsArray, options ) {

		var magic, args = arguments;

		if ( applicator && argsArray && api.Class.applicator === applicator ) {

			args = argsArray;

			$.extend( this, options || {} );

		}

		magic = this;

		if ( this.instance ) {

			magic = function() {

				return magic.instance.apply( magic, arguments );

			};

			$.extend( magic, this );

		}

		magic.initialize.apply( magic, args );

		return magic;

	};

	/**

	 * Creates a subclass of the class.

	 *

	 * @param  object protoProps  Properties to apply to the prototype.

	 * @param  object staticProps Properties to apply directly to the class.

	 * @return child              The subclass.

	 */

	api.Class.extend = function( protoProps, classProps ) {

		var child = inherits( this, protoProps, classProps );

		child.extend = this.extend;

		return child;

	};

	api.Class.applicator = {};

	api.Class.prototype.initialize = function() {};

	/*

	 * Checks whether a given instance extended a constructor.

	 *

	 * The magic surrounding the instance parameter causes the instanceof

	 * keyword to return inaccurate results; it defaults to the function's

	 * prototype instead of the constructor chain. Hence this function.

	 */

	api.Class.prototype.extended = function( constructor ) {

		var proto = this;

		while ( typeof proto.constructor !== 'undefined' ) {

			if ( proto.constructor === constructor )

				return true;

			if ( typeof proto.constructor.__super__ === 'undefined' )

				return false;

			proto = proto.constructor.__super__;

		}

		return false;

	};

	/**

	 * An events manager object, offering the ability to bind to and trigger events.

	 *

	 * Used as a mixin.

	 */

	api.Events = {

		trigger: function( id ) {

			if ( this.topics && this.topics[ id ] )

				this.topics[ id ].fireWith( this, slice.call( arguments, 1 ) );

			return this;

		},

		bind: function( id ) {

			this.topics = this.topics || {};

			this.topics[ id ] = this.topics[ id ] || $.Callbacks();

			this.topics[ id ].add.apply( this.topics[ id ], slice.call( arguments, 1 ) );

			return this;

		},

		unbind: function( id ) {

			if ( this.topics && this.topics[ id ] )

				this.topics[ id ].remove.apply( this.topics[ id ], slice.call( arguments, 1 ) );

			return this;

		}

	};

	/**

	 * Observable values that support two-way binding.

	 *

	 */

		initialize: function( initial, options ) {

			this._value = initial; // @todo: potentially change this to a this.set() call.

			this.callbacks = $.Callbacks();

			this._dirty = false;

			$.extend( this, options || {} );

			this.set = $.proxy( this.set, this );

		},

		/*

		 * Magic. Returns a function that will become the instance.

		 * Set to null to prevent the instance from extending a function.

		 */

		instance: function() {

			return arguments.length ? this.set.apply( this, arguments ) : this.get();

		},

		get: function() {

			return this._value;

		},

		set: function( to ) {

			var from = this._value;

			to = this._setter.apply( this, arguments );

			to = this.validate( to );

			// Bail if the sanitized value is null or unchanged.

			if ( null === to || _.isEqual( from, to ) ) {

				return this;

			}

			this._value = to;

			this._dirty = true;

			this.callbacks.fireWith( this, [ to, from ] );

			return this;

		},

		_setter: function( to ) {

			return to;

		},

		setter: function( callback ) {

			var from = this.get();

			this._setter = callback;

			// Temporarily clear value so setter can decide if it's valid.

			this._value = null;

			this.set( from );

			return this;

		},

		resetSetter: function() {

			this._setter = this.constructor.prototype._setter;

			this.set( this.get() );

			return this;

		},

		validate: function( value ) {

			return value;

		},

		bind: function() {

			this.callbacks.add.apply( this.callbacks, arguments );

			return this;

		},

		unbind: function() {

			this.callbacks.remove.apply( this.callbacks, arguments );

			return this;

		},

		link: function() { // values*

			var set = this.set;

			$.each( arguments, function() {

				this.bind( set );

			});

			return this;

		},

		unlink: function() { // values*

			var set = this.set;

			$.each( arguments, function() {

				this.unbind( set );

			});

			return this;

		},

		sync: function() { // values*

			var that = this;

			$.each( arguments, function() {

				that.link( this );

				this.link( that );

			});

			return this;

		},

		unsync: function() { // values*

			var that = this;

			$.each( arguments, function() {

				that.unlink( this );

				this.unlink( that );

			});

			return this;

		}

	});

	/**

	 * A collection of observable values.

	 *

	 * @augments wp.customize.Class

	 * @mixes wp.customize.Events

	 */

		defaultConstructor: api.Value,

		initialize: function( options ) {

			$.extend( this, options || {} );

			this._value = {};

			this._deferreds = {};

		},

		instance: function( id ) {

			if ( arguments.length === 1 )

				return this.value( id );

			return this.when.apply( this, arguments );

		},

		value: function( id ) {

			return this._value[ id ];

		},

		has: function( id ) {

			return typeof this._value[ id ] !== 'undefined';

		},