//*****************************************************************************
// Class - Simple JavaScript Inheritance
// by John Resig http://ejohn.org/
// Inspired by base2 and Prototype
// MIT Licensed.
//
// Modifications by Thomas O'Connor
//
// Required Libraries:
// - Underscore
//
// Notes:
// - If a child class tries to call _super() and there was no inhereted 
// function, then we get a hard error.
//
// Updates:
// - Along with overwriting existing functions, child classes can now extend
// existing objects (such as the .defaults in our sprite class).
// - The updated code regarding the dynamically generated constructor function
// helps with debugging, since the function will now have a name that is 
// representative of the derived class type. However, the __proto__ will show
// up in the debugger with the parent's name even though it more closely
// represents the child class, since we copy child class members onto an
// instance of the parent's class each time we create a new child... ah whatever.
//*****************************************************************************

(function(){
	var initializing = false,
		fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;

	// The base Class implementation (does nothing)
	this.Class = function BaseClass(){};

	// Create a new Class that inherits from this class
	Class.extend = function(prop) {

		// _super variable stores the parent class methods
		var _super = this.prototype;

		// Instantiate a base class (but only create the instance,
		// don't run the init constructor)
		initializing = true;
		var prototype = new this();
		initializing = false;

		// Copy the properties over onto the new prototype
		for (var name in prop) {
			// Check if we're overwriting an existing function
			if( typeof prop[name] == "function" &&
				typeof _super[name] == "function" && fnTest.test(prop[name]) ) {

				prototype[name] = (function(name, fn){
					return function() {
						var tmp = this._super;

						// Add a new ._super() method that is the same method
						// but on the super-class
						this._super = _super[name];

						// The method only need to be bound temporarily, so we
						// remove it when we're done executing
						var ret = fn.apply(this, arguments);
						this._super = tmp;

						return ret;
					};
				})(name, prop[name]);
			}

			// Tom addition:
			// Check if we're overwriting an existing object
			else if( typeof prop[name] == "object" && typeof _super[name] == "object" ) {
				prototype[name] = _(_super[name]).clone();
				_(prototype[name]).extend( prop[name] );
			}

			else {
				prototype[name] = prop[name];
			}
		}

		// Another Tom addition - this is solely to help with debugging:
		// If the user supplied a name for the class we use that name for the constructor function
		// Generate a dynamic function name that indicates what this is a derived class from
		prop.typename = prop.typename || "ChildOf" + this.typename;

		// When the constructor function is called, the context ("this") should be the parent class
		// Using JS's Function (akin to eval()) the context is lost, unless we use .apply to
		// propagate the context correctly.
		function customAction() {
			// All construction is actually done in the init method
			if ( !initializing && this.init )
				this.init.apply(this, arguments);
		}
		// This approach isn't ideal, but the benefit of getting better debug information is worth it.
		var func = new Function("action", "return function " + prop.typename + "(){ action.apply(this, arguments) };")(customAction);

		// Populate our constructed prototype object
		func.prototype = prototype;
		func.prototype.constructor = func;

		// And make this class extendable
		if( func.extend === undefined ) {
			func.extend = arguments.callee;
		}
		func._super = arguments.callee;

		return func;
	};
})();

var Person = Class.extend({
  init: function(isDancing){
    this.dancing = isDancing;
  },
  dance: function(){
    return this.dancing;
  }
});
 
var Ninja = Person.extend({
  init: function(){
    this._super( false );
  },
  dance: function(){
    // Call the inherited version of dance()
    return this._super();
  },
  swingSword: function(){
    return true;
  }
});
 
var p = new Person(true);
p.dance(); // => true
 
var n = new Ninja();
n.dance(); // => false
n.swingSword(); // => true
 
// Should all be true
alert( p instanceof Person );
alert( p instanceof Class );
alert( n instanceof Ninja );
alert( n instanceof Person );
alert( n instanceof Class );

