class testNNPV implements NeuralNetworkPolicyAndValue<int?, TicTacToePlayer> {
  @override
  double getCurrentValue(GameState<int?, TicTacToePlayer> game) {
    // TODO: implement getCurrentValue
    throw UnimplementedError();
  }
  @override
  Map<int?, double> getMoveProbabilities(
      GameState<int?, TicTacToePlayer?> game) {
    // pretend that the neural net thinks corner moves are good first moves
    if (game.getMoves().length == 9) {
      return <int?, double>{
        0: 0.25,
        1: 0,
        2: 0.25,
        3: 0,
        4: 0,
        5: 0,
        6: 0.25,
        7: 0,
        8: 0.25,
      };
    }
    return {};
  }
}

  test('visits neural net prescribed nodes more frequently', () {
    var o = TicTacToePlayer.O;
    var x = TicTacToePlayer.X;
    var e;
    var ttgg = TicTacToeGame(
        board: [e, e, e, e, e, e, e, e, e], currentPlayer: o, scores: {});
    MCTSResult<int?, TicTacToePlayer> result = MCTS(gameState: ttgg)
        .getSimulationResult(iterations: 100, nnpv: testNNPV());
    expect(result.root!.children.length, equals(9));
    expect(result.maxDepth, equals(9));
    Map<int?, int> visits = {};
    result.root!.children.forEach((key, value) {
      visits[value.move] = value.visits;
    });
    print(visits);
    ttgg = TicTacToeGame(
        board: [e, e, e, e, e, e, e, e, e], currentPlayer: o, scores: {});
    result = MCTS(gameState: ttgg).getSimulationResult(iterations: 100);
    result.root!.children.forEach((key, value) {
      visits[value.move] = value.visits;
    });
    print(visits);
  });

}
abstract class NeuralNetworkPolicyAndValue<MoveType, PlayerType> {
  Map<MoveType, double> getMoveProbabilities(
      GameState<MoveType?, PlayerType?> game);
  double getCurrentValue(GameState<MoveType, PlayerType> game);

  NeuralNetworkPolicyAndValue? nnpv;
  Map<MoveType?, double> _moveProbabilitiesFromNN = {};

  int? useValueAfterDepth;
  double? valueThreshold;

    this.c = 1.41421356237,
    this.backpropObserver, // square root of 2

    this.c = 1.41421356237, // square root of 2
    this.backpropObserver,
    this.nnpv,
    this.useValueAfterDepth,
    this.valueThreshold,

          depth: depth + 1);

          depth: depth + 1,
          nnpv: nnpv,
          useValueAfterDepth: useValueAfterDepth,
          valueThreshold: valueThreshold);

  double ucb1(PlayerType player, int maxScore) {

  double ucb1(PlayerType player, int maxScore, double priorScore) {

        (c * sqrt(log(parent!.visits.toDouble() / visits)));

        (c * priorScore * sqrt(log(parent!.visits.toDouble() / visits)));

    if (nnpv != null && _moveProbabilitiesFromNN.isEmpty) {
      _moveProbabilitiesFromNN = nnpv!.getMoveProbabilities(
              gameState as GameState<MoveType?, PlayerType>)
          as Map<MoveType?, double>;
    }

      return b.value
          .ucb1(player, maxScore)
          .compareTo(a.value.ucb1(player, maxScore));

      double bScore = b.value
          .ucb1(player, maxScore, _moveProbabilitiesFromNN[b.key] ?? 1.0);
      double aScore = a.value
          .ucb1(player, maxScore, _moveProbabilitiesFromNN[a.key] ?? 1.0);
      return bScore.compareTo(aScore);

    int maxDepth = this.depth;

  MCTSResult<MoveType, PlayerType> getSimulationResult(
      {Node<MoveType, PlayerType>? initialRootNode,
      int iterations = 100,
      double? maxSeconds,
      List<MoveType>? actualMoves}) {

  MCTSResult<MoveType, PlayerType> getSimulationResult({
    Node<MoveType, PlayerType>? initialRootNode,
    int iterations = 100,
    double? maxSeconds,
    List<MoveType>? actualMoves,
    NeuralNetworkPolicyAndValue? nnpv,
    int? useValueAfterDepth,
    double? valueThreshold,
  }) {

          gameState: gameState,
          parent: null,
          move: null,
          c: c,
          backpropObserver: backpropObserver);

        gameState: gameState,
        parent: null,
        move: null,
        c: c,
        backpropObserver: backpropObserver,
        nnpv: nnpv,
        useValueAfterDepth: useValueAfterDepth,
        valueThreshold: valueThreshold,
      );

      t:

        if (currentNode.useValueAfterDepth != null &&
            currentNode.depth >= currentNode.useValueAfterDepth!) {
          if (currentNode.nnpv!.getCurrentValue(currentNode.gameState!) >=
              currentNode.valueThreshold!) {
            currentNode.gameState!.winner =
                currentNode.gameState!.currentPlayer;
          } else {
            currentNode.gameState!.winner = null;
          }
          break t;
        }