class BenchmarkDriver::Output

def self.get(type)
  if type.include?(':')
    raise ArgumentError.new("Output type '#{type}' cannot contain ':'")
  end
  require "benchmark_driver/output/#{type}" # for plugin
  camelized = type.split('_').map(&:capitalize).join
  ::BenchmarkDriver::Output.const_get(camelized, false)
end

def initialize(type:, metrics:, jobs:, contexts:, options:)
  output = ::BenchmarkDriver::Output.get(type)
  output_params = output.instance_method(:initialize).parameters.select do |type, _name|
    type == :keyreq || type == :key
  end.map(&:last)
  # Optionally pass `options` to #initialize
  kwargs = {}
  if output_params.include?(:options)
    kwargs[:options] = options
  end
  @output = output.new(
    metrics: metrics,
    jobs: jobs,
    contexts: contexts,
    **kwargs,
  )
end

def metrics=(metrics)
  @output.metrics = metrics
end

def report(values:, all_values: nil, duration: nil, loop_count: nil, environment: {})
  result = BenchmarkDriver::Result.new(
    values: values,
    all_values: all_values,
    duration: duration,
    loop_count: loop_count,
    environment: environment,
  )
  @output.report(result)
end

def with_benchmark(&block)
  @output.with_benchmark(&block)
end

def with_context(name:, executable:, gems: {}, prelude: '', &block)
  context = BenchmarkDriver::Context.new(name: name, executable: executable, gems: gems, prelude: prelude)
  @output.with_context(context) do
    block.call
  end
end

def with_job(name:, &block)
  job = BenchmarkDriver::Job.new(name: name)
  @output.with_job(job) do
    block.call
  end
end

def with_warmup(&block)
  @output.with_warmup(&block)
end