class Datadog::Core::Configuration::OptionDefinition::Builder

def after_set(&block)
  @after_set = block
end

def apply_options!(options = {})
  return if options.nil? || options.empty?
  default(options[:default]) if options.key?(:default)
  default_proc(&options[:default_proc]) if options.key?(:default_proc)
  env(options[:env]) if options.key?(:env)
  deprecated_env(options[:deprecated_env]) if options.key?(:deprecated_env)
  env_parser(&options[:env_parser]) if options.key?(:env_parser)
  lazy(options[:lazy]) if options.key?(:lazy)
  after_set(&options[:after_set]) if options.key?(:after_set)
  resetter(&options[:resetter]) if options.key?(:resetter)
  setter(&options[:setter]) if options.key?(:setter)
  type(options[:type], **(options[:type_options] || {})) if options.key?(:type)
end

def default(value = nil, &block)
  @default = block || value
end

def default_proc(&block)
  @default_proc = block
end

def deprecated_env(value)
  @deprecated_env = value
end

def env(value)
  @env = value
end

def env_parser(&block)
  @env_parser = block
end

def helper(name, *_args, &block)
  @helpers[name] = block
end

def initialize(name, options = {})
  @env = nil
  @deprecated_env = nil
  @env_parser = nil
  @default = nil
  @default_proc = nil
  @helpers = {}
  @name = name.to_sym
  @after_set = nil
  @resetter = nil
  @setter = OptionDefinition::IDENTITY
  @type = nil
  @type_options = {}
  # If options were supplied, apply them.
  apply_options!(options)
  # Apply block if given.
  yield(self) if block_given?
  validate_options!
end

def lazy(_value = true)
  Datadog::Core.log_deprecation do
    'Defining an option as lazy is deprecated for removal. Options now always behave as lazy. '\
    "Please remove all references to the lazy setting.\n"\
    'Non-lazy options that were previously stored as blocks are no longer supported. '\
    'If you used this feature, please let us know by opening an issue on: '\
    'https://github.com/datadog/dd-trace-rb/issues/new so we can better understand and support your use case.'
  end
end

def meta
  {
    default: @default,
    default_proc: @default_proc,
    env: @env,
    deprecated_env: @deprecated_env,
    env_parser: @env_parser,
    after_set: @after_set,
    resetter: @resetter,
    setter: @setter,
    type: @type,
    type_options: @type_options
  }
end

def resetter(&block)
  @resetter = block
end

def setter(&block)
  @setter = block
end

def to_definition
  OptionDefinition.new(@name, meta)
end

def type(value, nilable: false)
  @type = value
  @type_options = { nilable: nilable }
  value
end

def validate_options!
  if !@default.nil? && @default_proc
    raise InvalidOptionError,
      'Using `default` and `default_proc` is not allowed. Please use one or the other.' \
                      'If you want to store a block as the default value use `default_proc`'\
                      ' otherwise use `default`'
  end
end