/* Minification failed. Returning unminified contents.
(1,25): run-time error CSS1031: Expected selector, found '='
(1,25): run-time error CSS1025: Expected comma or open brace, found '='
(11,1): run-time error CSS1019: Unexpected token, found '('
(11,11): run-time error CSS1031: Expected selector, found '('
(11,11): run-time error CSS1025: Expected comma or open brace, found '('
(81,2): run-time error CSS1019: Unexpected token, found ')'
(81,3): run-time error CSS1019: Unexpected token, found '('
(81,4): run-time error CSS1019: Unexpected token, found ')'
(83,1): run-time error CSS1019: Unexpected token, found '('
(83,11): run-time error CSS1031: Expected selector, found '('
(83,11): run-time error CSS1025: Expected comma or open brace, found '('
(110,2): run-time error CSS1019: Unexpected token, found '('
(110,3): run-time error CSS1019: Unexpected token, found ')'
(110,4): run-time error CSS1019: Unexpected token, found ')'
(112,10): run-time error CSS1031: Expected selector, found 'KeyboardInputManager('
(112,10): run-time error CSS1025: Expected comma or open brace, found 'KeyboardInputManager('
(129,35): run-time error CSS1031: Expected selector, found '='
(129,35): run-time error CSS1025: Expected comma or open brace, found '='
(136,37): run-time error CSS1031: Expected selector, found '='
(136,37): run-time error CSS1025: Expected comma or open brace, found '='
(145,39): run-time error CSS1031: Expected selector, found '='
(145,39): run-time error CSS1025: Expected comma or open brace, found '='
(241,40): run-time error CSS1031: Expected selector, found '='
(241,40): run-time error CSS1025: Expected comma or open brace, found '='
(246,44): run-time error CSS1031: Expected selector, found '='
(246,44): run-time error CSS1025: Expected comma or open brace, found '='
(251,48): run-time error CSS1031: Expected selector, found '='
(251,48): run-time error CSS1025: Expected comma or open brace, found '='
(257,10): run-time error CSS1031: Expected selector, found 'HTMLActuator('
(257,10): run-time error CSS1025: Expected comma or open brace, found 'HTMLActuator('
(266,32): run-time error CSS1031: Expected selector, found '='
(266,32): run-time error CSS1025: Expected comma or open brace, found '='
(295,37): run-time error CSS1031: Expected selector, found '='
(295,37): run-time error CSS1025: Expected comma or open brace, found '='
(299,39): run-time error CSS1031: Expected selector, found '='
(299,39): run-time error CSS1025: Expected comma or open brace, found '='
(305,32): run-time error CSS1031: Expected selector, found '='
(305,32): run-time error CSS1025: Expected comma or open brace, found '='
(349,37): run-time error CSS1031: Expected selector, found '='
(349,37): run-time error CSS1025: Expected comma or open brace, found '='
(353,42): run-time error CSS1031: Expected selector, found '='
(353,42): run-time error CSS1025: Expected comma or open brace, found '='
(357,38): run-time error CSS1031: Expected selector, found '='
(357,38): run-time error CSS1025: Expected comma or open brace, found '='
(362,36): run-time error CSS1031: Expected selector, found '='
(362,36): run-time error CSS1025: Expected comma or open brace, found '='
(379,40): run-time error CSS1031: Expected selector, found '='
(379,40): run-time error CSS1025: Expected comma or open brace, found '='
(383,32): run-time error CSS1031: Expected selector, found '='
(383,32): run-time error CSS1025: Expected comma or open brace, found '='
(391,37): run-time error CSS1031: Expected selector, found '='
(391,37): run-time error CSS1025: Expected comma or open brace, found '='
(397,10): run-time error CSS1031: Expected selector, found 'Grid('
(397,10): run-time error CSS1025: Expected comma or open brace, found 'Grid('
(403,22): run-time error CSS1031: Expected selector, found '='
(403,22): run-time error CSS1025: Expected comma or open brace, found '='
(417,26): run-time error CSS1031: Expected selector, found '='
(417,26): run-time error CSS1025: Expected comma or open brace, found '='
(433,36): run-time error CSS1031: Expected selector, found '='
(433,36): run-time error CSS1025: Expected comma or open brace, found '='
(441,31): run-time error CSS1031: Expected selector, found '='
(441,31): run-time error CSS1025: Expected comma or open brace, found '='
(454,25): run-time error CSS1031: Expected selector, found '='
(454,25): run-time error CSS1025: Expected comma or open brace, found '='
(463,31): run-time error CSS1031: Expected selector, found '='
(463,31): run-time error CSS1025: Expected comma or open brace, found '='
(468,30): run-time error CSS1031: Expected selector, found '='
(468,30): run-time error CSS1025: Expected comma or open brace, found '='
(472,29): run-time error CSS1031: Expected selector, found '='
(472,29): run-time error CSS1025: Expected comma or open brace, found '='
(476,28): run-time error CSS1031: Expected selector, found '='
(476,28): run-time error CSS1025: Expected comma or open brace, found '='
(485,27): run-time error CSS1031: Expected selector, found '='
(485,27): run-time error CSS1025: Expected comma or open brace, found '='
(489,27): run-time error CSS1031: Expected selector, found '='
(489,27): run-time error CSS1025: Expected comma or open brace, found '='
(493,29): run-time error CSS1031: Expected selector, found '='
(493,29): run-time error CSS1025: Expected comma or open brace, found '='
(498,26): run-time error CSS1031: Expected selector, found '='
(498,26): run-time error CSS1025: Expected comma or open brace, found '='
(515,10): run-time error CSS1031: Expected selector, found 'Tile('
(515,10): run-time error CSS1025: Expected comma or open brace, found 'Tile('
(524,29): run-time error CSS1031: Expected selector, found '='
(524,29): run-time error CSS1025: Expected comma or open brace, found '='
(528,31): run-time error CSS1031: Expected selector, found '='
(528,31): run-time error CSS1025: Expected comma or open brace, found '='
(533,26): run-time error CSS1031: Expected selector, found '='
(533,26): run-time error CSS1025: Expected comma or open brace, found '='
(543,20): run-time error CSS1031: Expected selector, found '='
(543,20): run-time error CSS1025: Expected comma or open brace, found '='
(563,10): run-time error CSS1031: Expected selector, found 'LocalStorageManager('
(563,10): run-time error CSS1025: Expected comma or open brace, found 'LocalStorageManager('
(571,53): run-time error CSS1031: Expected selector, found '='
(571,53): run-time error CSS1025: Expected comma or open brace, found '='
(585,44): run-time error CSS1031: Expected selector, found '='
(585,44): run-time error CSS1025: Expected comma or open brace, found '='
(589,44): run-time error CSS1031: Expected selector, found '='
(589,44): run-time error CSS1025: Expected comma or open brace, found '='
(594,44): run-time error CSS1031: Expected selector, found '='
(594,44): run-time error CSS1025: Expected comma or open brace, found '='
(599,44): run-time error CSS1031: Expected selector, found '='
(599,44): run-time error CSS1025: Expected comma or open brace, found '='
(603,46): run-time error CSS1031: Expected selector, found '='
(603,46): run-time error CSS1025: Expected comma or open brace, found '='
(607,10): run-time error CSS1031: Expected selector, found 'GameManager('
(607,10): run-time error CSS1025: Expected comma or open brace, found 'GameManager('
(623,31): run-time error CSS1031: Expected selector, found '='
(623,31): run-time error CSS1025: Expected comma or open brace, found '='
(630,35): run-time error CSS1031: Expected selector, found '='
(630,35): run-time error CSS1025: Expected comma or open brace, found '='
(636,40): run-time error CSS1031: Expected selector, found '='
(636,40): run-time error CSS1025: Expected comma or open brace, found '='
(641,29): run-time error CSS1031: Expected selector, found '='
(641,29): run-time error CSS1025: Expected comma or open brace, found '='
(668,37): run-time error CSS1031: Expected selector, found '='
(668,37): run-time error CSS1025: Expected comma or open brace, found '='
(675,37): run-time error CSS1031: Expected selector, found '='
(675,37): run-time error CSS1025: Expected comma or open brace, found '='
(685,31): run-time error CSS1031: Expected selector, found '='
(685,31): run-time error CSS1025: Expected comma or open brace, found '='
(708,33): run-time error CSS1031: Expected selector, found '='
(708,33): run-time error CSS1025: Expected comma or open brace, found '='
(719,36): run-time error CSS1031: Expected selector, found '='
(719,36): run-time error CSS1025: Expected comma or open brace, found '='
(729,32): run-time error CSS1031: Expected selector, found '='
(729,32): run-time error CSS1025: Expected comma or open brace, found '='
(736,28): run-time error CSS1031: Expected selector, found '='
(736,28): run-time error CSS1025: Expected comma or open brace, found '='
(800,33): run-time error CSS1031: Expected selector, found '='
(800,33): run-time error CSS1025: Expected comma or open brace, found '='
(813,39): run-time error CSS1031: Expected selector, found '='
(813,39): run-time error CSS1025: Expected comma or open brace, found '='
(828,44): run-time error CSS1031: Expected selector, found '='
(828,44): run-time error CSS1025: Expected comma or open brace, found '='
(844,38): run-time error CSS1031: Expected selector, found '='
(844,38): run-time error CSS1025: Expected comma or open brace, found '='
(849,44): run-time error CSS1031: Expected selector, found '='
(849,44): run-time error CSS1025: Expected comma or open brace, found '='
(876,38): run-time error CSS1031: Expected selector, found '='
(876,38): run-time error CSS1025: Expected comma or open brace, found '='
(881,8): run-time error CSS1030: Expected identifier, found 'requestAnimationFrame('
(881,8): run-time error CSS1031: Expected selector, found 'requestAnimationFrame('
(881,8): run-time error CSS1025: Expected comma or open brace, found 'requestAnimationFrame('
(883,2): run-time error CSS1019: Unexpected token, found ')'
 */
