public BattleController(Entity player, List<Entity> enemies) throws IllegalArgumentException

   /**
   * Starts the battle encounter
   * @throws IllegalStateException if the battle has already begun 
   */
  public void start() throws IllegalStateException

   /**
   * Reports whether the player currently has the given status effect.
   *
   * <p>Read-only: exposes a query about the player rather than the player entity itself, so callers
   * cannot mutate player state through this controller.
   *
   * @param effectType identifier of the status effect, as stored by CombatStatsComponent
   * @return true if the player carries an active effect with this identifier
   */
  public boolean playerHasStatusEffect(String effectType)

  /**
   * Player decides to end their turn
   */
  public void endPlayerTurn()

  /**
   * Resets the current battle to a completely new battle that has no previous player and
   * enemy turns
   */
  public void resetBattle()

  /**
   * Retrieves the current phase of the battle (e.g. player turn, enemy turn, player attack, etc.)
   * @return the current phase of the BattleController instance
   */
  public BattlePhase getCurrentPhase()

  /**
   * Returns whether the battle is in the player input phase.
   *
   * @return true only during {@link BattlePhase#PLAYER_TURN}; false during card resolution, setup,
   *     enemy turns, and all other phases
   */
  public boolean isPlayerTurn()

  /**
   * Returns the current targeted enemy.
   *
   * @return An int representing the targeted entity within the array.
   */
  public int getCurrentEnemyIndex()

  /**
   * Adds a listener to the event handler, which ultimately informs external teams about a phase
   * change.
   *
   * @param listener The instantiated external listener.
   */
  public void addPhaseChangeListener(EventListener2<BattlePhase, BattlePhase> listener)

  /**
   * Adds a listener for short, human-readable descriptions of what just happened in the battle.
   * Used by the UI to pop up "you did X" / "the enemy did Y" messages between turns.
   *
   * @param listener receives the message text
   */
  public void addBattleLogListener(EventListener1<String> listener)

  /**
   * Adds a listener for the end of the battle. The argument is {@code true} on a win (all enemies
   * defeated) and {@code false} on a loss (player defeated). This is the hook the UI uses to switch
   * to the victory or defeat screen.
   *
   * @param listener receives the win/loss flag
   */
  public void addBattleEndListener(EventListener1<Boolean> listener)

  /**
   * Adds a listener that receives the resolved enemy-facing effects of a played card, for Team 1 to
   * apply. The controller also applies these itself so the encounter still resolves.
   *
   * @param listener receives the resolved effects
   */
  public void addEnemyEffectsListener(EventListener1<List<ResolvedCardEffect>> listener)

  /**
   * Adds a listener that receives the resolved player-facing effects of a played card, for Team 7
   * to apply. The controller also applies these itself so the encounter still resolves.
   *
   * @param listener receives the resolved effects
   */
  public void addPlayerEffectsListener(EventListener1<List<ResolvedCardEffect>> listener)

  /**
   * Adds a listener that receives the player's hand (card IDs) after it changes, e.g. once a played
   * card has moved from hand to discard. The UI uses this to refresh the on-screen hand.
   *
   * @param listener receives the updated hand
   */
  public void addHandChangedListener(EventListener1<List<String>> listener)

  /** Sends a one-line description of the latest battle action to any log listeners. */
  private void narrate(String message)

  /**
   * Convenience function for returning if a given event can be handled within a state.
   *
   * @param event The event to check.
   * @return True if the event is valid to be applied. False if not.
   */
  public boolean canHandle(BattleEvent event)

BattleController controller = new BattleController()

controller.start();

controller.addBattleLogListener(message -> {
    System.out.println(message);
});

int enemyIndex = battleController.getCurrentEnemyIndex();

System.out.println("Currently targeting enemy: " + enemyIndex);

if (battleController.canHandle(event)) {
    battleController.handle(event);
}