module Dry::Core::Container::Mixin

def self.extended(base)
  hooks_mod = ::Module.new do
    def inherited(subclass)
      subclass.instance_variable_set(:@_container, @_container.dup)
      super
    end
  end
  base.class_eval do
    extend Configuration
    extend hooks_mod
    @_container = ::Concurrent::Hash.new
  end
end

def self.included(base)
  base.class_eval do
    extend Configuration
    prepend Initializer
    def config
      self.class.config
    end
  end
end

def [](key)
  resolve(key)
end

def _container
  @_container
end

def clone
  copy = super
  unless copy.frozen?
    copy.instance_variable_set(:@_container, _container.dup)
  end
  copy
end

def config
  self.class.config
end

def decorate(key, with: nil, &block)
  key = key.to_s
  original = _container.delete(key) do
    raise KeyError, "Nothing registered with the key #{key.inspect}"
  end
  if with.is_a?(Class)
    decorator = with.method(:new)
  elsif block.nil? && !with.respond_to?(:call)
    raise Error, "Decorator needs to be a Class, block, or respond to the `call` method"
  else
    decorator = with || block
  end
  _container[key] = original.map(decorator)
  self
end

def dup
  copy = super
  copy.instance_variable_set(:@_container, _container.dup)
  copy
end

def each(&)
  config.resolver.each(_container, &)
end

def each_key(&)
  config.resolver.each_key(_container, &)
  self
end

def enable_stubs!
  extend ::Dry::Core::Container::Stub
end

def freeze
  super
  _container.freeze
  self
end

def import(namespace)
  namespace(namespace.name, &namespace.block)
  self
end

def inherited(subclass)
  subclass.instance_variable_set(:@_container, @_container.dup)
  super
end

def key?(key)
  config.resolver.key?(_container, key)
end

def keys
  config.resolver.keys(_container)
end

def merge(other, namespace: nil, &block)
  if namespace
    _container.merge!(
      other._container.each_with_object(::Concurrent::Hash.new) { |(key, item), hsh|
        hsh[PREFIX_NAMESPACE.call(namespace, key, config)] = item
      },
      &block
    )
  else
    _container.merge!(other._container, &block)
  end
  self
end

def namespace(namespace, &)
  ::Dry::Core::Container::NamespaceDSL.new(
    self,
    namespace,
    config.namespace_separator,
    &
  )
  self
end

def register(key, contents = nil, options = EMPTY_HASH, &block)
  if block_given?
    item = block
    options = contents if contents.is_a?(::Hash)
  else
    item = contents
  end
  config.registry.call(_container, key, item, options)
  self
rescue ::FrozenError
  raise ::FrozenError,
        "can't modify frozen #{self.class} (when attempting to register '#{key}')"
end

def resolve(key, &)
  config.resolver.call(_container, key, &)
end