class GraphQL::Query

def analysis_errors
  valid?
  @analysis_errors
end

def arguments_for(irep_node, definition)
  @arguments_cache[irep_node][definition] ||= begin
    GraphQL::Query::LiteralInput.from_arguments(
      irep_node.ast_node.arguments,
      definition.arguments,
      self.variables
    )
  end
end

def document_valid?
  validation_result = schema.static_validator.validate(self)
  @validation_errors = validation_result[:errors]
  @internal_representation = validation_result[:irep]
  @validation_errors.none?
end

def find_operation(operations, operation_name)
  if operations.length == 1
    operations.values.first
  elsif operations.length == 0
    nil
  elsif !operations.key?(operation_name)
    raise OperationNameMissingError, operations.keys
  else
    operations[operation_name]
  end
end

def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil)
  fail ArgumentError, "a query string or document is required" unless query_string || document
  @schema = schema
  @max_depth = max_depth || schema.max_depth
  @max_complexity = max_complexity || schema.max_complexity
  @query_analyzers = schema.query_analyzers.dup
  if @max_depth
    @query_analyzers << GraphQL::Analysis::MaxQueryDepth.new(@max_depth)
  end
  if @max_complexity
    @query_analyzers << GraphQL::Analysis::MaxQueryComplexity.new(@max_complexity)
  end
  @context = Context.new(query: self, values: context)
  @root_value = root_value
  @validate = validate
  @operation_name = operation_name
  @fragments = {}
  @operations = {}
  @provided_variables = variables
  @query_string = query_string
  @document = document || GraphQL.parse(query_string)
  @document.definitions.each do |part|
    if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
      @fragments[part.name] = part
    elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
      @operations[part.name] = part
    else
      raise GraphQL::ExecutionError, "GraphQL query cannot contain a schema definition"
    end
  end
  @arguments_cache = Hash.new { |h, k| h[k] = {} }
  @validation_errors = []
  @analysis_errors = []
  @internal_representation = nil
  @was_validated = false
end

def internal_representation
  valid?
  @internal_representation
end

def query_possible?
  !selected_operation.nil? && variables
  true
rescue GraphQL::Query::OperationNameMissingError, GraphQL::Query::VariableValidationError => err
  @validation_errors << err.to_h
  false
end

def query_valid?
  @analysis_errors = begin
    if @query_analyzers.any?
      reduce_results = GraphQL::Analysis.analyze_query(self, @query_analyzers)
      reduce_results.select { |r| r.is_a?(GraphQL::AnalysisError) }.map(&:to_h)
    else
      []
    end
  end
  @analysis_errors.none?
end

def result
  @result ||= begin
    if !valid?
      all_errors = validation_errors + analysis_errors
      if all_errors.any?
        { "errors" => all_errors }
      else
        nil
      end
    else
      Executor.new(self).result
    end
  end
end

def selected_operation
  @selected_operation ||= find_operation(@operations, @operation_name)
end

def valid?
  if !@was_validated
    @was_validated = true
    @valid = if @validate
      document_valid? && query_possible? && query_valid?
    else
      true
    end
  end
  @valid
end

def validation_errors
  valid?
  @validation_errors
end

def variables
  @variables ||= GraphQL::Query::Variables.new(
    schema,
    selected_operation.variables,
    @provided_variables
  )
end