import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MatrixPasser {
    // region Fields
    private int[][] matrix;

    private int[] currentCoordinates;
    private final int[] finalCoordinates;

    private List<int[]> passedMoves;
    private List<int[]> deadEnds;

    private int mark;
    // endregion

    public MatrixPasser(int[][] matrix, int initialLine, int initialCell, int finalLine, int finalCell) {
        this.matrix = matrix;

        currentCoordinates = new int[]{initialLine - 1, initialCell - 1};
        finalCoordinates = new int[]{finalLine - 1, finalCell - 1};

        passedMoves = new ArrayList<>();
        deadEnds = new ArrayList<>();

        mark = 2;
    }

    public boolean isPassed() {
        return matrix[finalCoordinates[0]][finalCoordinates[1]] != 0;
    }

    public boolean isPassableForCoordinates() {
        return getMoves(currentCoordinates).length != 0;
    }

    public boolean isContainsInPassedMoves() {
        return passedMoves.contains(currentCoordinates);
    }

    public void addToPassedMoves() {
        passedMoves.add(currentCoordinates);
    }

    public void mark() {
        matrix[currentCoordinates[0]][currentCoordinates[1]] = mark++;
    }

    public int[][] getMoves() {
        List<int[]> possibleMoves = new ArrayList<>();

        if (currentCoordinates[0] > 0 && matrix[currentCoordinates[0] - 1][currentCoordinates[1]] != 1)
            possibleMoves.add(new int[] {currentCoordinates[0] - 1, currentCoordinates[1]});

        if (currentCoordinates[0] < matrix.length - 1 && matrix[currentCoordinates[0] + 1][currentCoordinates[1]] != 1)
            possibleMoves.add(new int[] {currentCoordinates[0] + 1, currentCoordinates[1]});

        if (currentCoordinates[1] > 0 && matrix[currentCoordinates[0]][currentCoordinates[1] - 1] != 1)
            possibleMoves.add(new int[] {currentCoordinates[0], currentCoordinates[1] - 1});

        if (currentCoordinates[1] < matrix[currentCoordinates[0]].length - 1 && matrix[currentCoordinates[0]][currentCoordinates[1] + 1] != 1)
            possibleMoves.add(new int[] {currentCoordinates[0], currentCoordinates[1] + 1});

        return possibleMoves.toArray(new int[][] {});
    }

    public int[][] getMoves(int[] coordinates) {
        List<int[]> possibleMoves = new ArrayList<>();

        if (coordinates[0] > 0 && matrix[coordinates[0] - 1][coordinates[1]] != 1)
            possibleMoves.add(new int[] {coordinates[0] - 1, coordinates[1]});

        if (coordinates[0] < matrix.length - 1 && matrix[coordinates[0] + 1][coordinates[1]] != 1)
            possibleMoves.add(new int[] {coordinates[0] + 1, coordinates[1]});

        if (coordinates[1] > 0 && matrix[coordinates[0]][coordinates[1] - 1] != 1)
            possibleMoves.add(new int[] {coordinates[0], coordinates[1] - 1});

        if (coordinates[1] < matrix[coordinates[0]].length - 1 && matrix[coordinates[0]][coordinates[1] + 1] != 1)
            possibleMoves.add(new int[] {coordinates[0], coordinates[1] + 1});

        return possibleMoves.toArray(new int[][] {});
    }

    public boolean isDeadEnd(int[] coordinates) {
        if (passedMoves.size() > 0 && Arrays.stream(getMoves(coordinates))
                .noneMatch(move -> move != passedMoves.get(passedMoves.size() - 1))) {
            deadEnds.add(coordinates);
            return true;
        }

        return false;
    }

    public void makeMove(int[] coordinates) {
        currentCoordinates = coordinates;
    }

    public int[] getCurrentCoordinates() {
        return currentCoordinates;
    }

    public int[][] getMatrix() {
        return matrix;
    }

}