module GraphQL::Analysis

def analysis_errors(results)
  results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
end

def analyze_multiplex(multiplex, analyzers)
  multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
    reducer_states = analyzers.map { |r| ReducerState.new(r, multiplex) }
    query_results = multiplex.queries.map do |query|
      if query.valid?
        analyze_query(query, query.analyzers, multiplex_states: reducer_states)
      else
        []
      end
    end
    multiplex_results = reducer_states.map(&:finalize_reducer)
    multiplex_errors = analysis_errors(multiplex_results)
    multiplex.queries.each_with_index do |query, idx|
      query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
    end
  end
  nil
end

def analyze_query(query, analyzers, multiplex_states: [])
  query.trace("analyze_query", { query: query }) do
    analyzers_to_run = analyzers.select do |analyzer|
      if analyzer.respond_to?(:analyze?)
        analyzer.analyze?(query)
      else
        true
      end
    end
    reducer_states = analyzers_to_run.map { |r| ReducerState.new(r, query) } + multiplex_states
    irep = query.internal_representation
    irep.operation_definitions.each do |name, op_node|
      reduce_node(op_node, reducer_states)
    end
    reducer_states.map(&:finalize_reducer)
  end
end

def reduce_node(irep_node, reducer_states)
  visit_analyzers(:enter, irep_node, reducer_states)
  irep_node.typed_children.each do |type_defn, children|
    children.each do |name, child_irep_node|
      reduce_node(child_irep_node, reducer_states)
    end
  end
  visit_analyzers(:leave, irep_node, reducer_states)
end

def visit_analyzers(visit_type, irep_node, reducer_states)
  reducer_states.each do |reducer_state|
    next_memo = reducer_state.call(visit_type, irep_node)
    reducer_state.memo = next_memo
  end
end