module T::Utils

def self.arity(method)
  arity = method.arity
  return arity if arity != -1 || method.is_a?(Proc)
  sig = T::Private::Methods.signature_for_method(method)
  sig ? sig.method.arity : arity
end

def self.check_type_recursive!(value, type)
  T::Private::Casts.cast_recursive(value, type, "T.check_type_recursive!")
end

def self.coerce(val)
  Private.coerce_and_check_module_types(val, nil, false)
end

def self.lift_enum(enum)
  unless enum.is_a?(T::Types::Enum)
    raise ArgumentError.new("#{enum.inspect} is not a T.deprecated_enum")
  end
  classes = enum.values.map(&:class).uniq
  if classes.empty?
    T.untyped
  elsif classes.length > 1
    T::Types::Union.new(classes)
  else
    T::Types::Simple::Private::Pool.type_for_module(classes.first)
  end
end

def self.methods_excluding_object(mod)
  # We can't just do mod.instance_methods - Object.instance_methods, because that would leave out
  # any methods from Object that are overridden in mod.
  mod.ancestors.flat_map do |ancestor|
    # equivalent to checking Object.ancestors.include?(ancestor)
    next [] if Object <= ancestor
    ancestor.instance_methods(false) + ancestor.private_instance_methods(false)
  end.uniq
end

def self.resolve_alias(type)
  case type
  when T::Private::Types::TypeAlias
    type.aliased_type
  else
    type
  end
end

def self.run_all_sig_blocks
  T::Private::Methods.run_all_sig_blocks
end

def self.signature_for_instance_method(mod, method_name)
  T::Private::Methods.signature_for_method(mod.instance_method(method_name))
end

def self.signature_for_method(method)
  T::Private::Methods.signature_for_method(method)
end

def self.string_truncate_middle(str, start_len, end_len, ellipsis='...')
  return unless str
  raise ArgumentError.new('must provide start_len') unless start_len
  raise ArgumentError.new('must provide end_len') unless end_len
  raise ArgumentError.new('start_len must be >= 0') if start_len < 0
  raise ArgumentError.new('end_len must be >= 0') if end_len < 0
  str = str.to_s
  return str if str.length <= start_len + end_len
  start_part = str[0...start_len - ellipsis.length]
  end_part = end_len == 0 ? '' : str[-end_len..-1]
  "#{start_part}#{ellipsis}#{end_part}"
end

def self.unwrap_nilable(type)
  case type
  when T::Types::Union
    type.unwrap_nilable
  else
    nil
  end
end

def self.wrap_method_with_call_validation_if_needed(mod, method_sig, original_method)
  T::Private::Methods::CallValidation.wrap_method_if_needed(mod, method_sig, original_method)
end