module Grape::Validations::Types

def build_coercer(type, method: nil, strict: false)
  cache_instance(type, method, strict) do
    create_coercer_instance(type, method, strict)
  end
end

def cache_instance(type, method, strict, &_block)
  key = cache_key(type, method, strict)
  return @__cache[key] if @__cache.key?(key)
  instance = yield
  @__cache_write_lock.synchronize do
    @__cache[key] = instance
  end
  instance
end

def cache_key(type, method, strict)
  [type, method, strict].each_with_object(+'_') do |val, memo|
    next if val.nil?
    memo << '_' << val.to_s
  end
end

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

def create_coercer_instance(type, method, strict)
  # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
  type = Types.map_special(type)
  # Use a special coercer for multiply-typed parameters.
  if Types.multiple?(type)
    MultipleTypeCoercer.new(type, method)
    # Use a special coercer for custom types and coercion methods.
  elsif method || Types.custom?(type)
    CustomTypeCoercer.new(type, method)
    # Special coercer for collections of types that implement a parse method.
    # CustomTypeCoercer (above) already handles such types when an explicit coercion
    # method is supplied.
  elsif Types.collection_of_custom?(type)
    Types::CustomTypeCollectionCoercer.new(
      Types.map_special(type.first), type.is_a?(Set)
    )
  else
    DryTypeCoercer.coercer_instance_for(type, strict)
  end
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)
  (type.is_a?(Array) || type.is_a?(Set)) && 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