$(function() {
  var Q = window.Q = Quintus()
                     .include('Input,Sprites,Scenes,DOM')
                     .domOnly()
                     .setup('quintus',{ maximize: true });
  var tileSize = 32;
  var TILE = {
    WALL: 10,
    FLOOR: 30,
    STAIRS: 45
  };
  var impassableTiles = {
    10: true
  };
  Q.input.keyboardControls();
  Q.input.joypadControls({zone: Q.width});

  Q.Level = Q.DOMTileMap.extend({
    legend: {
      "X": "wall",
      ".": "floor",
      "m": "monster",
      "f": "fountain",
      "d": "door",
      "g": "gold",
      "s": "stairs"
    },
    init:function(asset,stage) {
      this.stage = stage;
      this.level = [];
      this.sprites = [];
      var data = Q.asset(asset);
      this.extra = [];
      _.each(data.split("\n"),function(row) { 
        var columns = row.split("");
        if(columns.length > 1) {
          this.level.push(columns);
          this.sprites.push([]);
        }
      },this);

      this._super({
        cols:this.level[0].length,
        rows:this.level.length,
        sheet: 'tiles'
      })

      var tiles =[];
      for(var y=0;y<this.level.length;y++) {
        tiles[y] = [];
        for(var x =0;x<this.level[0].length;x++) {
          var square = this.level[y][x],
              frame = null,
              method = this.legend[square] || "wall";
          
          frame = this[method](x*tileSize,y*tileSize);
          tiles[y].push(frame);
        }
      }
      this.setup(tiles,true);
    },

    insert: function(sprite) {
      this.stage.insert(sprite);
      this.sprites[sprite.p.tileY][sprite.p.tileX] = sprite;
      return sprite;
    },
  
    unfog: function(x,y) {
      for(var sx=x-2,ex=x+2;sx<=ex;sx++) {
        for(var sy=y-2,ey=y+2;sy<=ey;sy++) {
          this.show(sx,sy);
          if(this.validTile(sx,sy) && this.sprites[sy][sx]) {
            this.sprites[sy][sx].show();
          }
        }
      }
    },
    wall: function(x,y) { return TILE.WALL; },
 
    floor: function(x,y) { return TILE.FLOOR; },
 
    stairs: function(x,y) {
      this.startX = x;
      this.startY = y;
      return TILE.STAIRS;
    },
 
    gold: function(x,y) {
      this.insert(new Q.Loot({ x:x, y:y }));
      return TILE.FLOOR;
    },
 
    fountain: function(x,y) {
      this.insert(new Q.Fountain({ x:x, y:y }));
      return TILE.FLOOR;
    },

    monster: function(x,y) {
      var frame = Math.floor(Math.random()*64);
      this.insert(new Q.Enemy({ x:x, y:y, frame:frame }));
      return TILE.FLOOR;
    }
   
  });


  Q.register('tiled', {
    added:function() {
      var p = this.entity.p;
      _(p).extend({
        wait: 0,
        delay: 0.15,
        tileX: Math.floor(p.x / tileSize),
        tileY: Math.floor(p.y / tileSize),
        dx: 0,
        dy: 0
      });
      this.direction = {};
      this.entity.bind('step',this,'move');
      this.entity.bind('removed',this,'removed');
    },

    move: function(dt) {
      var p =this.entity.p,
          stage = this.entity.parent;

      if(p.wait <= 0) {
        var destX = p.tileX, destY = p.tileY;

        if(p.attacking) {
            this.entity.trigger('attack',this.direction);
        } else if(p.dx || p.dy) {
          if(p.dx > 0) { destX += 1; }
          else if(p.dx < 0) { destX -= 1 };
          if(p.dy > 0) { destY += 1; }
          else if(p.dy < 0) { destY -= 1; }

          if(!impassableTiles[stage.level.get(destX,destY)]) {
            var sprite = stage.level.sprites[destY][destX];
            this.direction.dx = destX - p.tileX;
            this.direction.dy = destY - p.tileY;
            this.direction.sprite = sprite;
            if(!sprite) {
              this.moved(destX,destY);
              this.setPosition();
              p.wait = p.delay;
            } else {
              p.wait = p.delay * 2;
            }
            this.entity.trigger(sprite ? 'hit' : 'moved',
                                this.direction);
          }
        } 
      } else {
        p.wait -= dt;
      }
    },
    setPosition: function() {
      var p =this.entity.p;
      p.x = p.tileX * tileSize;
      p.y = p.tileY * tileSize;
    },
    moved: function(destX,destY) {
      var stage = this.entity.parent;
      var p =this.entity.p;
      stage.level.sprites[p.tileY][p.tileX] = null;
      p.tileX = destX;
      p.tileY = destY;
      stage.level.sprites[p.tileY][p.tileX] = this.entity;
    },
    removed: function() {
      var stage = this.entity.parent;
      var p =this.entity.p;
      stage.level.sprites[p.tileY][p.tileX] = null;
    }
  });

  Q.register('transition', {
    added: function() {
      Q.transitionDOM(this.entity.dom,'transform','0.25s');
    }
  });


  Q.register('camera', {
    added: function() {
      this.entity.bind('moved',this,'track');
    },
    track: function() {
      var p = this.entity.p,
          stage = this.entity.parent;
      stage.centerOn(p.x, p.y);
      stage.level.unfog(p.tileX,p.tileY);
    }
  });

  Q.register('player_input', {
    added: function() {
      this.entity.bind('step',this,'input');
    },
    input: function() {
      var p = this.entity.p;
      if(Q.inputs['left']) { p.dx = -1 }
      else if(Q.inputs['right']) { p.dx = 1;}
      else { p.dx = 0;}
      if(Q.inputs['up']) { p.dy = -1 }
      else if(Q.inputs['down']) { p.dy = 1;}
      else { p.dy = 0;}
    }
  });

  Q.register('healthbar', {
    added: function() {
      this.entity.bind('health',this,'update');

      this.bg = $("<div>").appendTo(this.entity.dom).css({
        width: "100%",
        height: 5,
        position: 'absolute',
        bottom: -6,
        left: 0,
        backgroundColor: "#000",
        border: "1px solid #999"
      }).hide();

      this.bar = $("<div>").appendTo(this.entity.dom).css({
        width: "100%",
        height: 5,
        position: 'absolute',
        bottom: -5,
        left: 1,
        backgroundColor: "#F00"
      }).hide();

      Q.transitionDOM(this.bar[0],'width');

    },

    large: function() {
      this.bg.css({ height: 20, bottom: -1 }).show();
      this.bar.css({ height: 20, bottom: 0 }).show();
      return this;
    },

    update: function(sprite) {
      this.bar.show();
      this.bg.show();
      var p = sprite.p;
      var width = Math.round(p.health / p.maxHealth * 100);
      this.bar.css('width',width + "%");
    }
  });




  Q.Player = Q.Sprite.extend({
    init: function(props) {
      this._super(_({
        sheet: 'characters',
        frame: 65,
        wait: 0,
        z: 10,
        attack: 5,
        health: 40,
        maxHealth: 40,
        gold: 0,
        xp: 0
      }).extend(props));
      this.add('player_input, tiled, camera, transition');
      this.bind('hit',this,'collision');
      this.bind('attack',this,'attack');
      this.bind('interact',this,'interact');
      this.bind('heal',this,'heal');
    },

    collision: function(data) {
      this.p.x += data.dx * tileSize/2; 
      this.p.y += data.dy * tileSize/2; 
      this.p.attacking = true;
    },

    attack: function(data) {
      var damage = Math.round(Math.random() * this.p.attack);
      data.sprite.trigger('interact',
                          { source: this, damage: damage });
      this.p.attacking = false;
      this.tiled.setPosition();
    },

    interact: function(data) {
      this.p.health -= data.damage;
      if(this.p.health <= 0) {
        this.destroy();
      }
      this.trigger('health');
    },

    heal: function(data) {
      this.p.health += data.amount;
      if(this.p.health > this.p.maxHealth) {
        this.p.health = this.p.maxHealth;
      }
      this.trigger('health');
    }
  });

  Q.Enemy = Q.Sprite.extend({
    init: function(props) {
      this._super(_({
        sheet: 'characters',
        z: 10,
        health: 10,
        maxHealth: 10,
        damage: 5,
        xp: 100
      }).extend(props));
      this.add('tiled, transition, healthbar');
      this.bind('interact',this,'interact');
      this.hide();
    },

    interact: function(data) {
      this.p.health -= data.damage;
      if(this.p.health <= 0) {
        this.destroy();
        data.source.trigger('xp',this.p.xp);
      } else {
        var damage = Math.round(Math.random() * this.p.damage);
        data.source.trigger('interact',
                            { source: this, damage: damage });
      }
      this.trigger('health',this);
    }
  });

  Q.Fountain= Q.Sprite.extend({
    init: function(props) {
      this._super(_({
        sheet: 'tiles',
        frame: 71,
        z: 10,
        power: 10
      }).extend(props));
      this.add('tiled');
      this.bind('interact',this,'interact');
      this.hide();
    },

    interact: function(data) {
      data.source.trigger('heal',{ amount: this.p.power });
    }
  });

  Q.Loot = Q.Sprite.extend({
    init: function(props) {
      this._super(_({
        sheet: 'items',
        frame: Math.floor(Math.random() * 30 * 9) + 150, 
        z: 10,
        gold: Math.floor(Math.random() * 100)
      }).extend(props));
      this.add('tiled');
      this.bind('interact',this,'interact');
      this.hide();
    },
    interact: function(data) {
      data.source.trigger('gold',this.p.gold);
      this.destroy();
    }
  });



  Q.Stat = Q.Sprite.extend({
    init: function(props) {
      this._super(_(props).extend({
        w: 100, h: 20, z: 100
      }));
      
      this.el.css({color: 'white', fontFamily: 'arial' })
             .text(this.p.text + ": 0");
    },

    update: function(data) {
      this.el.text(this.p.text + ": " + data.amount);
    }
  });

  Q.PlayerHealth = Q.Sprite.extend({
    init: function(props) {
      this._super(_(props).extend({
        w: Q.width / 4, h: 20, z: 100
      }));
      this.add('healthbar');
      this.healthbar.large();
    },
    update: function(sprite) {
      this.trigger('health',sprite);
    }
  });




  


  Q.load(['characters.png',
          'dungeon.png',
          'items.png',
          'level1.txt'], function() {
    
    Q.sheet('characters', 'characters.png', 
            { tilew: tileSize, tileh: tileSize });
    
    Q.sheet('tiles', 'dungeon.png', 
            { tilew: tileSize, tileh: tileSize });
    
    Q.sheet('items', 'items.png',
            { tilew: tileSize, tileh: tileSize });

    Q.scene('hud',new Q.Scene(function(stage) {
      var health, gold, xp;
      health = stage.insert(new Q.PlayerHealth({ x: 0, y: 10 }));
      stage.bind('health',health,'update');
      gold = stage.insert(new Q.Stat({ 
                                  text: "gold", x: Q.width-100, y: 10 
                              }));

      stage.bind('gold',gold,'update');
      xp = stage.insert(new Q.Stat({ text: "xp", x: Q.width-200, y: 10 }));
      stage.bind('xp',xp,'update');
    }));

    
    Q.scene('level1',new Q.Scene(function(stage) {
      Q.stageScene('hud',1);
      if(Q.width > 600 || Q.height > 600) {
        stage.rescale(2);
      }

      stage.level = stage.insert(
                      new Q.Level("level1.txt",stage)
                    );

      stage.add('transition');
      var player = stage.insert(new Q.Player({ x: stage.level.startX ,
                                               y: stage.level.startY }));

      player.camera.track();
      player.bind('removed',stage,function() {
       Q.stageScene('level1');
      });

      player.bind('health',stage,function() {
        Q.stage(1).trigger('health',player);
      });

      Q.stage(1).trigger('health',player);
      player.bind('gold',stage,function(amount) {
        player.p.gold += amount;
        Q.stage(1).trigger('gold',{ amount: player.p.gold });
      });

      player.bind('xp',stage,function(amount) {
        player.p.xp += amount;
        Q.stage(1).trigger('xp',{ amount: player.p.xp });
      });
    

   
    }));
    Q.stageScene('level1');
  });
});