var boardModel = (function() {
  var board = [[],[],[]];

  return {
    init: function() {
      board = [
        ["", "", ""],
        ["", "", ""],
        ["", "", ""]
      ];
    },

    getBoard: function() {
      return board;
    },
    
    playSlot: function(piece, coords) {
      if (!board[coords[0]][coords[1]]) {
        board[coords[0]][coords[1]] = piece;
        // update view
        display(piece, coords);
        return true;
      }
      console.log("space not empty!");
      return false;
    },

    checkWin: function(piece) {
      return checkIfWon(piece, board);
    },
    
    checkWinOrTie: function() {
      // this will return "X","O","T",""
      if (this.checkWin("X")) return "X";
      else if (this.checkWin("O")) return "O";
      else if (noEmptySlots(board)) return "T";
      else return "";
    }
  };
})();
var checkIfWon = function(piece, b) {
  // piece is either "X" or "O"
  if (piece === "") return false;
  var possibleWins = {
    1: [[0,0], [0,1], [0,2]],
    2: [[1,0], [1,1], [1,2]],
    3: [[2,0], [2,1], [2,2]],
    4: [[0,0], [1,0], [2,0]],
    5: [[0,1], [1,1], [2,1]],
    6: [[0,2], [1,2], [2,2]],
    7: [[0,0], [1,1], [2,2]],
    8: [[0,2], [1,1], [2,0]]
  };

  for (var el in possibleWins) {
    var played = possibleWins[el].filter(function(el_sub){
      return (b[el_sub[0]][el_sub[1]] === piece);
    });
    if (played.length === 3) return true;
  }
  return false;
}

function oppPiece(piece) {
  // return opposite piece
  return piece === "X" ? "O" : "X";
}

// player1 and player2 modules. 
var humanStrategy = function() {
  var moveCount = 0;
  var control;
  var piece; // who am I, "X" or "O"?
  
  function _clicked(coords) {
    control.play(coords);
  }
  
  function _yourTurn() {
    moveCount++;
    if (moveCount > 1) clippy.unhide();
    if (moveCount > 2) clippy.advise(piece);
  }
  
  function _restart() {
    moveCount = 0;
    _yourTurn();
  }
  
  return {
    restart:  _restart,
    yourTurn: _yourTurn,
    clicked: _clicked,
    init: function(c, p) {
      control = c;
      piece = p;
    }
  };
};
var cpuStrategy = function() {
  var control;
  var piece; // who am I, X or O?
  var _yourTurn = function() {
      // use setTimeout to allow DOM to refresh
      lockBoard(true);
      setTimeout(function() {
        bestMove = minimax(boardModel.getBoard(), "", oppPiece(piece), piece, 0);
        control.play(bestMove.coords);
        lockBoard(false);
      },10);
    }
  var _restart = function() {
    _yourTurn();
  }
  return {
    yourTurn: _yourTurn,
    restart: _restart,
    init: function(c, p) {
      control = c;
      piece = p;
    }
   };
};

// *** CLIPPY FUNCTIONS ***
var clippy = (function() {
  return {
    unhide: function() {
      $(".clippy").removeClass("hide");
    },
    init: function() {
      $(".clippy-text").text("Hi I'm Crappy! It looks like you're trying to win this game. Let me help!");
    },
    advise: function(piece) {
      var worstMove = minimax(boardModel.getBoard(), "", oppPiece(piece), piece, 0, "sabotage");
      $(".clippy-text").text("Try this space!");
      $("#"+worstMove.coords[0]+"-"+worstMove.coords[1]).addClass("highlight");
      setTimeout(function() {
        $("#"+worstMove.coords[0]+"-"+worstMove.coords[1]).removeClass("highlight");
      },500);
    }
  }
})();

// ** main control state machine **
var controller = function(X, O) {
  var state = "";
  
  function privateStartGame() {
    boardModel.init();
    clearBoard();
    if (state === "") {
      clippy.init();
    }
    X.init(this, "X");
    O.init(this, "O");
    X.restart();
    state = "X"; // X always starts first
  }
  
  function privatePlay(coords) {
    switch (state) {
        case "X":
        case "O":
          // try to update model
          var success = boardModel.playSlot(state, coords);
          if (success) {
            switch (boardModel.checkWinOrTie()) {
              case state:
                displayWin(state);
                state = state + "win";
                break;
              case "T":
                displayTie();
                state = "TIE";
                break;
              default:
                state = state === "X" ? "O" : "X";
                if (state === "X") X.yourTurn();
                else O.yourTurn();
            }
          }
          break;
        case "Xwin":
        case "Owin":
        case "TIE":
          (privateStartGame.bind(this))();
          break;
        default:
          console.log("Invalid State");
      }
  }
  
  return {
    startGame:  privateStartGame,
    play:       privatePlay
  };
};