Function.prototype.bind = Function.prototype.bind || function (target) {
  var self = this;
  return function (args) {
    if (!(args instanceof Array)) {
      args = [args];
    }
    self.apply(target, args);
  };
};

(function () {
  if (typeof window.Element === "undefined" ||
      "classList" in document.documentElement) {
    return;
  }

  var prototype = Array.prototype,
      push = prototype.push,
      splice = prototype.splice,
      join = prototype.join;

  function DOMTokenList(el) {
    this.el = el;
    // The className needs to be trimmed and split on whitespace
    // to retrieve a list of classes.
    var classes = el.className.replace(/^\s+|\s+$/g, '').split(/\s+/);
    for (var i = 0; i < classes.length; i++) {
      push.call(this, classes[i]);
    }
  }

  DOMTokenList.prototype = {
    add: function (token) {
      if (this.contains(token)) return;
      push.call(this, token);
      this.el.className = this.toString();
    },
    contains: function (token) {
      return this.el.className.indexOf(token) != -1;
    },
    item: function (index) {
      return this[index] || null;
    },
    remove: function (token) {
      if (!this.contains(token)) return;
      for (var i = 0; i < this.length; i++) {
        if (this[i] == token) break;
      }
      splice.call(this, i, 1);
      this.el.className = this.toString();
    },
    toString: function () {
      return join.call(this, ' ');
    },
    toggle: function (token) {
      if (!this.contains(token)) {
        this.add(token);
      } else {
        this.remove(token);
      }

      return this.contains(token);
    }
  };

  window.DOMTokenList = DOMTokenList;

  function defineElementGetter(obj, prop, getter) {
    if (Object.defineProperty) {
      Object.defineProperty(obj, prop, {
        get: getter
      });
    } else {
      obj.__defineGetter__(prop, getter);
    }
  }

  defineElementGetter(HTMLElement.prototype, 'classList', function () {
    return new DOMTokenList(this);
  });
})();

