import 'dart:developer' as d;

abstract class RewardProvider<PlayerType> {
  Map<PlayerType, double> rewards();
}

  Function? backpropObserver;

  bool useRewards;

    this.backpropObserver,

    this.useRewards = false,

  final Map<PlayerType, int> winsByPlayer = {};

  final Map<PlayerType, double> winsByPlayer = {};

    if (config.backpropObserver != null) {
      while (rootNode!.parent != null) {
        rootNode = rootNode.parent;
      }
      config.backpropObserver!(winner, rootNode, currentNode);
    }

      currentNode.visits += 1;
      currentNode = currentNode.parent;
    }
  }
  rewardBackProp(Map<PlayerType, double> rewards) {
    Node<MoveType, PlayerType?>? currentNode = this;
    Node<MoveType, PlayerType?>? rootNode = this;
    while (currentNode != null) {
      rewards.forEach((player, reward) {
        currentNode?.winsByPlayer
            .update(player, (value) => value + reward, ifAbsent: () => reward);
      });
      var currentPlayerReward = rewards[currentPlayer()]!;
      // Q[s][a] = (N[s][a]*Q[s][a] + v)/(N[s][a]+1)
      currentNode.q =
          (currentNode.visits * currentNode.q + currentPlayerReward) /
              (currentNode.visits + 1.0);

  Function? backpropObserver;

  MCTS({this.gameState, this.backpropObserver});

  MCTS({this.gameState});

    bool useRewards = false,
    bool resetDepth = true,

        backpropObserver: backpropObserver,

        opponentWinsShortCircuit: opponentWinsShortCircuit);

        opponentWinsShortCircuit: opponentWinsShortCircuit,
        useRewards: useRewards);

      if (resetDepth) currentDepth = 0;

      currentNode.backProp(winner);

      if (gameState is RewardProvider && config.useRewards) {
        currentNode.rewardBackProp(
            (gameState as RewardProvider<PlayerType>).rewards());
      } else {
        currentNode.backProp(winner);
      }

    PlayerType? winner = null;
    if (config.nnpv == null &&
        config.useRewards == true &&
        gameState is RewardProvider) {
      if (currentDepth >= config.useValueAfterDepth!) {
        var rewards = (gameState as RewardProvider).rewards();
        var sortedRewards = List.from(rewards.values);
        sortedRewards.sort();
        var highestReward = sortedRewards.last;
        for (var player in rewards.keys) {
          if (highestReward == rewards[player]) {
            return player;
          }
        }
      }
    }

        d.log('currentDepth: $currentDepth');