class Gamefic::Active::Cue

def finish
  props&.enter(actor.queue.shift&.strip)
  scene.finish
end

def initialize actor, key, narrative, **context
  @actor = actor
  @key = key
  @narrative = narrative
  @context = context
end

def output
  props&.output.clone.freeze || Props::Output::EMPTY
end

def prepare
  props.output.merge!({
                        scene: scene.to_hash,
                        prompt: props.prompt,
                        messages: actor.flush,
                        queue: actor.queue
                      })
  actor.narratives.player_output_blocks.each { |block| block.call actor, props.output }
end

def prepare_output
  props.output.last_input = actor.last_cue&.props&.input
  props.output.last_prompt = actor.last_cue&.props&.prompt
end

def restart
  Cue.new(actor, key, narrative, **context)
end

def scene
  # @note This method always returns a new instance. Scenes identified

  #   by symbolic keys can be instances of anonymous classes that cannot

  #   be serialized, so memoizing them breaks snapshots.

  narrative&.prepare(key, actor, props, **context) ||
    try_unblocked_class ||
    raise("Failed to cue #{key.inspect} in #{narrative.inspect}")
end

def start
  @props = scene.start
  prepare_output
  actor.rotate_cue
end

def to_s
  scene.to_s
end

def try_unblocked_class
  return unless key.is_a?(Class) && key <= Scene::Base
  Gamefic.logger.warn "Cueing scene #{key} without narrative" unless narrative
  key.new(actor, narrative, props, **context)
end

def type
  scene&.type
end