"""Tests for the MonteCarlo algorithm."""

import unittest

from imago.engine.decisionAlgorithm import DecisionAlgorithm
from imago.gameLogic.gameState import GameState
from imago.engine.monteCarlo import MCTS
from imago.engine.monteCarlo import MCTSNode

TEST_BOARD_SIZE = 9

class TestMonteCarlo(unittest.TestCase):
    """Test MonteCarlo algorithm."""

    def testPickMove(self):
        """Test picking a move."""
        state = GameState(TEST_BOARD_SIZE)
        tree = MCTS(state.lastMove)
        #print(tree.pickMove().toString())

    def testForceNextMove(self):
        """Test forcing next move."""

        # Next move before expansion (no children nodes)
        state = GameState(TEST_BOARD_SIZE)
        tree = MCTS(state.lastMove)
        self.assertEqual(set(), tree.root.children)
        tree.forceNextMove((0, 1))
        self.assertEqual(set(), tree.root.children)

        # Next move after expansion (with children nodes)
        tree.expansions = 2
        tree.simulationsPerExpansion = 2
        tree.pickMove()
        self.assertEqual(tree.expansions, len(tree.root.children))
        nextMoveCoords = list(tree.root.children)[0].move.coords
        tree.forceNextMove(nextMoveCoords)

    def testPass(self):
        """Test passing as next move."""
        state = GameState(TEST_BOARD_SIZE)
        tree = MCTS(state.lastMove)
        self.assertFalse(tree.root.move.isPass)
        tree.forceNextMove("pass")
        self.assertTrue(tree.root.move.isPass)

    def testClearBoard(self):
        """Test clearing board returns root to original and retains information."""
        state = GameState(TEST_BOARD_SIZE)
        tree = MCTS(state.lastMove)

        firstMoveCoords = (0,0)
        secondMoveCoords = (1,0)
        thirdMoveCoords = (0,1)

        tree.forceNextMove(firstMoveCoords)
        tree.forceNextMove(secondMoveCoords)
        tree.forceNextMove(thirdMoveCoords)
        tree.clearBoard()

        nextNode = list(tree.root.children)[0]
        self.assertEqual(firstMoveCoords, nextNode.move.coords)
        nextNode = list(nextNode.children)[0]
        self.assertEqual(secondMoveCoords, nextNode.move.coords)
        nextNode = list(nextNode.children)[0]
        self.assertEqual(thirdMoveCoords, nextNode.move.coords)

    #def testSimulation(self):
    #    """Test calculation of group liberties."""
    #    board = GameBoard(TEST_BOARD_SIZE, TEST_BOARD_SIZE)
    #    move = GameMove(board)
    #    node = MCTSNode(move, None)
    #    nMatches = 100
    #    scoreDiffHeur = 15
    #    node.simulation(nMatches, scoreDiffHeur)

if __name__ == '__main__':
    unittest.main()