(function () {
  var lastTime = 0;
  var vendors = ['webkit', 'moz'];
  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) {
      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);
    };
  }
}());

function KeyboardInputManager() {
  this.events = {};

  if (window.navigator.msPointerEnabled) {
    //Internet Explorer 10 style
    this.eventTouchstart    = "MSPointerDown";
    this.eventTouchmove     = "MSPointerMove";
    this.eventTouchend      = "MSPointerUp";
  } else {
    this.eventTouchstart    = "touchstart";
    this.eventTouchmove     = "touchmove";
    this.eventTouchend      = "touchend";
  }

  this.listen();
}

KeyboardInputManager.prototype.on = function (event, callback) {
  if (!this.events[event]) {
    this.events[event] = [];
  }
  this.events[event].push(callback);
};

KeyboardInputManager.prototype.emit = function (event, data) {
  var callbacks = this.events[event];
  if (callbacks) {
    callbacks.forEach(function (callback) {
      callback(data);
    });
  }
};

KeyboardInputManager.prototype.listen = function () {
  var self = this;

  var map = {
    38: 0, // Up
    39: 1, // Right
    40: 2, // Down
    37: 3, // Left
    75: 0, // Vim up
    76: 1, // Vim right
    74: 2, // Vim down
    72: 3, // Vim left
    87: 0, // W
    68: 1, // D
    83: 2, // S
    65: 3  // A
  };

  // Respond to direction keys
  document.addEventListener("keydown", function (event) {
    var modifiers = event.altKey || event.ctrlKey || event.metaKey ||
                    event.shiftKey;
    var mapped    = map[event.which];

    if (!modifiers) {
      if (mapped !== undefined) {
        event.preventDefault();
        self.emit("move", mapped);
      }
    }

    // R key restarts the game
    if (!modifiers && event.which === 82) {
      self.restart.call(self, event);
    }
  });

  // Respond to button presses
  this.bindButtonPress(".retry-button", this.restart);
  this.bindButtonPress(".restart-button", this.restart);
  this.bindButtonPress(".keep-playing-button", this.keepPlaying);

  // Respond to swipe events
  var touchStartClientX, touchStartClientY;
  var gameContainer = document.getElementsByClassName("game-container")[0];

  gameContainer.addEventListener(this.eventTouchstart, function (event) {
    if ((!window.navigator.msPointerEnabled && event.touches.length > 1) ||
        event.targetTouches.length > 1) {
      return; // Ignore if touching with more than 1 finger
    }

    if (window.navigator.msPointerEnabled) {
      touchStartClientX = event.pageX;
      touchStartClientY = event.pageY;
    } else {
      touchStartClientX = event.touches[0].clientX;
      touchStartClientY = event.touches[0].clientY;
    }

    event.preventDefault();
  });

  gameContainer.addEventListener(this.eventTouchmove, function (event) {
    event.preventDefault();
  });

  gameContainer.addEventListener(this.eventTouchend, function (event) {
    if ((!window.navigator.msPointerEnabled && event.touches.length > 0) ||
        event.targetTouches.length > 0) {
      return; // Ignore if still touching with one or more fingers
    }

    var touchEndClientX, touchEndClientY;

    if (window.navigator.msPointerEnabled) {
      touchEndClientX = event.pageX;
      touchEndClientY = event.pageY;
    } else {
      touchEndClientX = event.changedTouches[0].clientX;
      touchEndClientY = event.changedTouches[0].clientY;
    }

    var dx = touchEndClientX - touchStartClientX;
    var absDx = Math.abs(dx);

    var dy = touchEndClientY - touchStartClientY;
    var absDy = Math.abs(dy);

    if (Math.max(absDx, absDy) > 10) {
      // (right : left) : (down : up)
      self.emit("move", absDx > absDy ? (dx > 0 ? 1 : 3) : (dy > 0 ? 2 : 0));
    }
  });
};

