class Dry::Schema::Macros::DSL

def append_macro(macro_type)
  macro = macro_type.new(schema_dsl: schema_dsl, name: name)
  yield(macro)
  if chain
    trace << macro
    self
  else
    macro
  end
end

def array(*args, &block)
  append_macro(Macros::Array) do |macro|
    macro.value(*args, &block)
  end
end

def custom_type?
  schema_dsl.custom_type?(name)
end

def each(*args, &block)
  append_macro(Macros::Each) do |macro|
    macro.value(*args, &block)
  end
end

def extract_type_spec(*args, nullable: false, set_type: true)
  type_spec = args[0] unless schema_or_predicate?(args[0])
  predicates = Array(type_spec ? args[1..-1] : args)
  type_rule = nil
  if type_spec
    resolved_type = resolve_type(type_spec, nullable)
    if type_spec.is_a?(::Array)
      type_rule = type_spec.map { |ts| new(chain: false).value(ts) }.reduce(:|)
    else
      type_predicates = predicate_inferrer[resolved_type]
      predicates.replace(type_predicates + predicates) unless type_predicates.empty?
      return self if predicates.empty?
    end
  end
  type(resolved_type) if set_type && resolved_type
  if type_rule
    yield(*predicates, type_spec: nil, type_rule: type_rule)
  else
    yield(*predicates, type_spec: type_spec, type_rule: nil)
  end
end

def filled(*args, &block)
  append_macro(Macros::Filled) do |macro|
    macro.call(*args, &block)
  end
end

def hash(*args, &block)
  append_macro(Macros::Hash) do |macro|
    macro.call(*args, &block)
  end
end

def resolve_type(type_spec, nullable)
  resolved = schema_dsl.resolve_type(type_spec)
  if type_spec.is_a?(::Array) || !nullable || resolved.optional?
    resolved
  else
    schema_dsl.resolve_type([:nil, resolved])
  end
end

def schema(*args, &block)
  append_macro(Macros::Schema) do |macro|
    macro.call(*args, &block)
  end
end

def schema_or_predicate?(arg)
  arg.is_a?(Dry::Schema::Processor) ||
    arg.is_a?(Symbol) &&
      arg.to_s.end_with?(QUESTION_MARK)
end

def type(spec)
  schema_dsl.set_type(name, spec)
  self
end

def value(*predicates, &block)
  append_macro(Macros::Value) do |macro|
    macro.call(*predicates, &block)
  end
end