class_name BattleCutsceneAction

static func battleDecisionCallable(_params:Dictionary) -> int:
  print("Executing battle action...")
  await UI.TEXTBOX.setTextAndWait("Performing battle decision")
  var decision:BattleDecision = _params["decision"]
  return Cutscene.CUTSCENE_CONTINUE


static func getBattleDecisionCallable(decision:BattleDecision) -> Dictionary:
  return {
    "function": battleDecisionCallable,
    "decision": decision
  }

static func playerDecisionCallable(_params:Dictionary) -> int:
  # First, are all enemies, or all players, defeated?
  var allPlayersDead:bool = false
  var allEnemiesDead:bool = false
  for fighter:BattleFighter in BATTLE.fighterMap.values():
    if fighter == null:
      continue
    if fighter.status != BattleFighter.Status.DEAD:
      continue
    if fighter.isPlayerControlled():
      allPlayersDead = false
    else:
      allEnemiesDead = false

  # If all players are dead, game over unfortunately.
  if allPlayersDead:
    print("All players defeated! Game Over.")
    assert(false)

  # If all enemies are dead, victory!
  if allEnemiesDead:
    print("All enemies defeated! Victory!")
    assert(false)

  # Determine fighters and whether they're AI or player controlled
  var playerFighters:Array[BattleFighter] = []
  var aiFighters:Array[BattleFighter] = []

  for fighter:BattleFighter in BATTLE.fighterMap.values():
    if !fighter || !fighter.canPlayerMakeDecision():
      continue
    playerFighters.append(fighter)

  for fighter:BattleFighter in BATTLE.fighterMap.values():
    if !fighter || !fighter.canMakeDecision():
      continue
    if fighter in playerFighters:
      continue
    aiFighters.append(fighter)

  # Get decisions
  var decisions:Array[BattleDecision] = []
  var playerDecisions = await BATTLE.battleScene.getBattleDecisions(playerFighters)
  decisions.append_array(playerDecisions)

  for fighter in aiFighters:
    var decision = fighter.getAIDecision()
    if decision != null:
      decisions.append(decision)

  # Here I could do something like cutscene specific logic?

  # Prioritize moves
  decisions.shuffle()# Randomizes for moves that have equal chance of happening
  decisions.sort_custom(func(a:BattleDecision, b:BattleDecision) -> int:
    var priorityA = a.getPriority()
    var priorityB = b.getPriority()
    if priorityA > priorityB:
      return -1
    elif priorityA < priorityB:
      return 1
    else:
      return 0
  )

  # Turn into cutscene actions.
  for decision in decisions:
    print("Adding decision to cutscene: %s" % decision)
    _params['cutscene'].addCallable(BattleCutsceneAction.getBattleDecisionCallable(decision))

  # Then send to next decision
  _params['cutscene'].addCallable(BattleCutsceneAction.getPlayerDecisionCallable())
  
  return Cutscene.CUTSCENE_CONTINUE

static func getPlayerDecisionCallable() -> Dictionary:
  return {
    "function": playerDecisionCallable
  }