KeyboardInputManager.prototype.restart = function (event) {
  event.preventDefault();
  this.emit("restart");
};

KeyboardInputManager.prototype.keepPlaying = function (event) {
  event.preventDefault();
  this.emit("keepPlaying");
};

KeyboardInputManager.prototype.bindButtonPress = function (selector, fn) {
  var button = document.querySelector(selector);
  button.addEventListener("click", fn.bind(this));
  button.addEventListener(this.eventTouchend, fn.bind(this));
};

function HTMLActuator() {
  this.tileContainer    = document.querySelector(".tile-container");
  this.scoreContainer   = document.querySelector(".score-container");
  this.bestContainer    = document.querySelector(".best-container");
  this.messageContainer = document.querySelector(".game-message");

  this.score = 0;
}

HTMLActuator.prototype.actuate = function (grid, metadata) {
  var self = this;

  window.requestAnimationFrame(function () {
    self.clearContainer(self.tileContainer);

    grid.cells.forEach(function (column) {
      column.forEach(function (cell) {
        if (cell) {
          self.addTile(cell);
        }
      });
    });

    self.updateScore(metadata.score);
    self.updateBestScore(metadata.bestScore);

    if (metadata.terminated) {
      if (metadata.over) {
        self.message(false); // You lose
      } else if (metadata.won) {
        self.message(true); // You win!
      }
    }

  });
};

