class Puma::Configuration

def self.random_token
  require 'securerandom' unless defined?(SecureRandom)
  SecureRandom.hex(16)
end

def self.temp_path
  require 'tmpdir'
  t = (Time.now.to_f * 1000).to_i
  "#{Dir.tmpdir}/puma-status-#{t}-#{$$}"
end

def app
  found = options[:app] || load_rackup
  if @options[:log_requests]
    require_relative 'commonlogger'
    logger = @options[:logger]
    found = CommonLogger.new(found, logger)
  end
  ConfigMiddleware.new(self, found)
end

def app_configured?
  @options[:app] || File.exist?(rackup)
end

def clamp
  @options.finalize_values
end

def config_files
  files = @options.all_of(:config_files)
  return [] if files == ['-']
  return files if files.any?
  first_default_file = %W(config/puma/#{@options[:environment]}.rb config/puma.rb).find do |f|
    File.exist?(f)
  end
  [first_default_file]
end

def configure
  yield @user_dsl, @file_dsl, @default_dsl
ensure
  @user_dsl._offer_plugins
  @file_dsl._offer_plugins
  @default_dsl._offer_plugins
end

def environment
  @options[:environment]
end

def final_options
  @options.final_options
end

def flatten
  dup.flatten!
end

def flatten!
  @options = @options.flatten
  self
end

def initialize(user_options={}, default_options = {}, &block)
  default_options = self.puma_default_options.merge(default_options)
  @options     = UserFileDefaultOptions.new(user_options, default_options)
  @plugins     = PluginLoader.new
  @user_dsl    = DSL.new(@options.user_options, self)
  @file_dsl    = DSL.new(@options.file_options, self)
  @default_dsl = DSL.new(@options.default_options, self)
  if !@options[:prune_bundler]
    default_options[:preload_app] = (@options[:workers] > 1) && Puma.forkable?
  end
  if block
    configure(&block)
  end
end

def initialize_copy(other)
  @conf        = nil
  @cli_options = nil
  @options     = @options.dup
end

def load
  config_files.each { |config_file| @file_dsl._load_from(config_file) }
  @options
end

def load_plugin(name)
  @plugins.create name
end

def load_rackup
  raise "Missing rackup file '#{rackup}'" unless File.exist?(rackup)
  rack_app, rack_options = rack_builder.parse_file(rackup)
  rack_options = rack_options || {}
  @options.file_options.merge!(rack_options)
  config_ru_binds = []
  rack_options.each do |k, v|
    config_ru_binds << v if k.to_s.start_with?("bind")
  end
  @options.file_options[:binds] = config_ru_binds unless config_ru_binds.empty?
  rack_app
end

def puma_default_options
  defaults = DEFAULTS.dup
  puma_options_from_env.each { |k,v| defaults[k] = v if v }
  defaults
end

def puma_options_from_env
  min = ENV['PUMA_MIN_THREADS'] || ENV['MIN_THREADS']
  max = ENV['PUMA_MAX_THREADS'] || ENV['MAX_THREADS']
  workers = ENV['WEB_CONCURRENCY']
  {
    min_threads: min && Integer(min),
    max_threads: max && Integer(max),
    workers: workers && Integer(workers),
    environment: ENV['APP_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV'],
  }
end

def rack_builder
  # Load bundler now if we can so that we can pickup rack from
  # a Gemfile
  if ENV.key? 'PUMA_BUNDLER_PRUNED'
    begin
      require 'bundler/setup'
    rescue LoadError
    end
  end
  begin
    require 'rack'
    require 'rack/builder'
  rescue LoadError
    # ok, use builtin version
    return Puma::Rack::Builder
  else
    return ::Rack::Builder
  end
end

def rackup
  @options[:rackup]
end

def run_hooks(key, arg, log_writer, hook_data = nil)
  @options.all_of(key).each do |b|
    begin
      if Array === b
        hook_data[b[1]] ||= Hash.new
        b[0].call arg, hook_data[b[1]]
      else
        b.call arg
      end
    rescue => e
      log_writer.log "WARNING hook #{key} failed with exception (#{e.class}) #{e.message}"
      log_writer.debug e.backtrace.join("\n")
    end
  end
end