class Dry::Types::PredicateInferrer::Compiler

def infer_predicate(type) # rubocop:disable Metrics/PerceivedComplexity
  pred = TYPE_TO_PREDICATE.fetch(type) do
    if type.name.nil? || self.class.infer_predicate_by_class_name.equal?(false)
      nil
    else
      candidate = :"#{type.name.split("::").last.downcase}?"
      if registry.key?(candidate)
        if self.class.infer_predicate_by_class_name
          candidate
        else
          raise ::KeyError, <<~MESSAGE
            Automatic predicate inferring from class names is deprecated
            and will be removed in dry-types 2.0.
            Use `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name true`
            to restore the previous behavior
            or `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name false`
            to explicitly opt-out (i.e. no exception + no inferring).
            Note: for dry-schema and dry-validation use Dry::Schema::PredicateInferrer::Compiler.
          MESSAGE
        end
      else
        nil
      end
    end
  end
  if pred.nil?
    EMPTY_ARRAY
  else
    [pred]
  end
end

def initialize(registry)
  @registry = registry
end

def merge_predicates(nodes)
  preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
    if predicate.is_a?(::Hash)
      h.update(predicate)
    else
      ps << predicate
    end
  end
  merged.empty? ? preds : [*preds, merged]
end

def visit(node)
  meth, rest = node
  public_send(:"visit_#{meth}", rest)
end

def visit_and(node)
  left, right = node
  visit(left) + visit(right)
end

def visit_any(_) = EMPTY_ARRAY

def visit_array(_)
  ARRAY
end

def visit_constrained(node)
  other, rules = node
  predicates = visit(rules)
  if predicates.empty?
    visit(other)
  else
    [*visit(other), *merge_predicates(predicates)]
  end
end

def visit_constructor(node)
  other, * = node
  visit(other)
end

def visit_enum(node)
  other, * = node
  visit(other)
end

def visit_hash(_)
  HASH
end

def visit_lax(node)
  visit(node)
end

def visit_map(_node)
  raise ::NotImplementedError, "map types are not supported yet"
end

def visit_nominal(node)
  type = node[0]
  predicate = infer_predicate(type)
  if !predicate.empty? && registry.key?(predicate[0])
    predicate
  else
    [type?: type]
  end
end

def visit_predicate(node)
  pred, args = node
  if pred.equal?(:type?) || !registry.key?(pred)
    EMPTY_ARRAY
  else
    *curried, _ = args
    values = curried.map { |_, v| v }
    if values.empty?
      [pred]
    else
      [pred => values[0]]
    end
  end
end

def visit_sum(node)
  left_node, right_node, = node
  left = visit(left_node)
  right = visit(right_node)
  if left.eql?(NIL) # rubocop:disable Lint/DeprecatedConstants
    right
  else
    [[left, right]]
  end
end