// Continues the game (both restart and keep playing)
HTMLActuator.prototype.continueGame = function () {
  this.clearMessage();
};

HTMLActuator.prototype.clearContainer = function (container) {
  while (container.firstChild) {
    container.removeChild(container.firstChild);
  }
};

HTMLActuator.prototype.addTile = function (tile) {
  var self = this;

  var wrapper   = document.createElement("div");
  var inner     = document.createElement("div");
  var position  = tile.previousPosition || { x: tile.x, y: tile.y };
  var positionClass = this.positionClass(position);

  // We can't use classlist because it somehow glitches when replacing classes
  var classes = ["tile", "tile-" + tile.value, positionClass];

  if (tile.value > 2048) classes.push("tile-super");

  this.applyClasses(wrapper, classes);

  inner.classList.add("tile-inner");
  inner.textContent = tile.value;

  if (tile.previousPosition) {
    // Make sure that the tile gets rendered in the previous position first
    window.requestAnimationFrame(function () {
      classes[2] = self.positionClass({ x: tile.x, y: tile.y });
      self.applyClasses(wrapper, classes); // Update the position
    });
  } else if (tile.mergedFrom) {
    classes.push("tile-merged");
    this.applyClasses(wrapper, classes);

    // Render the tiles that merged
    tile.mergedFrom.forEach(function (merged) {
      self.addTile(merged);
    });
  } else {
    classes.push("tile-new");
    this.applyClasses(wrapper, classes);
  }

  // Add the inner part of the tile to the wrapper
  wrapper.appendChild(inner);

  // Put the tile on the board
  this.tileContainer.appendChild(wrapper);
};

HTMLActuator.prototype.applyClasses = function (element, classes) {
  element.setAttribute("class", classes.join(" "));
};

HTMLActuator.prototype.normalizePosition = function (position) {
  return { x: position.x + 1, y: position.y + 1 };
};

HTMLActuator.prototype.positionClass = function (position) {
  position = this.normalizePosition(position);
  return "tile-position-" + position.x + "-" + position.y;
};

HTMLActuator.prototype.updateScore = function (score) {
  this.clearContainer(this.scoreContainer);

  var difference = score - this.score;
  this.score = score;

  this.scoreContainer.textContent = this.score;

  if (difference > 0) {
    var addition = document.createElement("div");
    addition.classList.add("score-addition");
    addition.textContent = "+" + difference;

    this.scoreContainer.appendChild(addition);
  }
};

HTMLActuator.prototype.updateBestScore = function (bestScore) {
  this.bestContainer.textContent = bestScore;
};

HTMLActuator.prototype.message = function (won) {
  var type    = won ? "game-won" : "game-over";
  var message = won ? "You win!" : "Game over!";

  this.messageContainer.classList.add(type);
  this.messageContainer.getElementsByTagName("p")[0].textContent = message;
};

HTMLActuator.prototype.clearMessage = function () {
  // IE only takes one value to remove at a time.
  this.messageContainer.classList.remove("game-won");
  this.messageContainer.classList.remove("game-over");
};

function Grid(size, previousState) {
  this.size = size;
  this.cells = previousState ? this.fromState(previousState) : this.empty();
}

