package go;

public class Game {
    private Go_IO IOInterface;
    private Board GameBoard;
    private Player player1;
    private Player player2;
    private AnalysisData player1AnalysisData;
    private AnalysisData player2AnalysisData;
    private int currentTurn;
    private boolean configured;
    private int capturedStonesPlayer1;
    private int capturedStonesPlayer2;
    private Originator originator;
    private Caretaker caretaker;
    public static final int DEBUGLEVEL = 0;
    public static final Class IOTYPE = Go_ConsoleIO.class;


    // constructor
    public Game() {
        // create instance of Go_IO class, initialize other objects/variables
        try {
            IOInterface = Go_IOFactory.getIOFactoryInstance().create(IOTYPE);
        } catch (GoIOInstanceException e) {
            e.printStackTrace();
        }
        GameBoard = null;
        player1 = null;
        player2 = null;
        player1AnalysisData = new AnalysisData();
        player2AnalysisData = new AnalysisData();
        currentTurn = 0;
        configured = false;
        capturedStonesPlayer1 = 0;
        capturedStonesPlayer2 = 0;
        originator = null;
        caretaker = null;
    }

    public static void main(String args[]){
        Game game = new Game();

        game.startGame();
    }

    // start this method from main to start the game
    public void startGame() {
        while (true) {
            // print main menu and save menu choice in "menu"
            int menu = IOInterface.getMenu();

            // start the game
            if (menu == 1) {
                if (!configured) {
                    getDefaultConfiguration();
                    configured = true;
                }
                originator = new Originator();
                caretaker = new Caretaker();
                configured = false;
                gameLoop();
            }
            // configure the game
            else if (menu == 2) {
                getConfiguration();
                configured = true;
            }
        }
    }

    // get game configuration (dimension, human/ai player) from user
    private void getConfiguration() {
        // get board dimension
        GameBoard = new Board(IOInterface.getDimension());
        // initialize both players valid plays (all plays are valid in the beginning)
        player1AnalysisData.initValidPlays(GameBoard.getDimension());
        player2AnalysisData.initValidPlays(GameBoard.getDimension());
        // pass board to IO
        IOInterface.setBoard(GameBoard);

        // get players
        int player;
        // get player1 (player1 [black] starts the game)
        player = IOInterface.getPlayer(1);
        if (player == 1) {
            // create human player
            player1 = new Human(1);
        }
        else if (player == 2) {
            // create AI player
            player1 = new AI(1);
        }
        // get player2
        player = IOInterface.getPlayer(2);
        if (player == 1) {
            // create human player
            player2 = new Human(2);
        }
        else if (player == 2) {
            // create AI player
            player2 = new AI(2);
        }

        // pass board and IO to both players
        player1.setBoard(GameBoard);
        player2.setBoard(GameBoard);
        // pass IO to both players  ----> players can now get their own IO instance
        //player1.setIO(IOInterface);
        //player2.setIO(IOInterface);
        // initialize variables
        capturedStonesPlayer1 = 0;
        capturedStonesPlayer2 = 0;
        currentTurn = 0;
    }

    // default configuration: dimension = 9, HUMAN vs. AI
    private void getDefaultConfiguration() {
        // set board dimension
        final int DEFAULTDIMENSION = 9;
        GameBoard = new Board(DEFAULTDIMENSION);
        player1AnalysisData.initValidPlays(DEFAULTDIMENSION);
        player2AnalysisData.initValidPlays(DEFAULTDIMENSION);
        // pass board to IO
        IOInterface.setBoard(GameBoard);

        // get starting player
        int startingPlayer = IOInterface.getStartingPlayer();

        // set players
        if (startingPlayer == 1) {
            player1 = new Human(1);
            player2 = new AI(2);
        }
        else {
            player1 = new AI(1);
            player2 = new Human(2);
        }

        // pass board to both players
        player1.setBoard(GameBoard);
        player2.setBoard(GameBoard);
        // pass IO to both players  ---> players can now get their own IO instance
        //player1.setIO(IOInterface);
        //player2.setIO(IOInterface);
        // initialize variables
        capturedStonesPlayer1 = 0;
        capturedStonesPlayer2 = 0;
        currentTurn = 0;
    }


    private void gameLoop() {
        Boolean rungame = true;
        int currentPlayer = 1;
        save();

        while (rungame) {
            if (DEBUGLEVEL == 1) {
                // debug();
            }

            switch (currentPlayer) {
                case 1:
                    IOInterface.printTurn(currentTurn);
                    IOInterface.printCapturedStones(capturedStonesPlayer1, capturedStonesPlayer2);
                    IOInterface.printBoard();
                    currentPlayer = makeTurn(currentPlayer);
                    break;
                case 2:
                    IOInterface.printTurn(currentTurn);
                    IOInterface.printCapturedStones(capturedStonesPlayer1, capturedStonesPlayer2);
                    IOInterface.printBoard();
                    currentPlayer = makeTurn(currentPlayer);
                    break;
                case -3:
                    // both passed
                    endGame();
                    rungame = false;
                    break;
                case -2:
                    // player2 forfeited
                    endGameForfeit(2);
                    rungame = false;
                    break;
                case -1:
                    // player1 forfeited
                    endGameForfeit(1);
                    rungame = false;
                    break;
            }
        }

    }

