class Solargraph::Pin::Base

def == other
  return false unless nearly? other
  comments == other.comments and location == other.location
end

def all_rooted?
  !return_type || return_type.all_rooted?
end

def best_location
  location || type_location
end

def collect_macros
  return [] unless maybe_directives?
  parse = Solargraph::Source.parse_docstring(comments)
  parse.directives.select{ |d| d.tag.tag_name == 'macro' }
end

def comments
  @comments ||= ''
end

def compare_directives dir1, dir2
  return false if dir1.length != dir2.length
  dir1.each_index do |i|
    return false unless compare_tags(dir1[i].tag, dir2[i].tag)
  end
  true
end

def compare_docstring_tags d1, d2
  return false if d1.tags.length != d2.tags.length
  d1.tags.each_index do |i|
    return false unless compare_tags(d1.tags[i], d2.tags[i])
  end
  true
end

def compare_tags tag1, tag2
  tag1.class == tag2.class &&
    tag1.tag_name == tag2.tag_name &&
    tag1.text == tag2.text &&
    tag1.name == tag2.name &&
    tag1.types == tag2.types
end

def completion_item_kind
  LanguageServer::CompletionItemKinds::KEYWORD
end

def deprecated?
  @deprecated ||= docstring.has_tag?('deprecated')
end

def desc
  if path
    if to_rbs
      path + ' ' + to_rbs
    else
      path
    end
  else
    to_rbs
  end
end

def directives
  parse_comments unless defined?(@directives)
  @directives
end

def docstring
  parse_comments unless defined?(@docstring)
  @docstring ||= Solargraph::Source.parse_docstring('').to_docstring
end

def erase_generics(generics_to_erase)
  return self if generics_to_erase.empty?
  transform_types { |t| t.erase_generics(generics_to_erase) }
end

def filename
  return nil if location.nil?
  location.filename
end

def identity
  @identity ||= "#{closure.path}|#{name}"
end

def infer api_map
  Solargraph::Logging.logger.warn "WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead."
  type = typify(api_map)
  return type unless type.undefined?
  probe api_map
end

def initialize location: nil, type_location: nil, closure: nil, name: '', comments: ''
  @location = location
  @type_location = type_location
  @closure = closure
  @name = name
  @comments = comments
end

def inspect
  "#<#{self.class} `#{self.desc}` at #{self.location.inspect}>"
end

def macros
  @macros ||= collect_macros
end

def maybe_directives?
  return !@directives.empty? if defined?(@directives)
  @maybe_directives ||= comments.include?('@!')
end

def nearly? other
  self.class == other.class &&
    name == other.name &&
    (closure == other.closure || (closure && closure.nearly?(other.closure))) &&
    (comments == other.comments ||
      (((maybe_directives? == false && other.maybe_directives? == false) || compare_directives(directives, other.directives)) &&
      compare_docstring_tags(docstring, other.docstring))
    )
end

def parse_comments
  # HACK: Avoid a NoMethodError on nil with empty overload tags

  if comments.nil? || comments.empty? || comments.strip.end_with?('@overload')
    @docstring = nil
    @directives = []
  else
    # HACK: Pass a dummy code object to the parser for plugins that

    # expect it not to be nil

    parse = Solargraph::Source.parse_docstring(comments)
    @docstring = parse.to_docstring
    @directives = parse.directives
  end
end

def probe api_map
  typify api_map
end

def probed?
  @probed ||= false
end

def proxied?
  @proxied ||= false
end

def proxy return_type
  result = dup
  result.return_type = return_type
  result.proxied = true
  result
end

def realize api_map
  return self if return_type.defined?
  type = typify(api_map)
  return proxy(type) if type.defined?
  type = probe(api_map)
  return self if type.undefined?
  result = proxy(type)
  result.probed = true
  result
end

def resolve_generics definitions, context_type
  transform_types { |t| t.resolve_generics(definitions, context_type) if t }
end

def resolve_generics_from_context(generics_to_resolve, return_type_context = nil, resolved_generic_values: {})
  proxy return_type.resolve_generics_from_context(generics_to_resolve,
                                                  return_type_context,
                                                  resolved_generic_values: resolved_generic_values)
end

def return_type
  @return_type ||= ComplexType::UNDEFINED
end

def symbol_kind
  nil
end

def to_rbs
  return_type.to_rbs
end

def to_s
  to_rbs
end

def transform_types(&transform)
  proxy return_type.transform(&transform)
end

def try_merge! pin
  return false unless nearly?(pin)
  @location = pin.location
  @closure = pin.closure
  return true if comments == pin.comments
  @comments = pin.comments
  @docstring = pin.docstring
  @return_type = pin.return_type
  @documentation = nil
  @deprecated = nil
  reset_conversions
  true
end

def typify api_map
  return_type.qualify(api_map, namespace)
end

def variable?
  false
end