class GraphqlMigrateExecution::Visitor

# File lib/graphql_migrate_execution/visitor.rb, line 184
def self.constant_node?(node)
  case node
  when Prism::ConstantPathNode,
        Prism::ConstantReadNode,
        Prism::StringNode,
        Prism::SymbolNode,
        Prism::IntegerNode,
        Prism::FloatNode,
        Prism::TrueNode,
        Prism::FalseNode,
        Prism::NilNode
    true
  when Prism::ArrayNode
    node.elements.all? { |n| constant_node?(n) }
  else
    false
  end
end

# File lib/graphql_migrate_execution/visitor.rb, line 4
def initialize(source, type_definitions)
  @source = source
  @type_definitions = type_definitions
  @type_definition_stack = []
  @current_field_definition = nil
  @current_resolver_method = nil
  @is_public = true
end

# File lib/graphql_migrate_execution/visitor.rb, line 203
def self.source_for_constant_node(value_node)
  case value_node
  when Prism::SymbolNode
    ":#{value_node.unescaped}"
  when Prism::StringNode
    value_node.unescaped.inspect
  when Prism::IntegerNode, Prism::FloatNode
    value_node.value.inspect
  when Prism::TrueNode
    "true"
  when Prism::FalseNode
    "false"
  when Prism::ConstantPathNode, Prism::ConstantReadNode
    value_node.full_name
  when Prism::ArrayNode
    value_node.elements.map { |n| get_keyword_value(n) }
  when Prism::NilNode
    "nil"
  else
    # nil, constants, `self` ...?
    raise ArgumentError, "GraphQL-MigrateExecution can't parse this keyword argument yet, but it could. Please open an issue on GraphQL-Ruby with this error message (node class: #{value_node.class})\n\n#{value_node.inspect}"
  end
end

# File lib/graphql_migrate_execution/visitor.rb, line 67
def visit_call_node(node)
  if node.receiver.nil? && node.name == :field
    first_arg = node.arguments.arguments.first # rubocop:disable Development/ContextIsPassedCop
    if first_arg.is_a?(Prism::SymbolNode)
      field_name = first_arg.unescaped
      td = @type_definition_stack.last
      @current_field_definition = td.field_definition(field_name, node)
    else
      warn "GraphQL-Ruby warning: Skipping unrecognized field definition: #{node.inspect}"
    end
  elsif node.receiver.nil? && ((node.name == :private) || (node.name == :protected))
    @is_public = false
  elsif node.receiver.nil? && node.name == :public
    @is_public = true
  elsif @current_resolver_method
    if node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
      @current_resolver_method.self_sends.add(node.name)
      case node.name
      when :object
        @current_resolver_method.calls_object = true
      when :context
        @current_resolver_method.calls_context = true
      when :class
        @current_resolver_method.calls_class = true
      end
    end

    case node.name
    when :dataloader, :dataload, :dataload_association, :dataload_record, :dataload_all
      @current_resolver_method.calls_dataloader = true
    when :current_path
      if node.receiver.is_a?(Prism::CallNode) && node.receiver.name == :context
        @current_resolver_method.uses_current_path = true
      end
    when :[]
      if node.receiver.is_a?(Prism::CallNode) && node.receiver.name == :context &&
          (arg = node.arguments.arguments.first).is_a?(Prism::SymbolNode) && (arg.unescaped == "current_path")
        @current_resolver_method.uses_current_path = true
      end
    end
  end
  super
ensure
  if td
    @current_field_definition = nil
  end
end

# File lib/graphql_migrate_execution/visitor.rb, line 13
def visit_class_node(node)
  if node.superclass
    td = @type_definitions[node.name]
    @type_definition_stack << td
  end
  super
ensure
  if td
    @type_definition_stack.pop
  end
end

# File lib/graphql_migrate_execution/visitor.rb, line 115
def visit_def_node(node)
  if @is_public && (td = @type_definition_stack.last)
    if node.receiver.nil?
      @current_resolver_method = td.resolver_method(node.name, node)
    end

    if node.name == :resolve && td.resolver_methods.size == 1
      td.is_resolver = true
    elsif td.is_resolver && td.resolver_methods.size > 1
      td.is_resolver = false
    end

    body = case node.body
    when Prism::StatementsNode
      node.body.body
    when Prism::BeginNode
      node.body.statements.body
    when nil
      nil
    else
      raise ArgumentError, "Unexpected DefNode body for `def #{node.name}`: #{node.body.class}"
    end

    if body && @current_resolver_method && body.length == 1 && (call_node = body.first).is_a?(Prism::CallNode)
      case call_node.name
      when :load, :request, :load_all, :request_all
        if (call_node2 = call_node.receiver).is_a?(Prism::CallNode) && call_node2.name == :with
          @current_resolver_method.dataloader_call = true
        end
      when :dataload_record, :dataload_association, :dataload, :dataload_all
        @current_resolver_method.dataloader_call = true
      else
        # not a single dataloader call
      end
    end
  end
  super
ensure
  @current_resolver_method = nil
end

# File lib/graphql_migrate_execution/visitor.rb, line 33
def visit_keyword_hash_node(node)
  if @current_field_definition
    node.elements.each do |assoc|
      if assoc.key.is_a?(Prism::SymbolNode)
        case assoc.key.unescaped
        when "hash_key"
          @current_field_definition.resolve_mode ||= :hash_key
          @current_field_definition.hash_key = get_keyword_value(assoc.value)
        when "resolver", "mutation", "subscription"
          @current_field_definition.resolve_mode ||= :resolver
          @current_field_definition.resolver = get_keyword_value(assoc.value)
        when "method"
          @current_field_definition.resolve_mode ||= :object_direct_method
          @current_field_definition.object_direct_method = get_keyword_value(assoc.value)
        when "resolver_method"
          @current_field_definition.resolve_mode ||= :type_instance_method
          @current_field_definition.type_instance_method = get_keyword_value(assoc.value)
        when "dig"
          @current_field_definition.resolve_mode ||= :dig
          @current_field_definition.dig = get_keyword_value(assoc.value)
        when "resolve_each", "resolve_static", "resolve_batch", "resolve_legacy_instance_method"
          # These should override any other keywords that are discovered
          @current_field_definition.resolve_mode = :already_migrated
          @current_field_definition.already_migrated = { assoc.key.unescaped.to_sym => get_keyword_value(assoc.value) }
        else
          # fallback_value,  connection, extensions, extras, resolver, mutation, subscription
          @current_field_definition.unknown_options << assoc.key.unescaped
        end
      end
    end
  end
  super
end

# File lib/graphql_migrate_execution/visitor.rb, line 25
def visit_module_node(node)
  td = @type_definitions[node.name]
  @type_definition_stack << td
  super
ensure
  @type_definition_stack.pop
end