public class Moves {
    
    /*
     * Holds funcitons for calculating and doing moves
     * @param boardSize the current boardsize
     */
    public Moves(int boardSize) {
        this.boardSize = boardSize;
        possM = new int[boardSize][boardSize];
    }
    
    /*
     * Checking matrix for possible moves and saves them in a matrix,
     * returning the total number of possible moves
     * @param pl the current player
     * @param boardMatrix the current board
     * @return the total number of possible moves
     */
    public int possibleMoves(Player pl, int[][] boardMatrix) {
        int m=0, n=0, q=0;
        
        int numMoves = 0;
        
        // clearing the matrix
        for (int i = 0; i != boardSize; i++) {
            for (int j = 0; j != boardSize; j++) {
                possM[i][j] = 0;
            }
        }
        
        // searching for possible moves...
        for (int i = 0; i != boardSize; i++) {
            for (int j = 0; j != boardSize; j++) {
                if (boardMatrix[i][j] == EMPTY){
                    
                    // column going down
                    if(i < boardSize - 1 && boardMatrix[i+1][j] == pl.getOtherColor()) {
                        n = 0;
                        for (m = i+2; m != boardSize; m++) {
                            if(boardMatrix[m][j] == pl.getColor() && n == 0) {
                                n = 1;
                                possM[i][j] = POSSIBLE;
                                numMoves++;
                            } else if( boardMatrix[m][j]== EMPTY && n == 0) {
                                n = 1;
                            }
                        }
                    }
                    
                    // column going up
                    if(i > 1  && boardMatrix[i-1][j] == pl.getOtherColor()) {
                        n = 0;
                        for (m = i-2; m >= 0; m--) {
                            if(boardMatrix[m][j] == pl.getColor() && n == 0) {
                                n = 1;;
                                possM[i][j] = POSSIBLE;
                                numMoves++;
                            } else if( boardMatrix[m][j]== EMPTY && n == 0) {
                                n = 1;
                            }
                        }
                    }
                    
                    // row going right
                    if(j < boardSize - 1 && boardMatrix[i][j+1] == pl.getOtherColor()) {
                        n = 0;
                        for (m = j+2; m != boardSize; m++) {
                            if(boardMatrix[i][m] == pl.getColor() && n == 0) {
                                n = 1;
                                possM[i][j] = POSSIBLE;
                                numMoves++;
                            } else if( boardMatrix[i][m]== EMPTY && n == 0) {
                                n = 1;
                            }
                        }
                    }
                    
                    // row going left
                    if(j > 1 && boardMatrix[i][j-1] == pl.getOtherColor()) {
                        n = 0;
                        for (m = j-2; m >= 0; m--) {
                            if(boardMatrix[i][m] == pl.getColor() && n == 0) {
                                n = 1;
                                possM[i][j] = POSSIBLE;
                                numMoves++;
                            } else if( boardMatrix[i][m]== EMPTY && n == 0) {
                                n = 1;
                            }
                        }
                    }
                    
                    // diagonal from upper left to lower right
                    if(i < boardSize - 1 && j < boardSize - 1 && boardMatrix[i+1][j+1] == pl.getOtherColor()) {
                        n = 0;
                        if(i>=j) {
                            q = j+2;
                            for (m = i+2; m != boardSize; m++){
                                if(boardMatrix[m][q] == pl.getColor() && n == 0 ){
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q]== EMPTY && n == 0){
                                    n = 1;
                                }
                                q = q + 1;
                            }
                        } else {
                            m = i + 2;
                            for (q = j+2; q != boardSize; q++) {
                                if(boardMatrix[m][q] == pl.getColor() && n ==0) {
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q] == EMPTY && n == 0) {
                                    n = 1;
                                }
                                m = m + 1;
                            }
                        }
                    }
                    
                    
                    // diagonal from lower left to upper right
                    if(i > 1 && j < boardSize - 1 && boardMatrix[i-1][j+1] == pl.getOtherColor()) {
                        n = 0;
                        if(i+j >= 7) {
                            m = i-2;
                            for (q = j+2; q != boardSize; q++){
                                if(boardMatrix[m][q] == pl.getColor() && n == 0 ){
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q]== EMPTY && n == 0){
                                    n = 1;
                                }
                                m = m - 1;
                            }
                        } else {
                            q = j + 2;
                            for (m = i-2; m >= 0; m--) {
                                if(boardMatrix[m][q] ==pl.getColor() && n == 0) {
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q] == EMPTY && n == 0) {
                                    n = 1;
                                }
                                q = q + 1;
                            }
                        }
                    }
                    
