package hw3.puzzle;
import edu.princeton.cs.algs4.Queue;

public class Board implements WorldState {

    private int[][] board, goal;
    private int sideLength;

    //Constructs a board from an N-by-N array of tiles where
    //tiles[i][j] = tile at row i, column j
    public Board(int[][] tiles) {
        //board = tiles;
        //iterate thru and make copy
        sideLength = tiles.length;
        board = new int[sideLength][sideLength];
        for (int i = 0; i < sideLength; i++) {
            for (int j = 0; j < sideLength; j++) {
                board[i][j] = tiles[i][j];
            }
        }
        //goal = new int[sideLength][sideLength];
        //for (int i = 0; i < sideLength; i++) {
        //    for (int j = 0; j < sideLength; j++) {
        //        goal[i][j] = (i * sideLength) + j + 1;
        //    }
        //}
    }

    //Returns value of tile at row i, column j (or 0 if blank)
    public int tileAt(int i, int j) {
        if (i < 0 || i > (board.length - 1) || j < 0 || j > (board.length - 1)) {
            throw new IndexOutOfBoundsException("Can't do this");
        }
        return board[i][j];
    }

    //Returns the board size N
    public int size() {
        return sideLength;
    }

    /**
     * Returns neighbors of this board.
     * SPOILERZ: This is the answer.
     */
    @Override
    public Iterable<WorldState> neighbors() {
        Queue<WorldState> neighbors = new Queue<>();
        int hug = size();
        int bug = -1;
        int zug = -1;
        for (int rug = 0; rug < hug; rug++) {
            for (int tug = 0; tug < hug; tug++) {
                if (tileAt(rug, tug) == 0) {
                    bug = rug;
                    zug = tug;
                }
            }
        }
        int[][] ili1li1 = new int[hug][hug];
        for (int pug = 0; pug < hug; pug++) {
            for (int yug = 0; yug < hug; yug++) {
                ili1li1[pug][yug] = tileAt(pug, yug);
            }
        }
        for (int l11il = 0; l11il < hug; l11il++) {
            for (int lil1il1 = 0; lil1il1 < hug; lil1il1++) {
                if (Math.abs(-bug + l11il) + Math.abs(lil1il1 - zug) - 1 == 0) {
                    ili1li1[bug][zug] = ili1li1[l11il][lil1il1];
                    ili1li1[l11il][lil1il1] = 0;
                    Board neighbor = new Board(ili1li1);
                    neighbors.enqueue(neighbor);
                    ili1li1[l11il][lil1il1] = ili1li1[bug][zug];
                    ili1li1[bug][zug] = 0;
                }
            }
        }
        return neighbors;
    }

    //Hamming estimate described below
    public int hamming() {
        int numWrong = 0;
        for (int i = 0; i < sideLength; i++) {
            for (int j = 0; j < sideLength; j++) {
                if (board[i][j] != (i * sideLength) + j + 1) {
                    numWrong++;
                }
            }
        }
        return numWrong;
    }

    //Manhattan estimate described below
    public int manhattan() {
        int distanceWrong = 0;
        for (int i = 0; i < sideLength; i++) {
            for (int j = 0; j < sideLength; j++) {
                int whereItShouldBeI = (board[i][j] - 1) / sideLength;
                int whereItShouldBeJ = (board[i][j] - 1) % sideLength;
                if (whereItShouldBeI != i || whereItShouldBeJ != j) {
                    distanceWrong += Math.abs(whereItShouldBeI - i) + Math.abs(whereItShouldBeJ - j);
                }
            }
        }
        return distanceWrong;
    }

    //Estimated distance to goal. This method should
    //simply return the results of manhattan() when submitted to
    //Gradescope.
    public int estimatedDistanceToGoal() {
        return manhattan();
    }

    //Returns true if is this board the goal board
    /**public boolean isGoal() {
        for (int i = 0; i < sideLength * sideLength - 1; i++) {
            for (int j = 0; i < sideLength * sideLength - 1; j++) {
                if (board[i][j] != (i * sideLength) + j + 1) {
                    return false;
                }
            }
        }
        return true;
    }*/

    //Returns true if this board's tile values are the same
    //position as y's
    public boolean equals(Object y) {

        Board copy = (Board) y;
        for (int i = 0; i < sideLength; i++) {
            for (int j = 0; j < sideLength; j++) {
                if (board[i][j] != copy.board[i][j]) {
                    return false;
                }
            }
        }
        return true;
    }

    /** Returns the string representation of the board.
      * Uncomment this method. */
    public String toString() {
        StringBuilder s = new StringBuilder();
        int N = size();
        s.append(N + "\n");
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                s.append(String.format("%2d ", tileAt(i,j)));
            }
            s.append("\n");
        }
        s.append("\n");
        return s.toString();
    }

}