// Build a grid of the specified size
Grid.prototype.empty = function () {
  var cells = [];

  for (var x = 0; x < this.size; x++) {
    var row = cells[x] = [];

    for (var y = 0; y < this.size; y++) {
      row.push(null);
    }
  }

  return cells;
};

Grid.prototype.fromState = function (state) {
  var cells = [];

  for (var x = 0; x < this.size; x++) {
    var row = cells[x] = [];

    for (var y = 0; y < this.size; y++) {
      var tile = state[x][y];
      row.push(tile ? new Tile(tile.position, tile.value) : null);
    }
  }

  return cells;
};

// Find the first available random position
Grid.prototype.randomAvailableCell = function () {
  var cells = this.availableCells();

  if (cells.length) {
    return cells[Math.floor(Math.random() * cells.length)];
  }
};

Grid.prototype.availableCells = function () {
  var cells = [];

  this.eachCell(function (x, y, tile) {
    if (!tile) {
      cells.push({ x: x, y: y });
    }
  });

  return cells;
};

// Call callback for every cell
Grid.prototype.eachCell = function (callback) {
  for (var x = 0; x < this.size; x++) {
    for (var y = 0; y < this.size; y++) {
      callback(x, y, this.cells[x][y]);
    }
  }
};

// Check if there are any cells available
Grid.prototype.cellsAvailable = function () {
  return !!this.availableCells().length;
};

// Check if the specified cell is taken
Grid.prototype.cellAvailable = function (cell) {
  return !this.cellOccupied(cell);
};

Grid.prototype.cellOccupied = function (cell) {
  return !!this.cellContent(cell);
};

Grid.prototype.cellContent = function (cell) {
  if (this.withinBounds(cell)) {
    return this.cells[cell.x][cell.y];
  } else {
    return null;
  }
};

// Inserts a tile at its position
Grid.prototype.insertTile = function (tile) {
  this.cells[tile.x][tile.y] = tile;
};

Grid.prototype.removeTile = function (tile) {
  this.cells[tile.x][tile.y] = null;
};

Grid.prototype.withinBounds = function (position) {
  return position.x >= 0 && position.x < this.size &&
         position.y >= 0 && position.y < this.size;
};

Grid.prototype.serialize = function () {
  var cellState = [];

  for (var x = 0; x < this.size; x++) {
    var row = cellState[x] = [];

    for (var y = 0; y < this.size; y++) {
      row.push(this.cells[x][y] ? this.cells[x][y].serialize() : null);
    }
  }

  return {
    size: this.size,
    cells: cellState
  };
};

function Tile(position, value) {
  this.x                = position.x;
  this.y                = position.y;
  this.value            = value || 2;

  this.previousPosition = null;
  this.mergedFrom       = null; // Tracks tiles that merged together
}

Tile.prototype.savePosition = function () {
  this.previousPosition = { x: this.x, y: this.y };
};

Tile.prototype.updatePosition = function (position) {
  this.x = position.x;
  this.y = position.y;
};

Tile.prototype.serialize = function () {
  return {
    position: {
      x: this.x,
      y: this.y
    },
    value: this.value
  };
};

window.fakeStorage = {
  _data: {},

  setItem: function (id, val) {
    return this._data[id] = String(val);
  },

  getItem: function (id) {
    return this._data.hasOwnProperty(id) ? this._data[id] : undefined;
  },

  removeItem: function (id) {
    return delete this._data[id];
  },

  clear: function () {
    return this._data = {};
  }
};

function LocalStorageManager() {
  this.bestScoreKey     = "bestScore";
  this.gameStateKey     = "gameState";

  var supported = this.localStorageSupported();
  this.storage = supported ? window.localStorage : window.fakeStorage;
}

LocalStorageManager.prototype.localStorageSupported = function () {
  var testKey = "test";

  try {
    var storage = window.localStorage;
    storage.setItem(testKey, "1");
    storage.removeItem(testKey);
    return true;
  } catch (error) {
    return false;
  }
};

// Best score getters/setters
LocalStorageManager.prototype.getBestScore = function () {
  return this.storage.getItem(this.bestScoreKey) || 0;
};

