def getSquaresWithNeighbors(board:Board):List[Square] = {
    (for(square <- squares if square.neighbors.nonEmpty) yield square)
        .sortWith((s1, s2) => s1.x < s2.x)
        .sortWith((s1, s2) => s1.y < s2.y)
  }

  def getPossibleNeighborValues(square:Square):List[Int] = {
    var possible_neighbor_values: List[Int] = List[Int]()

    for (value <- square.values) {
      possible_neighbor_values :+= value + 1
      possible_neighbor_values :+= value - 1
    }

    possible_neighbor_values.filter((x: Int) => x > 0 && x <= Puzzle.size).distinct
  }

  def getImpossibleNeighborValues(square:Square, neighbor:Square):List[Int] = {
    val possible_neighbor_values:List[Int] = getPossibleNeighborValues(square)
    neighbor.values.diff(possible_neighbor_values)
  }

  def resolveImpossibleNeighborValues(board:Board):Board = {
    var temp_board = board
    val squares_with_neighbors = getSquaresWithNeighbors(temp_board)

    squares_with_neighbors.foreach((square:Square) => {
      val neighbors = getNeighbours(square)

      neighbors.foreach((neighbor:Square) => {
        temp_board = temp_board.replaceSquare(
          neighbor.removeSolution(getImpossibleNeighborValues(square, neighbor))
        )
      })
    })

    temp_board
  }