module Grape::Validations::Types

def array_or_set?(type)
  type.is_a?(Array) || type.is_a?(Set)
end

def build_coercer(type, method: nil, strict: false)
  # no cache since unique
  return create_coercer_instance(type, method, strict) if method.respond_to?(:call)
  CoercerCache[[type, method, strict]]
end

def collection_of_custom?(type)
  array_or_set?(type) && type.length == 1 && (custom?(type.first) || special?(type.first))
end

def create_coercer_instance(type, method, strict)
  # map_special doesn't recurse into collections — applied only to the top-level type here.
  type = map_special(type)
  # Multiply-typed parameters, e.g. types: [Integer, String].
  return MultipleTypeCoercer.new(type, method) if multiple?(type)
  # User-supplied coercion method, or a custom type with its own #parse.
  return CustomTypeCoercer.new(type, method) if method || custom?(type)
  # Array/Set of a custom type — CustomTypeCoercer already handles single
  # custom types when an explicit coercion method is supplied.
  return CustomTypeCollectionCoercer.new(map_special(type.first), set: type.is_a?(Set)) if collection_of_custom?(type)
  # Fallback: let dry-types handle primitives, structures, and known specials.
  DryTypeCoercer.coercer_instance_for(type, strict:)
end

def custom?(type)
  !(primitive?(type) || structure?(type) || multiple?(type)) &&
    type.respond_to?(:parse) && type.method(:parse).arity == 1
end

def group?(type)
  GROUPS.include? type
end

def map_special(type)
  SPECIAL.fetch(type, type)
end

def multiple?(type)
  array_or_set?(type) && type.size > 1
end

def primitive?(type)
  PRIMITIVES.include?(type)
end

def special?(type)
  SPECIAL.key? type
end

def structure?(type)
  STRUCTURES.include?(type)
end