class Solargraph::Pin::Callable

# File lib/solargraph/pin/callable.rb, line 17
def initialize block: nil, return_type: nil, parameters: [], **splat
  super(**splat)
  @block = block
  @return_type = return_type
  @parameters = parameters
end

# File lib/solargraph/pin/callable.rb, line 93
def arity
  [generics, blockless_parameters.map(&:arity_decl), block&.arity]
end

# File lib/solargraph/pin/callable.rb, line 204
def arity_matches? arguments, with_block
  argcount = arguments.length
  parcount = mandatory_positional_param_count
  parcount -= 1 if !parameters.empty? && parameters.last.block?
  return false if block? && !with_block
  return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
  true
end

# File lib/solargraph/pin/callable.rb, line 222
def block?
  !!@block
end

# File lib/solargraph/pin/callable.rb, line 84
def blockless_parameters
  if parameters.last&.block?
    parameters[0..-2]
  else
    parameters
  end
end

# File lib/solargraph/pin/callable.rb, line 68
def choose_parameters(other)
  raise "Trying to combine two pins with different arities - \nself =#{inspect}, \nother=#{other.inspect}, \n\n self.arity=#{self.arity}, \nother.arity=#{other.arity}" if other.arity != arity
  # @param param [Pin::Parameter]
  # @param other_param [Pin::Parameter]
  parameters.zip(other.parameters).map do |param, other_param|
    if param.nil? && other_param.block?
      other_param
    elsif other_param.nil? && param.block?
      param
    else
      param.combine_with(other_param)
    end
  end
end

# File lib/solargraph/pin/callable.rb, line 32
def combine_blocks(other)
  if block.nil?
    other.block
  elsif other.block.nil?
    block
  else
    # @type [Pin::Signature, nil]
    choose_pin_attr(other, :block)
  end
end

# File lib/solargraph/pin/callable.rb, line 47
def combine_with(other, attrs={})
  new_attrs = {
    block: combine_blocks(other),
    return_type: combine_return_type(other),
  }.merge(attrs)
  new_attrs[:parameters] = choose_parameters(other).clone.freeze unless new_attrs.key?(:parameters)
  super(other, new_attrs)
end

# File lib/solargraph/pin/callable.rb, line 61
def generics
  []
end

# File lib/solargraph/pin/callable.rb, line 214
def mandatory_positional_param_count
  parameters.count(&:arg?)
end

# File lib/solargraph/pin/callable.rb, line 141
def method_name
  raise "closure was nil in #{self.inspect}" if closure.nil?
  @method_name ||= closure.name
end

# File lib/solargraph/pin/callable.rb, line 25
def method_namespace
  closure.namespace
end

# File lib/solargraph/pin/callable.rb, line 57
def parameter_names
  @parameter_names ||= parameters.map(&:name)
end

# File lib/solargraph/pin/callable.rb, line 105
def resolve_generics_from_context(generics_to_resolve,
                                  arg_types = nil,
                                  return_type_context = nil,
                                  yield_arg_types = nil,
                                  yield_return_type_context = nil,
                                  resolved_generic_values: {})
  callable = super(generics_to_resolve, return_type_context, resolved_generic_values: resolved_generic_values)
  callable.parameters = callable.parameters.each_with_index.map do |param, i|
    if arg_types.nil?
      param.dup
    else
      param.resolve_generics_from_context(generics_to_resolve,
                                          arg_types[i],
                                          resolved_generic_values: resolved_generic_values)
    end
  end
  callable.block = block.resolve_generics_from_context(generics_to_resolve,
                                                        yield_arg_types,
                                                        yield_return_type_context,
                                                        resolved_generic_values: resolved_generic_values) if callable.block?
  callable
end

# File lib/solargraph/pin/callable.rb, line 154
def resolve_generics_from_context_until_complete(generics_to_resolve,
                                                 arg_types = nil,
                                                 return_type_context = nil,
                                                 yield_arg_types = nil,
                                                 yield_return_type_context = nil,
                                                 resolved_generic_values: {})
  # See
  # https://github.com/soutaro/steep/tree/master/lib/steep/type_inference
  # and
  # https://github.com/sorbet/sorbet/blob/master/infer/inference.cc
  # for other implementations

  return self if generics_to_resolve.empty?

  last_resolved_generic_values = resolved_generic_values.dup
  new_pin = resolve_generics_from_context(generics_to_resolve,
                                          arg_types,
                                          return_type_context,
                                          yield_arg_types,
                                          yield_return_type_context,
                                          resolved_generic_values: resolved_generic_values)
  if last_resolved_generic_values == resolved_generic_values
    # erase anything unresolved
    return new_pin.erase_generics(self.generics)
  end
  new_pin.resolve_generics_from_context_until_complete(generics_to_resolve,
                                                       arg_types,
                                                       return_type_context,
                                                       yield_arg_types,
                                                       yield_return_type_context,
                                                       resolved_generic_values: resolved_generic_values)
end

# File lib/solargraph/pin/callable.rb, line 218
def to_rbs
  rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ') + '-> ' + return_type.to_rbs
end

# File lib/solargraph/pin/callable.rb, line 191
def transform_types(&transform)
  # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
  callable = super(&transform)
  callable.block = block.transform_types(&transform) if block?
  callable.parameters = parameters.map do |param|
    param.transform_types(&transform)
  end
  callable
end

# File lib/solargraph/pin/callable.rb, line 128
def typify api_map
  type = super
  return type if type.defined?
  if method_name.end_with?('?')
    logger.debug { "Callable#typify(self=#{self}) => Boolean (? suffix)" }
    ComplexType::BOOLEAN
  else
    logger.debug { "Callable#typify(self=#{self}) => undefined" }
    ComplexType::UNDEFINED
  end
end