class Dry::Types::Schema

def apply(hash, options = EMPTY_HASH) = call_unsafe(hash, options)

def call_safe(hash, options = EMPTY_HASH)
  resolve_safe(coerce(hash) { return yield }, options) { return yield }
end

def call_unsafe(hash, options = EMPTY_HASH)
  resolve_unsafe(coerce(hash), options)
end

def clear
  with(keys: EMPTY_ARRAY)
end

def constrained?
  true
end

def each(&)
  keys.each(&)
end

def initialize(_primitive, **options)
  @keys = options.fetch(:keys)
  @name_key_map = keys.each_with_object({}) do |key, idx|
    idx[key.name] = key
  end
  key_fn = options.fetch(:key_transform_fn, NO_TRANSFORM)
  @transform_key = ::Dry::Types::FnContainer[key_fn]
  super
end

def key(name, fallback = Undefined, &)
  if Undefined.equal?(fallback)
    name_key_map.fetch(name, &)
  else
    name_key_map.fetch(name, fallback)
  end
end

def key?(name)
  name_key_map.key?(name)
end

def lax
  Lax.new(schema(keys.map(&:lax)))
end

def merge(other)
  schema(other.keys)
end

def merge_keys(*keys)
  keys
    .flatten(1)
    .each_with_object({}) { |key, merged| merged[key.name] = key }
    .values
end

def missing_key(key)
  MissingKeyError.new(key)
end

def resolve_missing_keys(hash, options) # rubocop:disable Metrics/PerceivedComplexity
  skip_missing = options.fetch(:skip_missing, false)
  resolve_defaults = options.fetch(:resolve_defaults, true)
  keys.each do |key|
    next if hash.key?(key.name)
    if key.default? && resolve_defaults
      hash[key.name] = key.call_unsafe(Undefined)
    elsif key.required? && !skip_missing
      if block_given?
        return yield
      else
        raise missing_key(key.name)
      end
    end
  end
end

def resolve_safe(hash, options = EMPTY_HASH, &block)
  result = {}
  hash.each do |key, value|
    k = @transform_key.(key)
    type = @name_key_map[k]
    if type
      result[k] = type.call_safe(value, &block)
    elsif strict?
      yield
    end
  end
  resolve_missing_keys(result, options, &block) if result.size < keys.size
  result
end

def resolve_unsafe(hash, options = EMPTY_HASH)
  result = {}
  hash.each do |key, value|
    k = @transform_key.(key)
    type = @name_key_map[k]
    if type
      begin
        result[k] = type.call_unsafe(value)
      rescue ConstraintError => e
        raise SchemaError.new(type.name, value, e.result)
      rescue CoercionError => e
        raise SchemaError.new(type.name, value, e.message)
      end
    elsif strict?
      raise unexpected_keys(hash.keys)
    end
  end
  resolve_missing_keys(result, options) if result.size < keys.size
  result
end

def schema(keys_or_map)
  if keys_or_map.is_a?(::Array)
    new_keys = keys_or_map
  else
    new_keys = build_keys(keys_or_map)
  end
  keys = merge_keys(self.keys, new_keys)
  Schema.new(primitive, **options, keys: keys, meta: meta)
end

def strict(strict = true) # rubocop:disable Style/OptionalBooleanParameter
  with(strict: strict)
end

def strict?
  options.fetch(:strict, false)
end

def to_ast(meta: true)
  [
    :schema,
    [keys.map { |key| key.to_ast(meta: meta) },
     options.slice(:key_transform_fn, :type_transform_fn, :strict),
     meta ? self.meta : EMPTY_HASH]
  ]
end

def transform_keys?
  !options[:key_transform_fn].nil?
end

def try(input)
  if primitive?(input)
    success = true
    output = {}
    result = {}
    input.each do |key, value|
      k = @transform_key.(key)
      type = @name_key_map[k]
      if type
        key_result = type.try(value)
        result[k] = key_result
        output[k] = key_result.input
        success &&= key_result.success?
      elsif strict?
        success = false
      end
    end
    if output.size < keys.size
      resolve_missing_keys(output, options) do
        success = false
      end
    end
    success &&= primitive?(output)
    if success
      failure = nil
    else
      error = CoercionError.new("#{input} doesn't conform schema", meta: result)
      failure = failure(output, error)
    end
  else
    failure = failure(input, CoercionError.new("#{input} must be a hash"))
  end
  if failure.nil?
    success(output)
  elsif block_given?
    yield(failure)
  else
    failure
  end
end

def unexpected_keys(hash_keys)
  extra_keys = hash_keys.map(&transform_key) - name_key_map.keys
  UnknownKeysError.new(extra_keys)
end

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