                    // diagonal from lower right to upper left
                    if(i > 1 && j > 1 && boardMatrix[i-1][j-1] == pl.getOtherColor()) {
                        n = 0;
                        if(i>=j) {
                            m = i-2;
                            for (q = j-2; q >= 0; q--){
                                if(boardMatrix[m][q] == pl.getColor() && n == 0 ){
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q]== EMPTY && n == 0){
                                    n = 1;
                                }
                                m = m - 1;
                            }
                        } else {
                            q = j - 2;
                            for (m = i-2; m >= 0; m--) {
                                if(boardMatrix[m][q] == pl.getColor() && n ==0) {
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q] == EMPTY && n == 0) {
                                    n = 1;
                                }
                                q = q - 1;
                            }
                        }
                    }
                    
                    // diagonal from upper right to lower left
                    if(i < boardSize - 1 && j > 1 && boardMatrix[i+1][j-1] == pl.getOtherColor()) {
                        n = 0;
                        if(i+j>=7) {
                            q = j-2;
                            for (m = i+2; m != boardSize; m++){
                                if(boardMatrix[m][q] == pl.getColor() && n == 0 ){
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q]== EMPTY && n == 0){
                                    n = 1;
                                }
                                q = q - 1;
                            }
                        } else {
                            m = i + 2;
                            for (q = j-2; q >= 0; q--) {
                                if(boardMatrix[m][q] == pl.getColor() && n ==0) {
                                    n = 1;
                                    possM[i][j] = POSSIBLE;
                                    numMoves++;
                                } else if(boardMatrix[m][q] == EMPTY && n == 0) {
                                    n = 1;
                                }
                                m = m + 1;
                            }
                        }
                    }
                }
            }
        }
        return numMoves;
    }
    
    /*
     * Calculating which markers have to be flipped due to a made move
     * @param pl the current player
     * @param X the x coordinate
     * @param Y the y coordinate
     * @param boardMatrix the current board
     * @return the updated board
     */
    public int[][] flip(Player pl, int X, int Y, int[][] boardMatrix) {
        int m=0, n=0, p=0, q=0;
        
        if ( X <= boardSize && X >= 0 && Y <= boardSize && Y >= 0) {
            
            // checking and maybe changing horizontally from left to right
            if (X < boardSize - 1) {
                if (boardMatrix[X+1][Y] == pl.getOtherColor()) {
                    n = 0;
                    p = 0;
                    for (m = X+1; m != boardSize; m++) {
                        if (boardMatrix[m][Y] == pl.getOtherColor() && p == 0) {
                            n++;
                        } else if (boardMatrix[m][Y] == pl.getColor() && p == 0) {
                            p = 1;
                        } else if (boardMatrix[m][Y] == EMPTY && p == 0) {
                            p = 2;
                        }
                    }
                    if (p == 1) {
                        for (m = X; m <= X + n; m++) {
                            boardMatrix[m][Y] = pl.getColor();
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
            
            // checking and maybe changing horizontally from right to left
            if (X > 0) {
                if (boardMatrix[X-1][Y] == pl.getOtherColor() && X > 0) {
                    n = 0;
                    p = 0;
                    for (m = X-1; m >= 0; m--) {
                        if (boardMatrix[m][Y] == pl.getOtherColor() && p == 0) {
                            n++;
                        } else if (boardMatrix[m][Y] == pl.getColor() && p == 0) {
                            p = 1;
                        } else if (boardMatrix[m][Y] == EMPTY && p == 0) {
                            p = 2;
                        }
                    }
                    if (p == 1) {
                        for (m = X; m >= X - n; m--) {
                            boardMatrix[m][Y] = pl.getColor();
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
            
            // checking and maybe changing vertically from top to bottom
            if (Y < boardSize - 1) {
                if (boardMatrix[X][Y+1] == pl.getOtherColor()) {
                    n = 0;
                    p = 0;
                    for (m = Y+1; m != boardSize; m++) {
                        if (boardMatrix[X][m] == pl.getOtherColor() && p == 0) {
                            n++;
                        } else if (boardMatrix[X][m] == pl.getColor() && p == 0) {
                            p = 1;
                        } else if (boardMatrix[X][m] == EMPTY && p == 0) {
                            p = 2;
                        }
                    }
                    if (p == 1) {
                        for (m = Y; m <= Y + n; m++) {
                            boardMatrix[X][m] = pl.getColor();
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
            
            // checking and maybe changing vertically from bottom to top
            if (Y > 0) {
                if (boardMatrix[X][Y-1] == pl.getOtherColor()) {
                    n = 0;
                    p = 0;
                    for (m = Y-1; m >= 0; m--) {
                        if (boardMatrix[X][m] == pl.getOtherColor() && p == 0) {
                            n++;
                        } else if (boardMatrix[X][m] == pl.getColor() && p == 0) {
                            p = 1;
                        } else if (boardMatrix[X][m] == EMPTY && p == 0) {
                            p = 2;
                        }
                    }
                    if (p == 1) {
                        for (m = Y; m >= Y - n; m--) {
                            boardMatrix[X][m] = pl.getColor();
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
            
            // checking and maybe changing diagonally from upper left to lower right
            if (X < boardSize - 1 && Y < boardSize - 1) {
                if (boardMatrix[X+1][Y+1] == pl.getOtherColor()) {
                    n = 0;
                    p = 0;
                    if (X >= Y) {
                        q = Y + 1;
                        for (m = X+1; m != boardSize; m++) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            q++;
                        }
                    } else {
                        m = X+1;
                        for (q = Y+1; q != boardSize; q++) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            m++;
                        }
                    }
                    if (p == 1) {
                        q = X+1;
                        for (m = Y+1; m <= Y + n; m++) {
                            boardMatrix[q][m] = pl.getColor();
                            q++;
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
            
            // checking and maybe changing diagonally from lower right to upper left
            if (X > 0 && Y > 0) {
                if (boardMatrix[X-1][Y-1] == pl.getOtherColor()) {
                    n = 0;
                    p = 0;
                    if (X >= Y) {
                        m = X - 1;
                        for (q = Y - 1; q >= 0; q--) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            m--;
                        }
                    } else {
                        q = Y - 1;
                        for (m = X - 1; m >= 0; m--) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            q--;
                        }
                    }
                    if (p == 1) {
                        q = X;
                        for (m = Y; m >= Y - n; m--) {
                            boardMatrix[q][m] = pl.getColor();
                            q--;
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
            
            // checking and maybe changing diagonally from lower left to upper right
            if (X > 0 && Y < boardSize - 1) {
                if (boardMatrix[X-1][Y+1] == pl.getOtherColor()) {
                    n = 0;
                    p = 0;
                    if (X + Y >= 7) {
                        m = X - 1;
                        for (q = Y + 1; q != boardSize; q++) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            m--;
                        }
                    } else {
                        q = Y + 1;
                        for (m = X - 1; m >= 0; m--) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            q++;
                        }
                    }
                    if (p == 1) {
                        q = X;
                        for (m = Y; m <= Y + n; m++) {
                            boardMatrix[q][m] = pl.getColor();
                            q--;
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
            // checking and maybe changing diagonally from upper right to lower left
            if (X < boardSize -1 && Y > 0) {
                if (boardMatrix[X+1][Y-1] == pl.getOtherColor()) {
                    n = 0;
                    p = 0;
                    if (X + Y >= 7) {
                        q = Y - 1;
                        for (m = X + 1; m != boardSize; m++) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            q--;
                        }
                    } else {
                        m = X + 1;
                        for (q = Y - 1; q >= 0; q--) {
                            if (boardMatrix[m][q] == pl.getOtherColor() && p == 0) {
                                n++;
                            } else if (boardMatrix[m][q] == pl.getColor() && p == 0) {
                                p = 1;
                            } else if (boardMatrix[m][q] == EMPTY && p == 0) {
                                p = 2;
                            }
                            m++;
                        }
                    }
                    if (p == 1) {
                        q = X;
                        for (m = Y; m >= Y - n; m--) {
                            boardMatrix[q][m] = pl.getColor();
                            q++;
                        }
                        boardMatrix[X][Y] = pl.getColor();
                    }
                }
            }
        }
        return boardMatrix;
    }
    
    /*
     * Returns the possible moves matrix
     * @return the current possible moves matrix
     */
    public int[][] getPossM() {
        return possM;
    }
    
    /*
     * Set the possible moves matrix
     * @param matrix the matrix to be set as the possible moves matrix
     */
    public void setMatrix(int[][] matrix) {
        for (int i = 0; i < boardSize; ++i) {
            for (int j = 0; j < boardSize; ++j) {
                possM[i][j] = matrix[i][j];
            }
        }
    }
    
    private int boardSize;
    private int[][] possM;
    
    private static final int BLACK = 0;
    private static final int WHITE = 1;
    private static final int EMPTY = 2;
    private static final int POSSIBLE = 3;
}