module Dry::Types

def self.Rule(options)
  rule_compiler.(
    options.map { |key, val|
      ::Dry::Logic::Rule::Predicate.build(
        ::Dry::Logic::Predicates[:"#{key}?"]
      ).curry(val).to_ast
    }
  ).reduce(:and)
end

def self.[](name)
  type_map.fetch_or_store(name) do
    case name
    when ::String
      result = name.match(TYPE_SPEC_REGEX)
      if result
        type_id, member_id = result[1..2]
        container[type_id].of(self[member_id])
      else
        container[name]
      end
    when ::Class
      warn(<<~DEPRECATION)
        Using Dry::Types.[] with a class is deprecated, please use string identifiers: Dry::Types[Integer] -> Dry::Types['integer'].
        If you're using dry-struct this means changing `attribute :counter, Integer` to `attribute :counter, Dry::Types['integer']` or to `attribute :counter, 'integer'`.
      DEPRECATION
      type_name = identifier(name)
      if container.key?(type_name)
        self[type_name]
      else
        name
      end
    end
  end
end

def self.const_missing(const)
  underscored = Types::Inflector.underscore(const)
  if container.keys.any? { |key| key.split(".")[0] == underscored }
    raise ::NameError,
          "dry-types does not define constants for default types. " \
          "You can access the predefined types with [], e.g. Dry::Types['integer'] " \
          "or generate a module with types using Dry.Types()"
  else
    super
  end
end

def self.container
  @container ||= Container.new
end

def self.define_builder(method, &block)
  Builder.define_method(method) do |*args|
    block.(self, *args)
  end
end

def self.identifier(klass)
  Types::Inflector.underscore(klass).tr("/", ".")
end

def self.included(*)
  raise "Import Dry.Types, not Dry::Types"
end

def self.loader
  @loader ||= ::Zeitwerk::Loader.new.tap do |loader|
    root = ::File.expand_path("..", __dir__)
    loader.tag = "dry-types"
    loader.inflector = ::Zeitwerk::GemInflector.new("#{root}/dry-types.rb")
    loader.inflector.inflect("json" => "JSON")
    loader.push_dir(root)
    loader.ignore(
      "#{root}/dry-types.rb",
      "#{root}/dry/types/extensions",
      "#{root}/dry/types/printer",
      "#{root}/dry/types/spec/types.rb",
      "#{root}/dry/types/{#{%w[
        compat
        constraints
        core
        errors
        extensions
        inflector
        module
        json
        params
        printer
        version
      ].join(",")}}.rb"
    )
  end
end

def self.module(*namespaces, default: :nominal, **aliases)
  ::Module.new(container, *namespaces, default: default, **aliases)
end

def self.register(name, type = nil, &block)
  container.register(name, type || block.call)
end

def self.registered?(class_or_identifier)
  container.key?(identifier(class_or_identifier))
end

def self.rule_compiler
  @rule_compiler ||= ::Dry::Logic::RuleCompiler.new(::Dry::Logic::Predicates)
end

def self.type_map
  @type_map ||= ::Concurrent::Map.new
end