class Dry::Types::Hash

def instantiate(member_types)
  SCHEMA_BUILDER.instantiate(primitive, **options, member_types: member_types)
end

def map(key_type, value_type)
  Map.new(
    primitive,
    key_type: resolve_type(key_type),
    value_type: resolve_type(value_type),
    meta: meta
  )
end

def permissive(type_map)
  schema(type_map, :permissive)
end

def resolve_type(type)
  case type
  when String, Class then Types[type]
  else type
  end
end

def schema(type_map, constructor = nil)
  member_types = transform_types(type_map)
  if constructor.nil?
    Schema.new(primitive, member_types: member_types, **options, meta: meta)
  else
    SCHEMA_BUILDER.(
      primitive,
      **options,
      member_types: member_types,
      meta: meta,
      hash_type: constructor
    )
  end
end

def strict(type_map)
  schema(type_map, :strict)
end

def strict_with_defaults(type_map)
  schema(type_map, :strict_with_defaults)
end

def symbolized(type_map)
  schema(type_map, :symbolized)
end

def transform_types(type_map)
  type_fn = meta.fetch(:type_transform_fn, Schema::NO_TRANSFORM)
  type_transform = Dry::Types::FnContainer[type_fn]
  type_map.each_with_object({}) { |(name, type), result|
    result[name] = type_transform.(
      resolve_type(type),
      name
    )
  }
end

def weak(type_map)
  schema(type_map, :weak)
end

def with_type_transform(proc = nil, &block)
  fn = proc || block
  if fn.nil?
    raise ArgumentError, "a block or callable argument is required"
  end
  handle = Dry::Types::FnContainer.register(fn)
  meta(type_transform_fn: handle)
end