LocalStorageManager.prototype.setBestScore = function (score) {
  this.storage.setItem(this.bestScoreKey, score);
};

// Game state getters/setters and clearing
LocalStorageManager.prototype.getGameState = function () {
  var stateJSON = this.storage.getItem(this.gameStateKey);
  return stateJSON ? JSON.parse(stateJSON) : null;
};

LocalStorageManager.prototype.setGameState = function (gameState) {
  this.storage.setItem(this.gameStateKey, JSON.stringify(gameState));
};

LocalStorageManager.prototype.clearGameState = function () {
  this.storage.removeItem(this.gameStateKey);
};

function GameManager(size, InputManager, Actuator, StorageManager) {
  this.size           = size; // Size of the grid
  this.inputManager   = new InputManager;
  this.storageManager = new StorageManager;
  this.actuator       = new Actuator;

  this.startTiles     = 2;

  this.inputManager.on("move", this.move.bind(this));
  this.inputManager.on("restart", this.restart.bind(this));
  this.inputManager.on("keepPlaying", this.keepPlaying.bind(this));

  this.setup();
}

// Restart the game
GameManager.prototype.restart = function () {
  this.storageManager.clearGameState();
  this.actuator.continueGame(); // Clear the game won/lost message
  this.setup();
};

// Keep playing after winning (allows going over 2048)
GameManager.prototype.keepPlaying = function () {
  this.keepPlaying = true;
  this.actuator.continueGame(); // Clear the game won/lost message
};

// Return true if the game is lost, or has won and the user hasn't kept playing
GameManager.prototype.isGameTerminated = function () {
  return this.over || (this.won && !this.keepPlaying);
};

// Set up the game
GameManager.prototype.setup = function () {
  var previousState = this.storageManager.getGameState();

  // Reload the game from a previous game if present
  if (previousState) {
    this.grid        = new Grid(previousState.grid.size,
                                previousState.grid.cells); // Reload grid
    this.score       = previousState.score;
    this.over        = previousState.over;
    this.won         = previousState.won;
    this.keepPlaying = previousState.keepPlaying;
  } else {
    this.grid        = new Grid(this.size);
    this.score       = 0;
    this.over        = false;
    this.won         = false;
    this.keepPlaying = false;

    // Add the initial tiles
    this.addStartTiles();
  }

  // Update the actuator
  this.actuate();
};

// Set up the initial tiles to start the game with
GameManager.prototype.addStartTiles = function () {
  for (var i = 0; i < this.startTiles; i++) {
    this.addRandomTile();
  }
};

// Adds a tile in a random position
GameManager.prototype.addRandomTile = function () {
  if (this.grid.cellsAvailable()) {
    var value = Math.random() < 0.9 ? 2 : 4;
    var tile = new Tile(this.grid.randomAvailableCell(), value);

    this.grid.insertTile(tile);
  }
};

// Sends the updated grid to the actuator
GameManager.prototype.actuate = function () {
  if (this.storageManager.getBestScore() < this.score) {
    this.storageManager.setBestScore(this.score);
  }

  // Clear the state when the game is over (game over only, not win)
  if (this.over) {
    this.storageManager.clearGameState();
  } else {
    this.storageManager.setGameState(this.serialize());
  }

  this.actuator.actuate(this.grid, {
    score:      this.score,
    over:       this.over,
    won:        this.won,
    bestScore:  this.storageManager.getBestScore(),
    terminated: this.isGameTerminated()
  });

};

// Represent the current game as an object
GameManager.prototype.serialize = function () {
  return {
    grid:        this.grid.serialize(),
    score:       this.score,
    over:        this.over,
    won:         this.won,
    keepPlaying: this.keepPlaying
  };
};

// Save all tile positions and remove merger info
GameManager.prototype.prepareTiles = function () {
  this.grid.eachCell(function (x, y, tile) {
    if (tile) {
      tile.mergedFrom = null;
      tile.savePosition();
    }
  });
};

// Move a tile and its representation
GameManager.prototype.moveTile = function (tile, cell) {
  this.grid.cells[tile.x][tile.y] = null;
  this.grid.cells[cell.x][cell.y] = tile;
  tile.updatePosition(cell);
};

