/*global Quintus:false */

Quintus.Sprites = function(Q) {
 
  // Create a new sprite sheet
  // Options:
  //  tilew - tile width
  //  tileh - tile height
  //  w     - width of the sprite block
  //  h     - height of the sprite block
  //  sx    - start x
  //  sy    - start y
  //  cols  - number of columns per row
  Q.Class.extend("SpriteSheet",{
    init: function(name, asset,options) {
      if(!Q.asset(asset)) { throw "Invalid Asset:" + asset; }
      Q._extend(this,{
        name: name,
        asset: asset,
        w: Q.asset(asset).width,
        h: Q.asset(asset).height,
        tilew: 64,
        tileh: 64,
        sx: 0,
        sy: 0
        });
      if(options) { Q._extend(this,options); }
      this.cols = this.cols || 
                  Math.floor(this.w / this.tilew);
    },

    fx: function(frame) {
      return Math.floor((frame % this.cols) * this.tilew + this.sx);
    },

    fy: function(frame) {
      return Math.floor(Math.floor(frame / this.cols) * this.tileh + this.sy);
    },

    draw: function(ctx, x, y, frame) {
      if(!ctx) { ctx = Q.ctx; }
      ctx.drawImage(Q.asset(this.asset),
                    this.fx(frame),this.fy(frame),
                    this.tilew, this.tileh,
                    Math.floor(x),Math.floor(y),
                    this.tilew, this.tileh);

    }

  });


  Q.sheets = {};
  Q.sheet = function(name,asset,options) {
    if(asset) {
      Q.sheets[name] = new Q.SpriteSheet(name,asset,options);
    } else {
      return Q.sheets[name];
    }
  };

  Q.compileSheets = function(imageAsset,spriteDataAsset) {
    var data = Q.asset(spriteDataAsset);
    Q._each(data,function(spriteData,name) {
      Q.sheet(name,imageAsset,spriteData);
    });
  };


  Q.SPRITE_DEFAULT  = 1;
  Q.SPRITE_PARTICLE = 2;
  Q.SPRITE_ACTIVE   = 4;
  Q.SPRITE_FRIENDLY = 8;
  Q.SPRITE_ENEMY    = 16;
  Q.SPRITE_UI       = 32;


// Properties:
  //    x
  //    y
  //    z - sort order
  //    sheet or asset
  //    frame
  Q.GameObject.extend("Sprite",{
    init: function(props,defaultProps) {
      this.p = Q._extend({ 
        x: 0,
        y: 0,
        z: 0,
        angle: 0,
        frame: 0,
        type: Q.SPRITE_DEFAULT | Q.SPRITE_ACTIVE
      },defaultProps);

      Q._extend(this.p,props); 

      if((!this.p.w || !this.p.h)) {
        if(this.asset()) {
          this.p.w = this.p.w || this.asset().width;
          this.p.h = this.p.h || this.asset().height;
        } else if(this.sheet()) {
          this.p.w = this.p.w || this.sheet().tilew;
          this.p.h = this.p.h || this.sheet().tileh;
        }
      }
      this.p.cx = this.p.cx || (this.p.points ? 0 : (this.p.w / 2));
      this.p.cy = this.p.cy || (this.p.points ? 0 : (this.p.h / 2));
      this.p.id = this.p.id || Q._uniqueId();
    },

    asset: function() {
      return Q.asset(this.p.asset);
    },

    sheet: function() {
      return Q.sheet(this.p.sheet);
    },

    hide: function() {
      this.p.hidden = true;
    },

    show: function() {
      this.p.hidden = false;
    },

    set: function(properties) {
      Q._extend(this.p,properties);
      return this;
    },

    draw: function(ctx) {
      var p = this.p;


      if(this.p.hidden) { return; }
      if(!ctx) { ctx = Q.ctx; }

      this.trigger('predraw',ctx);

      var saved = false;
      if(this.p.opacity != void 0 && this.p.opacity != 1) {
        ctx.save();
        saved = true;
        ctx.globalAlpha = this.p.opacity;
      }

      /* Only worry about context if we have an angle */
      if(p.angle || p.scale) {
        if(!saved) { ctx.save(); saved = true; }

        ctx.translate(p.x,p.y);
        ctx.translate(p.cx,p.cy);
        if(p.scale) { ctx.scale(p.scale,p.scale); }
        ctx.rotate(p.angle * Math.PI / 180);
        ctx.translate(-p.cx, -p.cy);

        if(p.sheet) {
          this.sheet().draw(ctx,0,0,p.frame);
        } else if(p.asset) {
          ctx.drawImage(Q.asset(p.asset),0,0);
        }

      } else {
        if(p.sheet) {
          this.sheet().draw(ctx, p.x, p.y, p.frame);
        } else if(this.asset()) {
          ctx.drawImage(this.asset(),
                        Math.floor(p.x), 
                        Math.floor(p.y));
        }
      }

      if(saved) { ctx.restore(); }
      this.trigger('draw',ctx);

      if(Q.debug) {

        if(this.p.points) {
          ctx.save();
          ctx.translate(this.p.x + this.p.cx, this.p.y + this.p.cy);
          if(p.scale) { ctx.scale(p.scale,p.scale); }
          ctx.rotate(p.angle * Math.PI / 180);
          ctx.translate(-p.cx, -p.cy);
          ctx.beginPath();
          ctx.fillStyle = this.p.hit ? "blue" : "red";
          ctx.strokeStyle = "black";

          ctx.moveTo(this.p.points[0][0],this.p.points[0][1]);
          for(var i=0;i<this.p.points.length;i++) {
            ctx.lineTo(this.p.points[i][0],this.p.points[i][1]);
          }
          ctx.lineTo(this.p.points[0][0],this.p.points[0][1]);
          ctx.stroke();
          ctx.fill();

          ctx.restore();
        }

        ctx.save();
        ctx.globalAlpha = 1;
        ctx.lineWidth = 2;
        ctx.strokeStyle = "#000";
        ctx.beginPath();
        ctx.moveTo(p.x,p.y);
        ctx.lineTo(p.x+p.w,p.y);
        ctx.lineTo(p.x+p.w,p.y+p.h);
        ctx.lineTo(p.x,p.y+p.h);
        ctx.lineTo(p.x,p.y);
        ctx.stroke();
        ctx.restore();
      }
    },

    step: function(dt) {
      this.trigger('step',dt);
    }
  });

  Q.Sprite.extend("MovingSprite",{
    init: function(props,defaultProps) {
      this._super(Q._extend({
        vx: 0,
        vy: 0,
        ax: 0,
        ay: 0
      },props),defaultProps);
   },

   step: function(dt) {
     var p = this.p;

     p.vx += p.ax * dt;
     p.vy += p.ay * dt;

     p.x += p.vx * dt;
     p.y += p.vy * dt;

     this._super(dt);
   }
 });




  return Q;
};