import java.util.Scanner;

public class Main {


    private static String[] discs = {"X", "O"};

    public static String[] getDiscs() {
        return discs;
    }

    private static String[] getValidCells(int[] columnHeights, Scanner reader){
        boolean error = false;

        String[] unUsuableCells;
        do {
            error = false;
            StringBuilder errorMessage = new StringBuilder();

            unUsuableCells = reader.nextLine().split(" ");
            if(unUsuableCells.length != 2){
                errorMessage.append("Must give 2 cells\n");
                error = true;
            }
            else if(unUsuableCells[0].equals(unUsuableCells[1])){
                errorMessage.append("Must give 2 distinct cells\n");
                error = true;
            }
            else {
                for (int i = 0; i < unUsuableCells.length; i++) {
                    int col = unUsuableCells[i].charAt(0) - 'A';
                    int row = Character.getNumericValue(unUsuableCells[i].charAt(1)) - 1;

                    if (col < 0 || col >= columnHeights.length) {
                        error = true;
                        errorMessage.append("Invalid set of columns (letters)\n");
                    } else if (row < 0 || row >=columnHeights[col]) {
                        error = true;
                        errorMessage.append("Invalid set of rows (must be 1 - height of column)\n");
                    }
                    if (error) {
                        break;
                    }
                }
            }

            if (error) {
                errorMessage.append("Please enter valid cells\n");
                System.out.println(errorMessage.toString());
            }
        } while (error);
        return  unUsuableCells;
    }


    private static void compVSCompSimulation(Board board){
        String[][] originalCells =
                new String[board.getCells().length][board.getColumnHeights().length];


        for(int i=0; i<originalCells.length; i++){
            for(int j=0; j<originalCells[i].length; j++){
                originalCells[i][j] = board.getCells()[i][j];
            }
        }

        ComputerPlayer[] players = new ComputerPlayer[2];
        ComputerPlayer player1 = new ComputerPlayer("X", 0);
        ComputerPlayer player2 = new ComputerPlayer("O", 0);
        players[0] = player1;
        players[1] = player2;
        int wins[];
        int winner;

        //both are computer
        int[] efforts = new int[]{80, 150, 500, 2000};

        int currPlayer;

        for(int k=0; k<1; k++) {
            player1.effort = efforts[k];

            for (int j = 0; j < 1; j++) {
                player2.effort = efforts[j];
                wins = new int[2];
                for (int i = 0; i < 100; i++) {
                    currPlayer = 0;
                    while (!board.haveWinner() && (!board.boardIsFull())) {
                        players[currPlayer].makeMove(board);
                        currPlayer = currPlayer ^ 1;
                    }

                    winner = currPlayer ^ 1;
                    wins[winner]++;

                    board.setCells(originalCells);
                }

                System.out.println(((ComputerPlayer) players[0]).effort + " effort -> " + wins[0]);
                System.out.println(((ComputerPlayer) players[1]).effort + " effort -> " + wins[1]);
            }
        }
    }


    private static void oneGame(Board board, Scanner reader){
        board.printBoard();

        Player player1;
        Player player2;

        String effort = "";

        System.out.println("Human-vs-Computer or Computer-vs-Computer? (1/2) ");
        String gameType = reader.nextLine();
        if(gameType.equals("1")){
            player1 = new HumanPlayer("X", reader);
            System.out.println("Enter effort of Computer player: ");
            effort = reader.nextLine();
            player2 = new ComputerPlayer("O", Integer.parseInt(effort));
        }
        else {
            System.out.println("Enter effort of Computer player1: ");
            effort = reader.nextLine();
            player1 = new ComputerPlayer("X", Integer.parseInt(effort));
            System.out.println("Enter effort of Computer player2: ");
            effort = reader.nextLine();
            player2 = new ComputerPlayer("O", Integer.parseInt(effort));
        }

        int currPlayer = 0;

        System.out.println("Which player will go first? (1/2)");
        String firstPlayer = reader.nextLine();
        if(firstPlayer.equals("2")){
            currPlayer = 1;
        }



        Player[] players = new Player[]{player1, player2};


        int winner = 0;

        while(!board.haveWinner() &&  (!board.boardIsFull())){

            players[currPlayer].makeMove(board);
            if(player1 instanceof HumanPlayer){
                board.printBoard();
            }
            currPlayer = currPlayer ^ 1;
        }

        winner = currPlayer ^ 1;

        System.out.println("GAME OVER");
        if(board.haveWinner()){
            System.out.println("Player"+(winner+1)+" is the winner!");
        }
        else {
            System.out.println("DRAW!");
        }
    }


    public static void main(String[] args) {

        System.out.println("Game setup:\n");


        Scanner reader = new Scanner(System.in);
        String[] heights = reader.nextLine().split(" ");

        while(heights.length < 6 || heights.length > 11){
            System.out.println("Invalid columns - Must be between 6-11 columns\n");
            System.out.println("Please enter a valid set of columns");
            heights = reader.nextLine().split(" ");
        }



        int[] columnHeights = new int[heights.length];
        for (int i = 0; i < heights.length; i++) {
            columnHeights[i] = Integer.parseInt(heights[i]);
        }



        Board board = new Board(columnHeights, getValidCells(columnHeights, reader));
        board.setup();

        //oneGame(board, reader);
        compVSCompSimulation(board);

        reader.close();


    }
}