//*****************************************************************************
// Base Object
//
// Required Systems:
//  * Engine
//	* Class
//
// Required libraries:
//	* Underscore
//
// Features:
// Initialization function that handles extending the object
// with the properties defined in defaults
// 
// Used to make an object support getting notified of events.
// Events are just strings, can be triggered on any object that derives from
// this class.
//
// Triggering an event on an object will dispatch any callbacks registered
// for that event. If there is a target bound to it, then that object will
// have its callback dispatched.
//
//*****************************************************************************

Engine.BaseObject = Class.extend({

	// Class name, helpful for debugging
	typename: "BaseObject",

	//=========================================================================
	// Derived class types can extend/overwrite any members in the defaults
	defaults: {
		engine: undefined
	},

	//=========================================================================
	// Initialize the object so that any properties passed in get assigned onto
	// the object.
	init: function(props) {
		// Assign the defaults as well as given properties to the object
		_.extend(this, props);
		_.defaults(this, this.defaults );
		this.engine = Engine.GetSingleton();
		this.listeners = {};
	},

	//=========================================================================
	// On destruction, make sure to debind any objects binded to this one
	destroy: function() {
		this.debindEvents();
	},

	//=========================================================================
	// Bind a listener to a specific event and trigger the callback on the target.
	// Target is an optional argument that provides a context for the callback and
	// allows the callback to be removed with a call to debind (to prevent stale
	// events from hanging around).
	bindEvent: function(event,target,callback) {
		// @TODO
	},

	//=========================================================================
	// Checks to see if there are any listeners listening to the specified event
	// If so, each of the listeners is looped over and the callback is called
	// with the provided context.
	triggerEvent: function(event,data) {
		// @TODO
	},

	//=========================================================================
	// Allow for all callbacks to be unbounded for a specific event
	unbindAllEvents: function(event) {
		// @TODO
	},

	//=========================================================================
	// Allow for events to be unbinded when an object is destroyed or no longer
	// needs to be triggered on specific events. Callback is optional, if not
	// inclued the unbind all events for the given context (target).
	unbindEvent: function(event,target,callback) {
		// @TODO
	},

	//=========================================================================
	// If the object has any event info stored on it
	// then we want to remove all of them.
	debindEvents: function() {
		// @TODO
	}
});

		// Define new classes
		var Person = Engine.BaseObject.extend({
			typename: "Person",
			startDancing: function() {
				console.log( "Triggering the 'dance' event on 'this' Person:", this );
				this.triggerEvent("dance");
			}
		});

		var Dog = Engine.BaseObject.extend({
			typename: "Dog",
			bark: function() {
				console.log( "woof! woof!" );
			}
		});

		// Create instances of these new object types
		var newPerson = new Person();
		var newDog = new Dog();

		// Bind the "bark" function to when a "dance" event occurs on the the Person instance
		newPerson.bindEvent( "dance", newDog, "bark" );

		console.log( "Testing the event system:" );
		newPerson.startDancing();	// This will trigger an event, which the dog is binded to

//*****************************************************************************
// Draw Nodes
//
// Required Systems:
//  * Engine
//	* Engine.BaseObject
//
// Required libraries:
//
// Features:
//
//*****************************************************************************

var nodeSortFunc = function(a, b) { return a.zOrder - b.zOrder; };

Engine.DrawNode = Engine.BaseObject.extend({

	typename: "DrawNode",

	defaults: {
		zOrder: 0
	},

	init: function(props) {
		this._super(props);
		this.nodes = [];
	},

	destroy: function() {
		this._super();
		this.removeAllChildren(true);
	},

	//=========================================================================
	// Node management
	attachChild: function( drawNode ) {
		// @TODO
	},

	removeChild: function(drawNode) {
		// @TODO
	},

	removeAllChildren: function() {
		// @TODO
	},

	// Recursively visit all nodes in this tree, calling the passed in function
	// name on each node
	visit: function(funcName, param) {
		// @TODO
	},
});