class Gherkin::Pickles::Compiler

# File lib/gherkin/pickles/compiler.rb, line 8
def initialize(id_generator)
  @id_generator = id_generator
end

# File lib/gherkin/pickles/compiler.rb, line 12
def compile(gherkin_document, source)
  pickles = []

  return pickles unless gherkin_document.feature

  feature = gherkin_document.feature
  language = feature.language
  tags = feature.tags

  compile_feature(pickles, language, tags, feature, source)
  pickles
end

# File lib/gherkin/pickles/compiler.rb, line 27
def compile_feature(pickles, language, tags, feature, source)
  feature_background_steps = []
  feature.children.each do |child|
    if child.background
      feature_background_steps.concat(child.background.steps)
    elsif child.rule
      compile_rule(pickles, language, tags, feature_background_steps, child.rule, source)
    else
      scenario = child.scenario
      if scenario.examples.empty?
        compile_scenario(tags, feature_background_steps, scenario, language, pickles, source)
      else
        compile_scenario_outline(tags, feature_background_steps, scenario, language, pickles, source)
      end
    end
  end
end

# File lib/gherkin/pickles/compiler.rb, line 45
def compile_rule(pickles, language, feature_tags, feature_background_steps, rule, source)
  tags = [].concat(feature_tags).concat(rule.tags)

  rule_background_steps = feature_background_steps.dup
  rule.children.each do |child|
    if child.background
      rule_background_steps.concat(child.background.steps)
    else
      scenario = child.scenario
      if scenario.examples.empty?
        compile_scenario(tags, rule_background_steps, scenario, language, pickles, source)
      else
        compile_scenario_outline(tags, rule_background_steps, scenario, language, pickles, source)
      end
    end
  end
end

# File lib/gherkin/pickles/compiler.rb, line 63
def compile_scenario(inherited_tags, background_steps, scenario, language, pickles, source)
  tags = [].concat(inherited_tags).concat(scenario.tags)

  last_keyword_type = Cucumber::Messages::PickleStepType::UNKNOWN
  steps = []
  unless scenario.steps.empty?
    [].concat(background_steps).concat(scenario.steps).each do |step|
      last_keyword_type =
        if step.keyword_type == Cucumber::Messages::StepKeywordType::CONJUNCTION
          last_keyword_type
        else
          step.keyword_type
        end
      steps.push(Cucumber::Messages::PickleStep.new(**pickle_step_props(step, [], nil, last_keyword_type)))
    end
  end

  pickle = Cucumber::Messages::Pickle.new(
    uri: source.uri,
    id: @id_generator.new_id,
    location: scenario.location,
    tags: pickle_tags(tags),
    name: scenario.name,
    language: language,
    ast_node_ids: [scenario.id],
    steps: steps
  )
  pickles.push(pickle)
end

# File lib/gherkin/pickles/compiler.rb, line 93
def compile_scenario_outline(inherited_tags, background_steps, scenario, language, pickles, source)
  scenario.examples.reject { |examples| examples.table_header.nil? }.each do |examples|
    variable_cells = examples.table_header.cells
    examples.table_body.each do |values_row|
      value_cells = values_row.cells
      tags = [].concat(inherited_tags).concat(scenario.tags).concat(examples.tags)

      last_keyword_type = nil
      steps = []
      unless scenario.steps.empty?
        background_steps.each do |step|
          last_keyword_type =
            if step.keyword_type == Cucumber::Messages::StepKeywordType::CONJUNCTION
              last_keyword_type
            else
              step.keyword_type
            end
          step_props = pickle_step_props(step, [], nil, last_keyword_type)
          steps.push(Cucumber::Messages::PickleStep.new(**step_props))
        end
        scenario.steps.each do |step|
          last_keyword_type =
            if step.keyword_type == Cucumber::Messages::StepKeywordType::CONJUNCTION
              last_keyword_type
            else
              step.keyword_type
            end
          step_props = pickle_step_props(step, variable_cells, values_row, last_keyword_type)
          steps.push(Cucumber::Messages::PickleStep.new(**step_props))
        end
      end

      pickle = Cucumber::Messages::Pickle.new(
        uri: source.uri,
        id: @id_generator.new_id,
        location: values_row.location,
        name: interpolate(scenario.name, variable_cells, value_cells),
        language: language,
        steps: steps,
        tags: pickle_tags(tags),
        ast_node_ids: [
          scenario.id,
          values_row.id
        ]
      )
      pickles.push(pickle)
    end
  end
end

# File lib/gherkin/pickles/compiler.rb, line 143
def interpolate(name, variable_cells, value_cells)
  variable_cells.each_with_index do |variable_cell, n|
    value_cell = value_cells[n]
    name = name.gsub('<' + variable_cell.value + '>', value_cell.value)
  end
  name
end

# File lib/gherkin/pickles/compiler.rb, line 178
def pickle_data_table(argument_index, data_table, variable_cells, value_cells)
  Cucumber::Messages::PickleTable.new(
    argument_index: argument_index,
    rows: data_table.rows.map do |row|
      Cucumber::Messages::PickleTableRow.new(
        cells: row.cells.map do |cell|
          Cucumber::Messages::PickleTableCell.new(
            value: interpolate(cell.value, variable_cells, value_cells)
          )
        end
      )
    end
  )
end

# File lib/gherkin/pickles/compiler.rb, line 193
def pickle_doc_string(argument_index, doc_string, variable_cells, value_cells)
  props = {
    argument_index: argument_index,
    content: interpolate(doc_string.content, variable_cells, value_cells)
  }
  props[:media_type] = interpolate(doc_string.media_type, variable_cells, value_cells) if doc_string.media_type
  Cucumber::Messages::PickleDocString.new(**props)
end

# File lib/gherkin/pickles/compiler.rb, line 151
def pickle_step_props(step, variable_cells, values_row, keyword_type)
  value_cells = values_row ? values_row.cells : []
  props = {
    id: @id_generator.new_id,
    ast_node_ids: [step.id],
    type: keyword_type,
    text: interpolate(step.text, variable_cells, value_cells),
  }
  props[:ast_node_ids].push(values_row.id) if values_row

  data_table_argument_index = nil
  doc_string_argument_index = nil
  if step.data_table && step.doc_string
    table_first = step.doc_string.location.line > step.data_table.location.line
    data_table_argument_index = table_first ? 1 : 2
    doc_string_argument_index = table_first ? 2 : 1
  end

  if step.data_table || step.doc_string
    props[:argument] = Cucumber::Messages::PickleStepArgument.new(
      data_table: step.data_table ? pickle_data_table(data_table_argument_index, step.data_table, variable_cells, value_cells) : nil,
      doc_string: step.doc_string ? pickle_doc_string(doc_string_argument_index, step.doc_string, variable_cells, value_cells) : nil
    )
  end
  props
end

# File lib/gherkin/pickles/compiler.rb, line 206
def pickle_tag(tag)
  Cucumber::Messages::PickleTag.new(
    name: tag.name,
    ast_node_id: tag.id
  )
end

# File lib/gherkin/pickles/compiler.rb, line 202
def pickle_tags(tags)
  tags.map { |tag| pickle_tag(tag) }
end