class GraphQL::Relay::BaseConnection

def after
  arguments[:after]
end

def before
  arguments[:before]
end

def connection_for_nodes(nodes)
  # If it's a new-style connection object, it's already ready to go
  if nodes.is_a?(GraphQL::Pagination::Connection)
    return nodes
  end
  # Check for class _names_ because classes can be redefined in Rails development
  nodes.class.ancestors.each do |ancestor|
    conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
    if conn_impl
      return conn_impl
    end
  end
  # Should have found a connection during the loop:
  raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
end

def cursor_from_node(object)
  raise GraphQL::RequiredImplementationMissingError, "must return a cursor for this object/connection pair"
end

def decode(data)
  @encoder.decode(data, nonce: true)
rescue ArgumentError
  raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
end

def edge_nodes
  @edge_nodes ||= paged_nodes
end

def encode(data)
  @encoder.encode(data, nonce: true)
end

def end_cursor
  if end_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).last
    return cursor_from_node(end_node)
  else
    return nil
  end
end

def first
  @first ||= get_limited_arg(:first)
end

def get_limited_arg(arg_name)
  arg_value = arguments[arg_name]
  if arg_value.nil?
    arg_value
  elsif arg_value < 0
    0
  else
    arg_value
  end
end

def has_next_page
  !!(first && sliced_nodes.count > first)
end

def has_previous_page
  !!(last && sliced_nodes.count > last)
end

def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
  @context = context
  @nodes = nodes
  @arguments = arguments
  @field = field
  @parent = parent
  @encoder = context ? @context.schema.cursor_encoder : GraphQL::Schema::Base64Encoder
  @max_page_size = max_page_size.nil? && context ? @context.schema.default_max_page_size : max_page_size
end

def inspect
  "#<GraphQL::Relay::Connection @parent=#{@parent.inspect} @arguments=#{@arguments.to_h.inspect}>"
end

def last
  @last ||= get_limited_arg(:last)
end

def page_info
  self
end

def paged_nodes
  raise GraphQL::RequiredImplementationMissingError, "must return nodes for this connection after paging"
end

def register_connection_implementation(nodes_class, connection_class)
  CONNECTION_IMPLEMENTATIONS[nodes_class.name] = connection_class
end

def sliced_nodes
  raise GraphQL::RequiredImplementationMissingError, "must return  all nodes for this connection after chopping off first and last"
end

def start_cursor
  if start_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).first
    return cursor_from_node(start_node)
  else
    return nil
  end
end