module Cucumber::StepMother

def After(*tag_names, &proc)
  register_hook(:after, tag_names, proc)
end

def Before(*tag_names, &proc)
  register_hook(:before, tag_names, proc)
end

def World(*world_modules, &proc)
  if(proc)
    raise MultipleWorld.new(@world_proc, proc) if @world_proc
    @world_proc = proc
  end
  @world_modules ||= []
  @world_modules += world_modules
end

def after(scenario)
  execute_after(scenario)
  nil_world!
end

def alias_adverb(adverb)
  adverb = adverb.gsub(/\s/, '')
  alias_method adverb, :register_step_definition
end

def before(scenario)
  unless current_world
    new_world!
    execute_before(scenario)
  end
end

def before_and_after(scenario, skip=false)
  before(scenario) unless skip
  yield
  after(scenario) unless skip
  scenario_visited(scenario)
end

def best_matches(step_name, step_matches)
  max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
  top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
  if top_groups.length > 1
    shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } }.min
    top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
  else
    top_groups
  end
end

def check_nil(o, proc)
  if o.nil?
    begin
      raise NilWorld.new
    rescue NilWorld => e
      e.backtrace.clear
      e.backtrace.push(proc.backtrace_line("World"))
      raise e
    end
  else
    o
  end
end

def connect_world
  @current_world.__cucumber_step_mother = self
  @current_world.__cucumber_visitor = @visitor
end

def create_world!
  if(@world_proc)
    @current_world = @world_proc.call
    check_nil(@current_world, @world_proc)
  else
    @current_world = Object.new
  end
end

def current_world
  @current_world
end

def execute_after(scenario)
  return if options[:dry_run]
  hooks_for(:after, scenario).each do |hook|
    hook.execute_in(@current_world, scenario, 'After')
  end
end

def execute_before(scenario)
  return if options[:dry_run]
  hooks_for(:before, scenario).each do |hook|
    hook.execute_in(@current_world, scenario, 'Before')
  end
end

def extend_world
  @current_world.extend(World)
  @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
  (@world_modules || []).each do |mod|
    @current_world.extend(mod)
  end
end

def hooks
  @hooks ||= Hash.new {|hash, phase| hash[phase] = []}
end

def hooks_for(phase, scenario)
  hooks[phase].select{|hook| scenario.accept_hook?(hook)}
end

def max_step_definition_length
  @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
end

def new_world!
  return if options[:dry_run]
  create_world!
  extend_world
  connect_world
  @current_world
end

def nil_world!
  @current_world = nil
end

def options
  @options || {}
end

def options
  @options || {}
end

def register_hook(phase, tags, proc)
  hook = Hook.new(tags, proc)
  hooks[phase] << hook
  hook
end

def register_step_definition(regexp, &proc)
  step_definition = StepDefinition.new(regexp, &proc)
  step_definitions.each do |already|
    raise Redundant.new(already, step_definition) if already.match(regexp)
  end
  step_definitions << step_definition
  step_definition
end

def scenario_visited(scenario)
  scenarios << scenario unless scenarios.index(scenario)
end

def scenarios(status = nil)
  @scenarios ||= []
  if(status)
    @scenarios.select{|scenario| scenario.status == status}
  else
    @scenarios
  end
end

def snippet_text(step_keyword, step_name, multiline_arg_class)
  @snippet_generator.snippet_text(step_keyword, step_name, multiline_arg_class)
end

def step_definitions
  @step_definitions ||= []
end

def step_match(step_name, formatted_step_name=nil)
  matches = step_definitions.map { |d| d.step_match(step_name, formatted_step_name) }.compact
  raise Undefined.new(step_name) if matches.empty?
  matches = best_matches(step_name, matches) if matches.size > 1 && options[:guess]
  raise Ambiguous.new(step_name, matches, options[:guess]) if matches.size > 1
  matches[0]
end

def step_visited(step)
  steps << step unless steps.index(step)
end

def steps(status = nil)
  @steps ||= []
  if(status)
    @steps.select{|step| step.status == status}
  else
    @steps
  end
end