require_relative 'production'
require_relative 'grammar_visitor'

module Sequitur # Module for classes implementing the Sequitur algorithm
# A dynamic grammar is a context-free grammar that can be built incrementally.
#   Formally, a grammar has:
#   One start production
#   Zero or more other productions
#   Each production has a rhs that is a sequence of grammar symbols.
#   Grammar symbols are categorized into
#   -terminal symbols (i.e. String, Ruby Symbol,...)
#   -non-terminal symbols (i.e. ProductionRef)
class DynamicGrammar
  # Link to the start production.
  attr_reader(:start)

  # The set of production rules of the grammar
  attr_reader(:productions)

  # nodoc Trace the execution of the algorithm.
  attr(:trace)


  # Constructor.
  # Build a grammar with one empty rule as start/start rule.
  def initialize()
    @start = Production.new
    @productions = [ start ]
    @trace = false
  end

  # Emit a text representation of the grammar.
  # Each production rule is emitted per line.
  # @return [String]
  def to_string()
    rule_text = productions.map(&:to_string).join("\n")
    return rule_text
  end


  # Add a given production to the grammar.
  # @param aProduction [Production]
  def add_production(aProduction)
    # TODO: remove output
    puts "Adding #{aProduction.object_id}" if trace
    puts aProduction.to_string if trace
    productions << aProduction
  end


  # Remove a production with given index from the grammar
  # @param anIndex [Fixnum]
  # @return [Production] the production removed from the grammar.
  def remove_production(anIndex)
    puts "Before production removal #{productions[anIndex].object_id}" if trace
    puts to_string if trace
    prod = productions.delete_at(anIndex)
    # TODO: remove output
    puts('Removed: ' + prod.to_string) if trace
    prod.clear_rhs

    return prod
  end


  # Add the given token to the grammar.
  #   Append the token to the rhs of the start/start rule.
  # @param aToken [Object] input token to add
  def add_token(aToken)
    append_symbol_to(start, aToken)
  end

  # Part of the 'visitee' role in the Visitor design pattern.
  #   A visitee is expected to accept the visit from a visitor object
  # @param aVisitor [GrammarVisitor] the visitor object
  def accept(aVisitor)
    aVisitor.start_visit_grammar(self)

    # Let's proceed with the visit of productions
    productions.each { |prod| prod.accept(aVisitor) }

    aVisitor.end_visit_grammar(self)
  end

  # Factory method. Returns a visitor for this grammar.
  # @return [GrammarVisitor]
  def visitor()
    return GrammarVisitor.new(self)
  end

  protected

  # Append a given symbol to the rhs of passed production.
  # @param aProduction [Production]
  # @param aSymbol [Object]
  def append_symbol_to(aProduction, aSymbol)
    aProduction.append_symbol(aSymbol)
  end
end # class
end # module
# End of file