class ArchSpec::Facts::Builder

# File lib/archspec/facts/builder.rb, line 26
def initialize(graph, producer:)
  @graph = graph
  @producer = producer.to_s
  @entries = LIST_KEYS.to_h { |key| [key, []] }
end

# File lib/archspec/facts/builder.rb, line 118
def apply
  document = Document.new(@graph, facts, @producer)
  Application.apply(@graph, [document.compile.with(producer: nil)])
end

# File lib/archspec/facts/builder.rb, line 76
def bind_receiver(edge:, receiver:, scope:)
  source = @graph.constants_named(edge.from_constant).find { |node| node.path == edge.from_path }
  raise Error, 'receiver fact requires a call owned by an analyzed constant' unless source

  add('receivers', entry_for(source, edge.location).merge('source' => source.name,
    'name' => edge.to, 'receiver' => name_of(receiver), 'scope' => scope.to_s))
end

# File lib/archspec/facts/builder.rb, line 142
def count(key)
  @entries.fetch(key.to_s).size
end

# File lib/archspec/facts/builder.rb, line 84
def expose_methods(source:, owner:, scope:)
  source = constant(source, nil)
  entry = entry_for(source, source.location).merge('source' => source.name,
    'owner' => name_of(owner), 'scope' => scope.to_s)
  owners = @graph.constants_named(name_of(owner)).map { |node| relative(node.path) }.uniq - [entry['source_path']]
  entry['depends_on'] = owners.sort unless owners.empty?
  add('exposures', entry)
end

# File lib/archspec/facts/builder.rb, line 93
def gap(source:, message:, location:)
  location = location_of(location)
  source = constant(source, location)
  add('gaps', entry_for(source, location).merge('source' => source.name, 'message' => message))
end

# File lib/archspec/facts/builder.rb, line 60
def method_definition(owner:, definition:, installation: nil)
  methods(owner: owner, names: [definition.name], scope: definition.scope, location: definition.location,
    visibility: definition.visibility, signatures: definition.signatures, alias_target: definition.alias_target,
    mode: installation ? :define : :append, installation: installation)
end

# File lib/archspec/facts/builder.rb, line 38
def methods(owner:, names:, location:, scope: :instance, visibility: :public,
            signatures: [], alias_target: nil, mode: :if_missing, installation: nil)
  unless alias_target.nil? || alias_target.is_a?(String) || alias_target.is_a?(Symbol)
    raise Error, 'alias target must be a String or Symbol'
  end
  location = location_of(location)
  owner = constant(owner, location)
  entry = entry_for(owner, location).merge('owner' => owner.name, 'names' => Array(names).map(&:to_s),
    'scope' => scope.to_s, 'visibility' => visibility.to_s, 'mode' => mode.to_s,
    'signatures' => signatures.map do |signature|
      signature.to_h.transform_keys(&:to_s).transform_values do |value|
        value.is_a?(Array) ? value.map(&:to_s) : value
      end
    end)
  entry['alias_target'] = alias_target.to_s unless alias_target.nil?
  entry['installation'] = location_for(location_of(installation)) if installation
  add('methods', entry)
end

# File lib/archspec/facts/builder.rb, line 67
def mixin(owner:, target:, kind:, location:)
  location = location_of(location)
  owner = constant(owner, location)
  add('mixins', entry_for(owner, location).merge('owner' => owner.name,
    'target' => name_of(target), 'kind' => kind.to_s))
end

# File lib/archspec/facts/builder.rb, line 32
def reference(source:, target:, location:)
  location = location_of(location)
  source = constant(source, location)
  add('references', entry_for(source, location).merge('source' => source.name, 'target' => name_of(target)))
end

# File lib/archspec/facts/builder.rb, line 104
def resolve(source:, location:, message: nil, consumers: nil)
  location = location_of(location)
  source = constant(source, location)
  entry = entry_for(source, location).merge('source' => source.name)
  entry['message'] = message if message
  if consumers
    nodes = consumers.map { |consumer| constant(consumer, nil) }
    entry['consumers'] = nodes.map(&:name).uniq.sort
    paths = nodes.map { |node| relative(node.path) }.uniq - [entry['source_path'], entry['path']]
    entry['depends_on'] = paths.sort unless paths.empty?
  end
  add('resolves', entry)
end

# File lib/archspec/facts/builder.rb, line 128
def to_document(facts_path: 'archspec_facts', inputs: DEFAULT_INPUTS, sources: [], env: {})
  cited = @entries.values.flatten.flat_map do |entry|
    [entry['path'], entry['source_path'], entry.dig('installation', 'path'), *entry['depends_on']]
  end.compact.uniq.map { |path| File.expand_path(path, @graph.root) }
  document = { 'version' => VERSION, 'producer' => @producer,
               'env' => env.to_h { |name, value| [name.to_s, value.to_s] },
               'inputs' => inputs.map(&:to_s), 'sources' => sources.map(&:to_s),
               'snapshot' => Facts.fingerprint(@graph, inputs: inputs, sources: sources, cited: cited,
                                               excluding: facts_path) }.merge(facts)
  reader = Document.new(@graph, document, @producer)
  Application.validate(@graph, [reader.compile])
  document
end