class Dry::Schema::Trace

def append(op)
  captures << op
  self
end

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

def evaluate(*args, **opts)
  predicates = opts.empty? ? args : args.push(opts)
  evaluate_predicates(predicates).each do |rule|
    append(rule)
  end
  self
end

def evaluate_predicates(predicates)
  predicates.flat_map do |predicate|
    if predicate.respond_to?(:call)
      predicate
    elsif predicate.is_a?(::Array)
      predicate.map { |pred| evaluate_predicates(pred).reduce(:&) }.reduce(:|)
    elsif predicate.is_a?(::Hash)
      predicate.map { |pred, *args| __send__(pred, *args) }
    else
      __send__(predicate)
    end
  end
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