/* Simple JavaScript Inheritance
   * By John Resig http://ejohn.org/
   * MIT Licensed.
   */
  // Inspired by base2 and Prototype
  (function(){
    var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
    // The base Class implementation (does nothing)
    this.Class = function(){};
    
    // Create a new Class that inherits from this class
    Class.extend = function(prop) {
      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
        prototype[name] = typeof prop[name] == "function" && 
          typeof _super[name] == "function" && fnTest.test(prop[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]) :
          prop[name];
      }
      
      // The dummy class constructor
      function Class() {
        // All construction is actually done in the init method
        if ( !initializing && this.init )
          this.init.apply(this, arguments);
      }
      
      // Populate our constructed prototype object
      Class.prototype = prototype;
      
      // Enforce the constructor to be what we expect
      Class.prototype.constructor = Class;
  
      // And make this class extendable
      Class.extend = arguments.callee;
      
      return Class;
    };
  })();
  
  (function() {
      var lastTime = 0;
      var vendors = ['ms', 'moz', 'webkit', 'o'];
      for(var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
          window.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];
          window.cancelAnimationFrame = 
            window[vendors[x]+'CancelAnimationFrame'] || window[vendors[x]+'CancelRequestAnimationFrame'];
      }
   
      if (!window.requestAnimationFrame)
          window.requestAnimationFrame = function(callback, element) {
              var currTime = new Date().getTime();
              var timeToCall = Math.max(0, 16 - (currTime - lastTime));
              var id = window.setTimeout(function() { callback(currTime + timeToCall); }, 
                timeToCall);
              lastTime = currTime + timeToCall;
              return id;
          };
   
      if (!window.cancelAnimationFrame)
          window.cancelAnimationFrame = function(id) {
              clearTimeout(id);
          };
  }());
  
  var Quintus = function(opts) {
    var Q = {};
  
    Q.options = {
      // TODO: set some sensible defaults
    };
    if(opts) { _(Q.options).extend(opts); }
  
    Q._normalizeArg = function(arg) {
      if(_.isString(arg)) {
        arg = arg.replace(/\s+/g,'').split(",");
      }
      if(!_.isArray(arg)) {
        arg = [ arg ];
      }
      return arg;
    };
  
    // Shortcut to extend Quintus with new functionality
    // binding the methods to Q
    Q.extend = function(obj) {
      _(Q).extend(obj);
      return Q;
    };
  
    // Syntax for including other modules into quintus
    Q.include = function(mod) {
      _.each(Q._normalizeArg(mod),function(m) {
        m = Quintus[m] || m;
        m(Q);
      });
      return Q;
    };
  
    Q.gameLoop = function(callback) {
  
      Q.lastGameLoopFrame = new Date().getTime();
  
      Q.gameLoopCallbackWrapper = function(now) {
        Q.loop = requestAnimationFrame(Q.gameLoopCallbackWrapper);
        var dt = now - Q.lastGameLoopFrame;
        if(dt > 100) { dt = 100; }
        callback.apply(Q,[dt / 1000]);  
        Q.lastGameLoopFrame = now;
      };
  
      requestAnimationFrame(Q.gameLoopCallbackWrapper);
    };
  
    Q.pauseGame = function() {
      if(Q.loop) {
        cancelAnimationFrame(Q.loop); 
      }
      Q.loop = null;
    };
  
    Q.unpauseGame = function() {
      if(!Q.loop) {
        Q.lastGameLoopFrame = new Date().getTime();
        Q.loop = requestAnimationFrame(Q.gameLoopCallbackWrapper);
      }
    };
   
    // Adds event support to any object
    // Extended with evented
    Q.Evented = Class.extend({
  
      // Binds a callback on a target object to an 
      // event on this object
      bind: function(event,target,callback) {
        // Handle the case where there is no target provided
        if(!callback) {
          callback = target;
          target = null;
        }
  
        // Handle case for callback that is a string
        if(_.isString(callback)) {
          callback = target[callback];
        }
  
        this.listeners = this.listeners || {};
        this.listeners[event] = this.listeners[event] || [];
        this.listeners[event].push([ target || this, callback]);
  
        if(target) {
          if(!target.binds) { target.binds = []; }
          target.binds.push([this,event,callback]);
        }
      },
  
      // Triggers an event on an object, 
      // triggering all listeners on the object
      trigger: function(event,data) {
        if(this.listeners && this.listeners[event]) {
          for(var i=0,len = this.listeners[event].length;i<len;i++) {
            var listener = this.listeners[event][i];
            listener[1].call(listener[0],data);
          }
        }
      },
  
      unbind: function(event,target,callback) {
        if(!target) {
          if(this.listeners[event]) {
            delete this.listeners[event];
            return;
          }
        } else {
          var l = this.listeners && this.listeners[event];
          if(l) {
            for(var i = l.length-1;i>=0;i--) {
              if(l[i][0] == target) {
                if(!callback || callback == l[i][1]) {
                  this.listeners[event].splice(i,1);
                }
              }
            }
          }
  
        }
      },
  
       // Removes any bound methods from 
       // this object
      debind: function() {
         if(this.binds) {
           for(var i=0,len=this.binds.length;i<len;i++) {
             var boundEvent = this.binds[i],
                 source = boundEvent[0],
                 event = boundEvent[1];
             source.unbind(event,this);
           }
         }
       }
    });
  
    Q.components = {};
  
    Q.register = function(name,methods) {
      methods.name = name;
      Q.components[name] = Q.Component.extend(methods);
    };
  
    Q.Component = Q.Evented.extend({
      init: function(entity) {
        this.entity = entity;
        if(this.extend) _.extend(entity,this.extend);
        entity[this.name] = this;
        entity.activeComponents.push(this.name);
        if(this.added) this.added();
      },
  
      destroy: function() {
        if(this.extend) {
          var extensions = _.keys(this.extend);
          for(var i=0,len=extensions.length;i<len;i++) {
            delete this.entity[extensions[i]];
          }
        }
  
        delete this.entity[this.name];
  
        var idx = this.entity.activeComponents.indexOf(this.name);
        if(idx != -1) { 
          this.entity.activeComponents.splice(idx,1);
        }
  
        this.debind();
        if(this.destroyed) this.destroyed();
      }
  
    });
  
   Q.GameObject = Q.Evented.extend({
  
      has: function(component) {
        return this[component] ? true : false; 
      },
  
      add: function(components) {
        components = Q._normalizeArg(components);
        if(!this.activeComponents) { this.activeComponents = []; }
  
        for(var i=0,len=components.length;i<len;i++) {
          var name = components[i],
              comp = Q.components[name];
          if(!this.has(name) && comp) { 
            var c = new comp(this); 
            this.trigger('addComponent',c);
          }
        }
        return this;
      }, 
  
      del: function(components) {
        components = Q._normalizeArg(components);
  
        for(var i=0,len=components.length;i<len;i++) {
          var name = components[i];
          if(name && this.has(name)) { 
            this.trigger('delComponent',this[name]);
            this[name].destroy(); 
          }
        }
        return this;
      },
  
      destroy: function() {
        if(this.destroyed) { return; }
        this.debind();
        if(this.parent && this.parent.remove) {
          this.parent.remove(this);
        }
        this.trigger('removed');
        this.destroyed = true;
      }
  
    });
  
    return Q;
  };