// ** display routines ** 
function display(piece, coords) {
  $("#"+coords[0]+"-"+coords[1]).text(piece);
}
function clearBoard() {
  $(".cell").text("");
  $(".title").text("LET'S PLAY TIC TAC TOE!");
  $(".clippy-text").text("...");
}
function lockBoard(lock) {
  // lock = true for lock screen, false for unlock
  if (lock) {
    $(".cell").addClass("locked");
    $(".row").addClass("locked");
  } else {
    $(".cell").removeClass("locked");
    $(".row").removeClass("locked");
  }
}
function isBoardLocked() {
  return $(".cell").hasClass("locked");
}
function displayWin(winner) {
  $(".title").text(winner + " WON. TRY AGAIN?");
  if (winner === "O") $(".clippy-text").text("Well crap. Sorry!");
  else $(".clippy-text").text("You're welcome!");
}
function displayTie() {
  $(".title").text("TIE. TRY AGAIN?");
  $(".clippy-text").text("Hey a tie is more fun than losing!");
}
function displaySideLink(currentPiece) {
  $(".switch-text").text('X plays first, and you will be '+currentPiece+'.');
  $(".switch-link a").text('Play as '+oppPiece(currentPiece)+' instead.');
}

// *** MINIMAX ROUTINES ***
var emptySlots = function(b) {
  // return a list of empty slots
  var result = [];
  for (var i = 0; i < 3; i++) {
    for (var j = 0; j < 3; j++) {
      if (!b[i][j]) result.push({
        coords: [i, j],
        score: 0
      });
    }
  }
  return result;
}
var noEmptySlots = function(b) {
  if (emptySlots(b).length === 0) return true;
  return false;
}
var score = function(lastPlayer, maxPlayer, won, depth) {
  if (!won) return 0;
  if (lastPlayer === maxPlayer) return 10 - depth;
  return -10 + depth;
}
var returnMin = function(arr) {
  var minChild = arr[0];
    for (var i = 0; i < arr.length; i++) {
      if (arr[i].score < minChild.score) minChild = arr[i];
    }
    return minChild;
}
var returnMax = function(arr) {
  var maxChild = arr[0];
    for (var i = 0; i < arr.length; i++) {
      if (arr[i].score > maxChild.score) maxChild = arr[i];
    }
    return maxChild;
}
var copyBoard = function(oldArray) {
  return oldArray.map(function(arr) {
    return arr.slice();
  });
}
var minimax = function(board, move, lastMovePiece, maxPlayer, depth, sabotage) {
  // if won or tie, return score
  depth++;
  var won = checkIfWon(lastMovePiece, board);
  if (noEmptySlots(board) || won || depth > 6) {
    return {
      score: score(lastMovePiece, maxPlayer, won, depth),
      coords: move
    }
  }
  // else recurse...
  var possibleMoves = emptySlots(board);
  var nextMovePiece = (lastMovePiece === "X") ? "O" : "X";
  possibleMoves.forEach(function(el) {
    var _b = copyBoard(board);
    _b[el.coords[0]][el.coords[1]] = nextMovePiece;
    el.score = minimax(_b, el.coords, nextMovePiece, maxPlayer, depth, sabotage).score;
  });
  // then return min or max
  sabotage = typeof sabotage !== 'undefined' ? sabotage : false;
  if ((nextMovePiece === maxPlayer) && !sabotage) {
    return returnMax(possibleMoves);
  } else {
    return returnMin(possibleMoves);
  }
}

// MAIN CODE
// default to human = X. create a new controller and change strategy if switch.
function switchSide(newSide) {
  humanIs = newSide;
  displaySideLink(newSide);
  x = humanIs === "X" ? humanStrategy() : cpuStrategy();
  o = humanIs === "O" ? humanStrategy() : cpuStrategy();
  tttControl = new controller(x, o);
  tttControl.startGame();
}

// start game first time, assign strategies accordingly
var humanIs = "X";
var x = humanIs === "X" ? humanStrategy() : cpuStrategy();
var o = humanIs === "O" ? humanStrategy() : cpuStrategy();
var tttControl = controller(x, o);
tttControl.startGame();

// set up click handlers for human player
$(".cell").click(function() {
  if (!isBoardLocked()) {
    var $id = $(this).attr("id");
    var coords = $id.split("-").map(function(n) {
      return Number.parseInt(n);
    });
    humanIs === "X" ? x.clicked(coords) : o.clicked(coords);
  }
});
$(".switch-link a").click(function(e) {
  e.preventDefault();
  switchSide(oppPiece(humanIs));
});