class Dry::Schema::DSL

def self.new(**options, &block)
  dsl = super
  dsl.instance_eval(&block) if block
  dsl
end

def array
  -> member_type { type_registry['array'].of(resolve_type(member_type)) }
end

def call
  steps = [key_coercer]
  steps << filter_schema.rule_applier if filter_rules?
  steps << value_coercer << rule_applier
  processor_type.new { |processor| steps.each { |step| processor << step } }
end

def configure(&block)
  config.configure(&block)
  self
end

def filter_rules?
  instance_variable_defined?('@__filter_schema__') && !filter_schema.macros.empty?
end

def filter_schema
  @__filter_schema__ ||= new
end

def key(name, macro:, &block)
  raise ArgumentError, "Key +#{name}+ is not a symbol" unless name.is_a?(::Symbol)
  set_type(name, Types::Any)
  macro = macro.new(
    name: name,
    compiler: compiler,
    schema_dsl: self,
    filter_schema: filter_schema
  )
  macro.value(&block) if block
  macros << macro
  macro
end

def key_coercer
  KeyCoercer.symbolized(key_map + parent_key_map)
end

def key_map(types = self.types)
  keys = types.map { |key, type| key_spec(key, type) }
  km = KeyMap.new(keys)
  if key_map_type
    km.public_send(key_map_type)
  else
    km
  end
end

def key_map_type
  processor_type.config.key_map_type
end

def key_spec(name, type)
  if type.respond_to?(:keys)
    { name => key_map(type.name_key_map) }
  elsif type.respond_to?(:member)
    kv = key_spec(name, type.member)
    kv.equal?(name) ? name : kv.flatten(1)
  else
    name
  end
end

def new(&block)
  self.class.new(processor_type: processor_type, &block)
end

def optional(name, &block)
  key(name, macro: Macros::Optional, &block)
end

def parent_key_map
  parent&.key_map || EMPTY_ARRAY
end

def parent_rules
  parent&.rules || EMPTY_HASH
end

def required(name, &block)
  key(name, macro: Macros::Required, &block)
end

def resolve_type(spec)
  case spec
  when ::Dry::Types::Type then spec
  when ::Array then spec.map { |s| resolve_type(s) }.reduce(:|)
  else
    type_registry[spec]
  end
end

def rule_applier
  RuleApplier.new(rules, config: config)
end

def rules
  parent_rules.merge(macros.map { |m| [m.name, m.to_rule] }.to_h.compact)
end

def set_type(name, spec)
  type = resolve_type(spec)
  meta = { required: false, maybe: type.optional? }
  types[name] = type.meta(meta)
end

def to_rule
  call.to_rule
end

def type_registry
  processor_type.config.type_registry
end

def type_schema
  if parent
    parent.type_schema.schema(types)
  else
    type_registry['hash'].schema(types).lax
  end
end

def value_coercer
  ValueCoercer.new(type_schema)
end