class Solargraph::ApiMap::Store

def domains(fqns)
  result = []
  fqns_pins(fqns).each do |nspin|
    result.concat nspin.domains
  end
  result
end

def extend_references
  @extend_references ||= {}
end

def fqns_pins fqns
  return [] if fqns.nil?
  if fqns.include?('::')
    parts = fqns.split('::')
    name = parts.pop
    base = parts.join('::')
  else
    base = ''
    name = fqns
  end
  namespace_children(base).select{|pin| pin.name == name and pin.kind == Pin::NAMESPACE}
end

def get_class_variables(fqns)
  namespace_children(fqns).select{|pin| pin.kind == Pin::CLASS_VARIABLE}
end

def get_constants fqns, visibility = [:public]
  namespace_children(fqns).select { |pin|
    !pin.name.empty? and (pin.kind == Pin::NAMESPACE or pin.kind == Pin::CONSTANT) and visibility.include?(pin.visibility)
  }
end

def get_extends fqns
  extend_references[fqns] || []
end

def get_includes fqns
  include_references[fqns] || []
end

def get_instance_variables(fqns, scope = :instance)
  namespace_children(fqns).select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context.scope == scope}
end

def get_methods fqns, scope: :instance, visibility: [:public]
  namespace_children(fqns).select{ |pin|
    [Pin::METHOD, Pin::ATTRIBUTE].include?(pin.kind) and (pin.scope == scope or fqns == '') and visibility.include?(pin.visibility)
  }
end

def get_path_pins path
  # return [] if path.nil? # @todo Should be '' instead?
  path ||= ''
  base = path.sub(/(#|\.|::)[a-z0-9_]*(\?|\!)?$/i, '')
  base = '' if base == path
  namespace_children(base).select{ |pin| pin.path == path }
end

def get_superclass fqns
  return superclass_references[fqns].first if superclass_references.has_key?(fqns)
  nil
end

def get_symbols
  symbols.uniq(&:name)
end

def include_references
  @include_references ||= {}
end

def index
  namespace_map.clear
  namespaces.clear
  symbols.clear
  namespace_map[''] = []
  pins.each do |pin|
    namespace_map[pin.namespace] ||= []
    namespace_map[pin.namespace].push pin
    namespaces.add pin.path if pin.kind == Pin::NAMESPACE and !pin.path.empty?
    symbols.push pin if pin.kind == Pin::SYMBOL
    if pin.kind == Pin::INCLUDE_REFERENCE
      include_references[pin.namespace] ||= []
      include_references[pin.namespace].push pin.name
    elsif pin.kind == Pin::EXTEND_REFERENCE
      extend_references[pin.namespace] ||= []
      extend_references[pin.namespace].push pin.name
    elsif pin.kind == Pin::SUPERCLASS_REFERENCE
      superclass_references[pin.namespace] ||= []
      superclass_references[pin.namespace].push pin.name
    end
  end
  @namespace_pins = nil
  @method_pins = nil
end

def initialize pins = []
  @pins = pins
  index
end

def method_pins
  @method_pins ||= pins.select{|p| p.kind == Pin::METHOD or p.kind == Pin::ATTRIBUTE}
end

def namespace_children name
  namespace_map[name] || []
end

def namespace_exists?(fqns)
  fqns_pins(fqns).any?
end

def namespace_map
  @namespace_map ||= {}
end

def namespace_pins
  @namespace_pins ||= pins.select{|p| p.kind == Pin::NAMESPACE}
end

def namespaces
  @namespaces ||= Set.new
end

def superclass_references
  @superclass_references ||= {}
end

def symbols
  @symbols ||= []
end