module Cucumber::Glue::ProtoWorld

def self.extended(object)
  # wrap the dynamically generated module so that we can document the methods
  # for yardoc, which doesn't like define_method.
  object.extend(ProtoWorld)
end

def self.for(runtime, language)
  Module.new do
    def self.extended(object)
      # wrap the dynamically generated module so that we can document the methods
      # for yardoc, which doesn't like define_method.
      object.extend(ProtoWorld)
    end
    # TODO: pass these in when building the module, instead of mutating them later
    # Extend the World with user-defined modules
    def add_modules!(world_modules, namespaced_world_modules)
      add_world_modules!(world_modules) if world_modules.any?
      add_namespaced_modules!(namespaced_world_modules) if namespaced_world_modules.any?
    end
    define_method(:step) do |name, raw_multiline_arg = nil|
      location = Core::Test::Location.of_caller
      runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
    end
    define_method(:steps) do |steps_text|
      location = Core::Test::Location.of_caller
      runtime.invoke_dynamic_steps(steps_text, language, location)
    end
    define_method(:ask) do |question, timeout_seconds = 60|
      runtime.ask(question, timeout_seconds)
    end
    define_method(:attach) do |file, media_type, filename|
      runtime.attach(file, media_type, filename)
    end
    # Prints the list of modules that are included in the World
    def inspect
      modules = [self.class]
      (class << self; self; end).instance_eval do
        modules += included_modules
      end
      modules << stringify_namespaced_modules
      format('#<%<modules>s:0x%<object_id>x>', modules: modules.join('+'), object_id: object_id)
    end
    private
    def add_world_modules!(modules)
      modules.each do |world_module|
        extend(world_module)
      end
    end
    def add_namespaced_modules!(modules)
      @__namespaced_modules = modules
      modules.each do |namespace, world_modules|
        world_modules.each do |world_module|
          variable_name = "@__#{namespace}_world"
          inner_world = instance_variable_get(variable_name) || Object.new
          instance_variable_set(
            variable_name,
            inner_world.extend(world_module)
          )
          self.class.send(:define_method, namespace) do
            instance_variable_get(variable_name)
          end
        end
      end
    end
    def stringify_namespaced_modules
      return '' if @__namespaced_modules.nil?
      @__namespaced_modules.map { |k, v| "#{v.join(',')} (as #{k})" }.join('+')
    end
  end
end

def add_modules!(world_modules, namespaced_world_modules)
  add_world_modules!(world_modules) if world_modules.any?
  add_namespaced_modules!(namespaced_world_modules) if namespaced_world_modules.any?
end

def add_namespaced_modules!(modules)
  @__namespaced_modules = modules
  modules.each do |namespace, world_modules|
    world_modules.each do |world_module|
      variable_name = "@__#{namespace}_world"
      inner_world = instance_variable_get(variable_name) || Object.new
      instance_variable_set(
        variable_name,
        inner_world.extend(world_module)
      )
      self.class.send(:define_method, namespace) do
        instance_variable_get(variable_name)
      end
    end
  end
end

def add_world_modules!(modules)
  modules.each do |world_module|
    extend(world_module)
  end
end

def ask(question, timeout_seconds = 60)
  super
end

def attach(file, media_type = nil, filename = nil)
  return super unless File.file?(file)
  content = File.read(file, mode: 'rb')
  media_type = MiniMime.lookup_by_filename(file)&.content_type if media_type.nil?
  super(content, media_type.to_s, filename)
rescue StandardError
  super
end

def inspect
  super
end

def inspect
  modules = [self.class]
  (class << self; self; end).instance_eval do
    modules += included_modules
  end
  modules << stringify_namespaced_modules
  format('#<%<modules>s:0x%<object_id>x>', modules: modules.join('+'), object_id: object_id)
end

def log(*messages)
  messages.each { |message| attach(message.to_s.dup, 'text/x.cucumber.log+plain') }
end

def pending(message = 'TODO')
  raise Pending, message unless block_given?
  yield
rescue Exception
  raise Pending, message
end

def skip_this_scenario(message = 'Scenario skipped')
  raise Core::Test::Result::Skipped, message
end

def step(name, raw_multiline_arg = nil)
  super
end

def steps(steps_text)
  super
end

def stringify_namespaced_modules
  return '' if @__namespaced_modules.nil?
  @__namespaced_modules.map { |k, v| "#{v.join(',')} (as #{k})" }.join('+')
end

def table(text_or_table)
  MultilineArgument::DataTable.from(text_or_table)
end

def to_s
  inspect
end