class_name BattleCutsceneAction

static func battleDecisionCallable(_params:Dictionary) -> int:
  print("Battle action executed.")
  return Cutscene.CUTSCENE_CONTINUE


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

static func playerDecisionCallable(_params:Dictionary) -> int:
  var decisions:Array[BattleDecision] = []

  for fighter:BattleFighter in BATTLE.fighterMap.values():
    if !fighter || !fighter.isPlayerControlled():
      continue

    # Handle player decision
    BATTLE.battleScene.actionBox.visible = true
    var decision = await BATTLE.battleScene.actionBox.decisionMade
    BATTLE.battleScene.actionBox.visible = false
    if decision == null:
      continue
    decisions.append(decision)

  # AI decisions
  for fighter:BattleFighter in BATTLE.fighterMap.values():
    if !fighter || fighter.isPlayerControlled():
      continue
    var decision = fighter.getAIDecision()
    if decision == null:
      continue
    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:
    _params['cutscene'].addCallable(BattleCutsceneAction.getBattleDecisionCallable(decision))
  
  return Cutscene.CUTSCENE_CONTINUE

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