/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package core;

import java.awt.Color;
import java.util.ArrayList;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

/**
 *
 * @author adang
 */
public class Board
{
    private Disc[][]board;
    private int darkCount;
    private int lightCount;
    private ArrayList<Player> players;

    public Board()
    {
        initObjects();
    }

    private void initObjects()
    {
        //declare the size of the array
        board = new Disc[Constants.ROWS][Constants.COLUMNS];

        //initialize each object in the array
        for(int row = 0; row < Constants.ROWS; row++)
        {
            for(int col = 0; col < Constants.COLUMNS; col++)
            {
                //something goes here -- calling no argument constructor for class Disc
                board[row][col] = new Disc();
            }
        }

        //initial setup of the board
        board[3][3].setDiscColor(Constants.LIGHT);
        board[3][4].setDiscColor(Constants.DARK);
        board[4][3].setDiscColor(Constants.DARK);
        board[4][4].setDiscColor(Constants.LIGHT);
    }

    /**
     * @return the board
     */
    public Disc[][] getBoard()
    {
        return board;
    }

    /**
     * @param board the board to set
     */
    public void setBoard(Disc[][] board)
    {
        this.board = board;
    }

    public void calculateScore()
    {
        darkCount = 0;
        lightCount = 0;
        for(int row = 0; row < Constants.ROWS; row++)
        {
            for(int col = 0; col <Constants.COLUMNS; col++)
            {
                if (board[row][col].getDiscColor() == Constants.DARK)
                    darkCount++;
                else if(board[row][col].getDiscColor() == Constants.LIGHT)
                    lightCount++;
            }
        }
        players.get(Constants.PLAYER_ONE).setScore(darkCount);
        players.get(Constants.PLAYER_TWO).setScore(lightCount);


    }

    public boolean gameOver()
    {
       JFrame frame = new JFrame("Game Over");
       boolean gameIsOver = false;
       int filledSquares = 0;
       int emptySquares = 0; // doesn't affect anything
       int playerOneScore = players.get(Constants.PLAYER_ONE).getScore();
       int playerTwoScore = players.get(Constants.PLAYER_TWO).getScore();

       //this checks the board to see if all of the squares are populated
       for(int row = 0; row < Constants.ROWS; row++)
       {
            for(int col = 0; col <Constants.COLUMNS; col++)
            {
                if (board[row][col].getDiscColor() != Constants.EMPTY)
                    filledSquares++;
                else if(board[row][col].getDiscColor() == Constants.EMPTY)
                    emptySquares++;
            }
       }

       if (filledSquares == Constants.MAX_DISCS)
       {
           if (playerOneScore > playerTwoScore )
           {
               JOptionPane.showMessageDialog(frame, "Game Over! Player One wins!");
               //System.exit(0);
           }
           else if (playerTwoScore > playerOneScore)
           {
               JOptionPane.showMessageDialog(frame, "Game Over! Player Two wins!");
               //System.exit(0);
           }
           else
           {
               JOptionPane.showMessageDialog(frame, "Game Over! It is a tie!");
               //System.exit(0);
           }


       }

       //checks to see if neither player can make a valid move.

       boolean anyValidMoves = false;
       Color color;


       for(int row = 0; row < Constants.ROWS; row++)
       {
            for(int col = 0; col <Constants.COLUMNS; col++)

            {
                color = players.get(Constants.PLAYER_ONE).getDiscColor();
                if(checkUpValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkUpLeftValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkLeftValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkLeftDownValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkDownValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkDownRightValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkRightValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkUpRightValid(row, col, color))
                {
                   anyValidMoves = true;
                }
            }
        }

       if (anyValidMoves == false)
       {
           if (playerOneScore > playerTwoScore )
           {
               JOptionPane.showMessageDialog(frame, "No available moves! Game Over! Player One wins!");
               //System.exit(0);
           }
           else if (playerTwoScore > playerOneScore)
           {
               JOptionPane.showMessageDialog(frame, "No available moves! Game Over! Player Two wins!");
               //System.exit(0);
           }
           else
           {
               JOptionPane.showMessageDialog(frame, "Now available moves! Game Over! It is a tie!");
               //System.exit(0);
           }

       }


       for(int row = 0; row < Constants.ROWS; row++)
       {
            for(int col = 0; col <Constants.COLUMNS; col++)
            {
                color = players.get(Constants.PLAYER_TWO).getDiscColor();

                if(checkUpValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkUpLeftValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkLeftValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkLeftDownValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkDownValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkDownRightValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkRightValid(row, col, color))
                {
                   anyValidMoves = true;
                }
                if(checkUpRightValid(row, col, color))
                {
                   anyValidMoves = true;
                }
            }
        }
       if (anyValidMoves == false)
       {
           if (players.get(Constants.PLAYER_ONE).getScore() > players.get(Constants.PLAYER_TWO).getScore() )
           {
               JOptionPane.showMessageDialog(frame, "Game Over! Player One wins!");
               return gameIsOver;
           }
           else if (players.get(Constants.PLAYER_TWO).getScore() > players.get(Constants.PLAYER_ONE).getScore())
           {
               JOptionPane.showMessageDialog(frame, "Game Over! Player Two wins!");
               return gameIsOver;
           }
           else
           {
               JOptionPane.showMessageDialog(frame, "Game Over! It is a tie!");
               return gameIsOver;
           }


       }

    return gameIsOver;
    }