    private int makeTurn(int player) {
        currentTurn++;
        // player1 turn
        if (player == 1) {
            // get player1Status
            player1AnalysisData = player1.playTurn(player2AnalysisData.getValidPlays());

            switch (player1AnalysisData.getPlayerStatus()) {
                // normal turn
                case 0:
                    capturedStonesPlayer1 += player1AnalysisData.getCapturedStones();
                    save();
                    return 2;
                // pass
                case 1:
                    // if both passed
                    if (player2AnalysisData.getPlayerStatus() == 1) {
                        // end the game
                        return -3;
                    }
                    save();
                    return 2;
                // forfeit
                case 2:
                    return -1;
                // undo
                case 3:
                    // undo not allowed in turn 1 and 2
                    if (currentTurn <= 2) {
                        IOInterface.printUndoError();
                        currentTurn--;  //
                    }
                    else {
                        undo();
                    }
                    return 1;
                // no more valid plays
                case 4:
                    IOInterface.printNoMoreValidPlaysMessage(1);
                    // if both passed
                    if (player2AnalysisData.getPlayerStatus() == 1) {
                        // end the game
                        return -3;
                    }
                    save();
                    return 2;
            }
        }

        // player2 turn
        else if (player == 2) {
            // get player2Status
            player2AnalysisData = player2.playTurn(player1AnalysisData.getValidPlays());

            switch (player2AnalysisData.getPlayerStatus()) {
                // normal turn
                case 0:
                    capturedStonesPlayer2 += player2AnalysisData.getCapturedStones();
                    save();
                    return 1;
                // pass
                case 1:
                    // if both passed
                    if (player1AnalysisData.getPlayerStatus() == 1) {
                        // end the game
                        return -3;
                    }
                    save();
                    return 1;
                // forfeit
                case 2:
                    return -2;
                // undo
                case 3:
                    // undo not allowed in turn 1 and 2
                    if (currentTurn <= 2) {
                        IOInterface.printUndoError();
                        currentTurn--;
                    }
                    else {
                        undo();
                    }
                    return 2;
                // no more valid plays
                case 4:
                    IOInterface.printNoMoreValidPlaysMessage(2);
                    // if both passed
                    if (player2AnalysisData.getPlayerStatus() == 1) {
                        // end the game
                        return -3;
                    }
                    save();
                    return 1;
            }
        }

        return 0;
    }

    private void undo() {
        Memento last = caretaker.getLastMemento();
        originator.restoreFromMemento(last);
        GameBoard.overwrite(last.getSavedBoard());
        player1AnalysisData.setValidPlays(GameBoard.getValidPlays(2));
        player2AnalysisData.setValidPlays(GameBoard.getValidPlays(1));
        GameBoard.getValidPlays(2);
        currentTurn = last.getSavedTurn();
        capturedStonesPlayer1 = last.getSavedCapturedStonesForPlayer1();
        capturedStonesPlayer2 = last.getSavedCapturedStonesForPlayer2();
    }

    private void save() {
        // make deep copy of the current GameBoard and save that copy instead of the current board
        Board GameBoardCopy = new Board(GameBoard);
        originator.set(GameBoardCopy, currentTurn, capturedStonesPlayer1, capturedStonesPlayer2);
        Memento memento = originator.storeInMemento();
        caretaker.addMemento(memento);
    }

    private void endGame() {
        double player1score = capturedStonesPlayer1;
        double player2score = 6.5 + capturedStonesPlayer2;

        IOInterface.printEndGameMessage(player1score, player2score);

        IOInterface.printBackToMenuMessage();
    }

    private void endGameForfeit(int player) {
        IOInterface.printForfeitMessage(player);
        IOInterface.printBackToMenuMessage();
    }

    /* private void debug() {
        System.err.print("savedMementos.size() = " + caretaker.savedMementosSize());
        System.err.println();
        System.err.print("Valid plays BLACK: ");
        for (int play : GameBoard.getValidPlays(1)) {
            System.err.print(play + " ");
        }
        System.err.println();
        System.err.print("Valid plays WHITE: ");
        for (int play : GameBoard.getValidPlays(2)) {
            System.err.print(play + " ");
        }
        System.err.println();
        System.err.print("Board Belegung: ");
        for (int i = 0; i < GameBoard.getDimension()*GameBoard.getDimension(); i++) {
            System.err.print(GameBoard.getStone(i).getColor() + " ");
        }
        System.err.println();
    } */
}