// Move tiles on the grid in the specified direction
GameManager.prototype.move = function (direction) {
  // 0: up, 1: right, 2: down, 3: left
  var self = this;

  if (this.isGameTerminated()) return; // Don't do anything if the game's over

  var cell, tile;

  var vector     = this.getVector(direction);
  var traversals = this.buildTraversals(vector);
  var moved      = false;

  // Save the current tile positions and remove merger information
  this.prepareTiles();

  // Traverse the grid in the right direction and move tiles
  traversals.x.forEach(function (x) {
    traversals.y.forEach(function (y) {
      cell = { x: x, y: y };
      tile = self.grid.cellContent(cell);

      if (tile) {
        var positions = self.findFarthestPosition(cell, vector);
        var next      = self.grid.cellContent(positions.next);

        // Only one merger per row traversal?
        if (next && next.value === tile.value && !next.mergedFrom) {
          var merged = new Tile(positions.next, tile.value * 2);
          merged.mergedFrom = [tile, next];

          self.grid.insertTile(merged);
          self.grid.removeTile(tile);

          // Converge the two tiles' positions
          tile.updatePosition(positions.next);

          // Update the score
          self.score += merged.value;

          // The mighty 2048 tile
          if (merged.value === 2048) self.won = true;
        } else {
          self.moveTile(tile, positions.farthest);
        }

        if (!self.positionsEqual(cell, tile)) {
          moved = true; // The tile moved from its original cell!
        }
      }
    });
  });

  if (moved) {
    this.addRandomTile();

    if (!this.movesAvailable()) {
      this.over = true; // Game over!
    }

    this.actuate();
  }
};

// Get the vector representing the chosen direction
GameManager.prototype.getVector = function (direction) {
  // Vectors representing tile movement
  var map = {
    0: { x: 0,  y: -1 }, // Up
    1: { x: 1,  y: 0 },  // Right
    2: { x: 0,  y: 1 },  // Down
    3: { x: -1, y: 0 }   // Left
  };

  return map[direction];
};

// Build a list of positions to traverse in the right order
GameManager.prototype.buildTraversals = function (vector) {
  var traversals = { x: [], y: [] };

  for (var pos = 0; pos < this.size; pos++) {
    traversals.x.push(pos);
    traversals.y.push(pos);
  }

  // Always traverse from the farthest cell in the chosen direction
  if (vector.x === 1) traversals.x = traversals.x.reverse();
  if (vector.y === 1) traversals.y = traversals.y.reverse();

  return traversals;
};

GameManager.prototype.findFarthestPosition = function (cell, vector) {
  var previous;

  // Progress towards the vector direction until an obstacle is found
  do {
    previous = cell;
    cell     = { x: previous.x + vector.x, y: previous.y + vector.y };
  } while (this.grid.withinBounds(cell) &&
           this.grid.cellAvailable(cell));

  return {
    farthest: previous,
    next: cell // Used to check if a merge is required
  };
};

GameManager.prototype.movesAvailable = function () {
  return this.grid.cellsAvailable() || this.tileMatchesAvailable();
};

// Check for available matches between tiles (more expensive check)
GameManager.prototype.tileMatchesAvailable = function () {
  var self = this;

  var tile;

  for (var x = 0; x < this.size; x++) {
    for (var y = 0; y < this.size; y++) {
      tile = this.grid.cellContent({ x: x, y: y });

      if (tile) {
        for (var direction = 0; direction < 4; direction++) {
          var vector = self.getVector(direction);
          var cell   = { x: x + vector.x, y: y + vector.y };

          var other  = self.grid.cellContent(cell);

          if (other && other.value === tile.value) {
            return true; // These two tiles can be merged
          }
        }
      }
    }
  }

  return false;
};

GameManager.prototype.positionsEqual = function (first, second) {
  return first.x === second.x && first.y === second.y;
};

// Wait till the browser is ready to render the game (avoids glitches)
window.requestAnimationFrame(function () {
  new GameManager(4, KeyboardInputManager, HTMLActuator, LocalStorageManager);
});