module Dry::Configurable

def self.extended(base)
  base.class_eval do
    @_config_mutex = ::Mutex.new
    @_settings = ::Concurrent::Array.new
    @_reader_attributes = ::Concurrent::Array.new
  end
end

def _config_for(&block)
  ::Dry::Configurable::NestedConfig.new(&block)
end

def _reader_attributes
  @_reader_attributes
end

def _settings
  @_settings
end

def config
  return @_config if defined?(@_config)
  create_config
end

def configure
  raise_frozen_config if frozen?
  yield(config) if block_given?
end

def create_config
  @_config_mutex.synchronize do
    create_config_for_nested_configurations
    @_config = ::Dry::Configurable::Config.create(_settings) unless _settings.empty?
  end
end

def create_config_for_nested_configurations
  nested_configs.map(&:create_config)
end

def enable_test_interface
  extend Dry::Configurable::TestInterface
end

def finalize!
  freeze
  config.finalize!
end

def inherited(subclass)
  subclass.instance_variable_set(:@_config_mutex, ::Mutex.new)
  subclass.instance_variable_set(:@_settings, @_settings.clone)
  subclass.instance_variable_set(:@_reader_attributes, @_reader_attributes.clone)
  subclass.instance_variable_set(:@_config, @_config.clone) if defined?(@_config)
  super
end

def method_missing(method, *args, &block)
  _reader_attributes.include?(method) ? config.public_send(method, *args, &block) : super
end

def nested_configs
  _settings.select { |setting| setting.value.is_a?(::Dry::Configurable::NestedConfig) }.map(&:value)
end

def raise_already_defined_config(key)
  raise AlreadyDefinedConfig,
        "Cannot add setting +#{key}+, #{self} is already configured"
end

def raise_frozen_config
  raise FrozenConfig, 'Cannot modify frozen config'
end

def respond_to_missing?(method, _include_private = false)
  _reader_attributes.include?(method) || super
end

def setting(key, *args, &block)
  raise_already_defined_config(key) if defined?(@_config)
  value, options = ArgumentParser.call(args)
  if block
    if block.parameters.empty?
      value = _config_for(&block)
    else
      processor = block
    end
  end
  _settings << ::Dry::Configurable::Config::Value.new(
    key,
    !value.nil? ? value : ::Dry::Configurable::Config::Value::NONE,
    processor || ::Dry::Configurable::Config::DEFAULT_PROCESSOR
  )
  store_reader_options(key, options) if options.any?
end

def settings
  _settings.map(&:name)
end

def store_reader_options(key, options)
  _reader_attributes << key if options.fetch(:reader, false)
end