(function () {
  if (typeof Mario === "undefined") window.Mario = {};

  //there are too many possible configurations of pipe to capture in a reasonable
  //set of simple variables. Joints, etc. are just too much.
  //To that end, the pipe class handles simple pipes, and we'll put together
  //anything more complex with individual props. OK? OK.
  Pipe = Mario.Pipe = function (options) {
    this.pos = options.pos;

    //NOTE: direction is the direction you move INTO the pipe.
    this.direction = options.direction;
    this.destination = options.destination;
    this.length = options.length;

    if (this.direction === "UP" || this.direction === "DOWN") {
      this.hitbox = [0, 0, 32, this.length * 16];
      this.midsection = level.pipeUpMid;
      this.endsection = level.pipeTop;
    } else {
      this.hitbox = [0, 0, 16 * this.length, 32];
      this.midsection = level.pipeSideMid;
      this.endsection = level.pipeLeft;
    }
  };

  Pipe.prototype.checkPipe = function () {
    if (this.destination === undefined || !input.isDown(this.direction)) return;

    var h = player.power === 0 ? 16 : 32;
    var x = Math.floor(player.pos[0]);
    var y = Math.floor(player.pos[1]);
    switch (this.direction) {
      case "RIGHT":
        if (
          x === this.pos[0] - 16 &&
          y >= this.pos[1] &&
          y + h <= this.pos[1] + 32
        ) {
          player.pipe(this.direction, this.destination);
        }
        break;
      case "LEFT":
        if (
          x === this.pos[0] + 16 * this.length &&
          y >= this.pos[1] &&
          y + h <= this.pos[1] + 32
        ) {
          player.pipe(this.direction, this.destination);
        }
        break;
      case "UP":
        if (
          y === this.pos[1] + 16 * this.length &&
          x >= this.pos[0] &&
          x + 16 <= this.pos[0] + 32
        ) {
          player.pipe(this.direction, this.destination);
        }
        break;
      case "DOWN":
        if (
          y + h === this.pos[1] &&
          x >= this.pos[0] &&
          x + 16 <= this.pos[0] + 32
        ) {
          player.pipe(this.direction, this.destination);
        }
        break;
    }
  };

  //Note to self: next time, decide on a convention for which thing checks for collisions
  //and stick to it. This is a pain.
  Pipe.prototype.checkCollisions = function () {
    var that = this;
    level.enemies.forEach(function (ent) {
      that.isCollideWith(ent);
    });

    level.items.forEach(function (ent) {
      that.isCollideWith(ent);
    });

    fireballs.forEach(function (ent) {
      that.isCollideWith(ent);
    });

    if (!player.piping) this.isCollideWith(player);
  };

  Pipe.prototype.isCollideWith = function (ent) {
    //long story short: because we scan every item, and and one 'rubble' item is four things with separate positions
    //we'll crash without this line as soon as we destroy a block. OOPS.
    if (ent.pos === undefined) return;

    //the first two elements of the hitbox array are an offset, so let's do this now.
    var hpos1 = [
      Math.floor(this.pos[0] + this.hitbox[0]),
      Math.floor(this.pos[1] + this.hitbox[1]),
    ];
    var hpos2 = [
      Math.floor(ent.pos[0] + ent.hitbox[0]),
      Math.floor(ent.pos[1] + ent.hitbox[1]),
    ];

    //if the hitboxes actually overlap
    if (
      !(
        hpos1[0] > hpos2[0] + ent.hitbox[2] ||
        hpos1[0] + this.hitbox[2] < hpos2[0]
      )
    ) {
      if (
        !(
          hpos1[1] > hpos2[1] + ent.hitbox[3] ||
          hpos1[1] + this.hitbox[3] < hpos2[1]
        )
      ) {
        //if the entity is over the block, it's basically floor
        var center = hpos2[0] + ent.hitbox[2] / 2;
        if (Math.abs(hpos2[1] + ent.hitbox[3] - hpos1[1]) <= ent.vel[1]) {
          ent.vel[1] = 0;
          ent.pos[1] = hpos1[1] - ent.hitbox[3] - ent.hitbox[1];
          ent.standing = true;
          if (ent instanceof Mario.Player) {
            ent.jumping = 0;
          }
        } else if (
          Math.abs(hpos2[1] - hpos1[1] - this.hitbox[3]) > ent.vel[1] &&
          center + 2 >= hpos1[0] &&
          center - 2 <= hpos1[0] + this.hitbox[2]
        ) {
          //ent is under the block.
          ent.vel[1] = 0;
          ent.pos[1] = hpos1[1] + this.hitbox[3];
          if (ent instanceof Mario.Player) {
            ent.jumping = 0;
          }
        } else {
          //entity is hitting it from the side, we're a wall
          ent.collideWall(this);
        }
      }
    }
  };

  //we COULD try to write some shenanigans so that the check gets put into the
  //collision code, but there won't ever be more than a handful of pipes in a level
  //so the performance hit of scanning all of them is miniscule.
  Pipe.prototype.update = function (dt) {
    if (this.destination) this.checkPipe();
  };

  //http://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-an-unsorted-array
  //I honestly have no idea if javascript does this, but I feel like it makes sense
  //stylistically to prefer branching outside of loops when possible as convention

  //TODO: edit the spritesheet so UP and LEFT pipes aren't backwards.
  Pipe.prototype.render = function (ctx, vX, vY) {
    switch (this.direction) {
      case "DOWN":
        this.endsection.render(ctx, this.pos[0], this.pos[1], vX, vY);
        for (var i = 1; i < this.length; i++) {
          this.midsection.render(
            ctx,
            this.pos[0],
            this.pos[1] + i * 16,
            vX,
            vY,
          );
        }
        break;
      case "UP":
        this.endsection.render(
          ctx,
          this.pos[0],
          this.pos[1] + 16 * (this.length - 1),
          vX,
          vY,
        );
        for (var i = 0; i < this.length - 1; i++) {
          this.midsection.render(
            ctx,
            this.pos[0],
            this.pos[1] + i * 16,
            vX,
            vY,
          );
        }
        break;
      case "RIGHT":
        this.endsection.render(ctx, this.pos[0], this.pos[1], vX, vY);
        for (var i = 1; i < this.length; i++) {
          this.midsection.render(
            ctx,
            this.pos[0] + 16 * i,
            this.pos[1],
            vX,
            vY,
          );
        }
        break;
      case "LEFT":
        this.endsection.render(
          ctx,
          this.pos[0] + 16 * (this.length - 1),
          this.pos[1],
          vX,
          vY,
        );
        for (var i = 0; i < this.legth - 1; i++) {
          this.midsection.render(
            ctx,
            this.pos[0],
            this.pos[1] + i * 16,
            vX,
            vY,
          );
        }
        break;
    }
  };
})();