class Dry::Schema::Trace

def append(op)
  captures << op
  self
end

def class
  ::Dry::Schema::Trace
end

def evaluate(*predicates, **opts)
  pred_opts = opts.dup
  pred_opts.delete(:type_spec)
  predicates.each do |predicate|
    if predicate.respond_to?(:call)
      append(predicate)
    elsif predicate.is_a?(::Hash)
      evaluate_hash_predicates(predicate)
    elsif predicate.is_a?(::Array)
      append(predicate.map { |pred| __send__(pred) }.reduce(:|))
    else
      append(__send__(predicate))
    end
  end
  evaluate_hash_predicates(pred_opts)
  self
end

def evaluate_hash_predicates(predicates)
  predicates.each do |predicate, *args|
    append(__send__(predicate, *args))
  end
  self
end

def initialize(compiler = Compiler.new)
  @compiler = compiler
  @captures = []
end

def method_missing(meth, *args, &block)
  if meth.to_s.end_with?(QUESTION_MARK)
    if ::Dry::Schema::Trace::INVALID_PREDICATES.include?(meth)
      ::Kernel.raise InvalidSchemaError, "#{meth} predicate cannot be used in this context"
    end
    unless compiler.supports?(meth)
      ::Kernel.raise ::ArgumentError, "#{meth} predicate is not defined"
    end
    predicate = Predicate.new(compiler, meth, args, block)
    predicate.ensure_valid
    predicate
  else
    super
  end
end

def reduced_rule
  captures.map(&:to_ast).map(&compiler.method(:visit)).reduce(:and)
end

def to_ast
  reduced_rule.to_ast
end

def to_rule(name = nil)
  return if captures.empty?
  if name
    compiler.visit([:key, [name, to_ast]])
  else
    reduced_rule
  end
end