    // color is the current player's disc color
    public boolean isValidMove(int row, int col, Color color)
    {
        boolean valid = false;

        // checks all directions to see if discs can be flipped
        if(checkUp(row, col, color))
        {
            valid = true;
        }
        if(checkUpLeft(row, col, color))
        {
            valid = true;
        }
        if(checkLeft(row, col, color))
        {
            valid = true;
        }
        if(checkLeftDown(row, col, color))
        {
            valid = true;
        }
        if(checkDown(row, col, color))
        {
            valid = true;
        }
        if(checkDownRight(row, col, color))
        {
            valid = true;
        }
        if(checkRight(row, col, color))
        {
            valid = true;
        }
        if(checkUpRight(row, col, color))
        {
            valid = true;
        }

        if(valid)
        {
            board[row][col].setDiscColor(color);
            calculateScore();
            gameOver();
        }
        return valid;
    }



    // row is the cliked row
    // col is the clicked column
    // color is the current player's disc color
    private boolean checkUp (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkCol = col;
        int checkRow = row - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow >= 0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;

            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY) //this is to ensure that there isn't already a disc in the grid
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow--;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                row--;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);

            validMove = true;
        }
        else
        {
            validMove = false;
        }


        return validMove;
    }

     private boolean checkUpLeft (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row - 1;
        int checkCol = col - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow >= 0 && checkCol >=0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;

            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow--;
            checkCol--;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                row--;
                col--;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);

            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkLeft (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row;
        int checkCol = col - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkCol >=0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol--;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                col--;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);

            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkLeftDown (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row + 1;
        int checkCol = col - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow < Constants.ROWS && checkCol >=0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol--;
            checkRow++;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                col--;
                row++;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);

            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkDown (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkCol = col;
        int checkRow = row + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow < Constants.ROWS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow++;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                row++;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkDownRight (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row + 1;
        int checkCol = col + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow < Constants.ROWS && checkCol < Constants.COLUMNS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol++;
            checkRow++;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                row++;
                col++;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);

            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkRight (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row;
        int checkCol = col + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkCol < Constants.COLUMNS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol++;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                col++;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);

            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkUpRight (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row - 1;
        int checkCol = col + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow >= 0 && checkCol < Constants.COLUMNS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;

            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow--;
            checkCol++;
        }
        if (matchFound && flipSquares > 0)
        {
            do
            {
                row--;
                col++;
                flipSquares--;
                board[row][col].setDiscColor(color);
            } while(flipSquares > 0);

            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    // CHECK FOR VALID WITHOUT CHANGING THE BOARD
    /////

    //





    private boolean checkUpValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkCol = col;
        int checkRow = row - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow >= 0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY) //this is to ensure that there isn't already a disc in the grid
            {
                validMove = false;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow--;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

     private boolean checkUpLeftValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row - 1;
        int checkCol = col - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow >= 0 && checkCol >=0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow--;
            checkCol--;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkLeftValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row;
        int checkCol = col - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkCol >=0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol--;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkLeftDownValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row + 1;
        int checkCol = col - 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow < Constants.ROWS && checkCol >=0 && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol--;
            checkRow++;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkDownValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkCol = col;
        int checkRow = row + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow < Constants.ROWS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
                return validMove;

            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow++;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkDownRightValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row + 1;
        int checkCol = col + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow < Constants.ROWS && checkCol < Constants.COLUMNS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol++;
            checkRow++;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkRightValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row;
        int checkCol = col + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkCol < Constants.COLUMNS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }
            checkCol++;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    private boolean checkUpRightValid (int row, int col, Color color)
    {
        int flipSquares = 0;
        int checkRow = row - 1;
        int checkCol = col + 1;
        boolean matchFound = false;
        boolean validMove = false;

        while (checkRow >= 0 && checkCol < Constants.COLUMNS && !matchFound)
        {
            if(board[checkRow][checkCol].getDiscColor() == Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if(board[row][col].getDiscColor() != Constants.EMPTY)
            {
                validMove = false;
                return validMove;
            }
            else if (board[checkRow][checkCol].getDiscColor() != color)
            {
                flipSquares++;
            }
            else
            {
                matchFound = true;
            }

            checkRow--;
            checkCol++;
        }
        if (matchFound && flipSquares > 0)
        {
            validMove = true;
        }
        else
        {
            validMove = false;
        }
        return validMove;
    }

    /**
     * @return the darkCount
     */
    public int getDarkCount() {
        return darkCount;
    }

    /**
     * @param darkCount the darkCount to set
     */
    public void setDarkCount(int darkCount) {
        this.darkCount = darkCount;
    }

    /**
     * @return the lightCount
     */
    public int getLightCount() {
        return lightCount;
    }

    /**
     * @param lightCount the lightCount to set
     */
    public void setLightCount(int lightCount) {
        this.lightCount = lightCount;
    }

    /**
     * @return the players
     */
    public ArrayList<Player> getPlayers() {
        return players;
    }

    /**
     * @param players the players to set
     */
    public void setPlayers(ArrayList<Player> players) {
        this.players = players;
    }


}