module Pagy::Backend

def pagy(collection, vars={})
  pagy = Pagy.new(pagy_get_vars(collection, vars))
  return pagy, pagy_get_items(collection, pagy)
end

def pagy_arel(collection, vars={})
  pagy = Pagy.new(pagy_arel_get_vars(collection, vars))
  return pagy, pagy_get_items(collection, pagy)
end

def pagy_arel_count(collection)
  if collection.group_values.empty?
    # COUNT(*)
    collection.count(:all)
  else
    # COUNT(*) OVER ()
    sql = Arel.star.count.over(Arel::Nodes::Grouping.new([]))
    collection.unscope(:order).limit(1).pluck(sql).first.to_i
  end
end

def pagy_arel_get_vars(collection, vars)
  vars[:count] ||= pagy_arel_count(collection)
  vars[:page]  ||= params[ vars[:page_param] || VARS[:page_param] ]
  vars
end

def pagy_array(array, vars={})
  pagy = Pagy.new(pagy_array_get_vars(array, vars))
  return pagy, array[pagy.offset, pagy.items]
end

def pagy_array_get_vars(array, vars)
  vars[:count] ||= array.size
  vars[:page]  ||= params[ vars[:page_param] || VARS[:page_param] ]
  vars
end

def pagy_countless(collection, vars={})
  pagy = Pagy::Countless.new(pagy_countless_get_vars(collection, vars))
  return pagy, pagy_countless_get_items(collection, pagy)
end

def pagy_countless_get_items(collection, pagy)
  # This should work with ActiveRecord, Sequel, Mongoid...
  items      = collection.offset(pagy.offset).limit(pagy.items + 1).to_a
  items_size = items.size
  items.pop if items_size == pagy.items + 1
  pagy.finalize(items_size)                  # finalize may adjust pagy.items, so must be used after checking the size
  items
end

def pagy_countless_get_vars(_collection, vars)
  vars[:page] ||= params[ vars[:page_param] || VARS[:page_param] ]
  vars
end

def pagy_elasticsearch_rails(pagy_search_args, vars={})
  model, search_args, _block, *called = pagy_search_args
  vars                   = pagy_elasticsearch_rails_get_vars(nil, vars)
  search_args[-1][:size] = vars[:items]
  search_args[-1][:from] = vars[:items] * (vars[:page] - 1)
  response               = model.search(*search_args)
  total                  = response.respond_to?(:raw_response) ? response.raw_response['hits']['total'] : response.response['hits']['total']
  vars[:count]           = total.is_a?(Hash) ? total['value'] : total
  pagy = Pagy.new(vars)
  # with :last_page overflow we need to re-run the method in order to get the hits
  if defined?(OVERFLOW) && pagy.overflow? && pagy.vars[:overflow] == :last_page
    return pagy_elasticsearch_rails(pagy_search_args, vars.merge(page: pagy.page))
  end
  return pagy, called.empty? ? response : response.send(*called)
end

def pagy_elasticsearch_rails_get_vars(_collection, vars)
  vars[:items] ||= VARS[:items]
  vars[:page]  ||= (params[ vars[:page_param] || VARS[:page_param] ] || 1).to_i
  vars
end

def pagy_get_items(collection, pagy)
  # This should work with ActiveRecord, Sequel, Mongoid...
  collection.offset(pagy.offset).limit(pagy.items)
end

def pagy_get_vars(collection, vars)
  vars[:count] ||= (c = collection.count(:all)).is_a?(Hash) ? c.size : c
  vars[:page]  ||= params[ vars[:page_param] || VARS[:page_param] ]
  vars
end

def pagy_headers(pagy)
  hash = pagy_headers_hash(pagy)
  hash['Link'] = hash['Link'].map{|rel, link| %(<#{link}>; rel="#{rel}")}.join(', ')
  hash
end

def pagy_headers_hash(pagy)
  countless = defined?(Pagy::Countless) && pagy.is_a?(Pagy::Countless)
  rels      = { 'first' => 1, 'prev' => pagy.prev, 'next' => pagy.next }; rels['last'] = pagy.last unless countless
  url_str   = pagy_url_for(PAGE_PLACEHOLDER, pagy, :url)
  hash      = { 'Link' => Hash[rels.map{|rel, n|[rel, url_str.sub(PAGE_PLACEHOLDER, n.to_s)] if n}.compact] }
  headers   = pagy.vars[:headers]
  hash[headers[:page]]  = pagy.page.to_s         if headers[:page]
  hash[headers[:items]] = pagy.vars[:items].to_s if headers[:items]
  unless countless
    hash[headers[:pages]] = pagy.pages.to_s if headers[:pages]
    hash[headers[:count]] = pagy.count.to_s if headers[:count]
  end
  hash
end

def pagy_headers_merge(pagy)
  response.headers.merge!(pagy_headers(pagy))
end

def pagy_metadata(pagy, url=false)
  names = pagy.vars[:metadata]
  (unknown = names - METADATA).empty? or raise(VariableError.new(pagy), "unknown metadata #{unknown.inspect}")
  scaffold_url = pagy_url_for(PAGE_PLACEHOLDER, pagy, url)
  metadata = {}
  names.each do |key|
    metadata[key] = case key
                    when :scaffold_url ; scaffold_url
                    when :first_url    ; scaffold_url.sub(PAGE_PLACEHOLDER, 1.to_s)
                    when :prev_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.prev.to_s)
                    when :page_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.page.to_s)
                    when :next_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.next.to_s)
                    when :last_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.last.to_s)
                    else pagy.send(key)
                    end
  end
  metadata
end

def pagy_searchkick(pagy_search_args, vars={})
  model, search_args, block, *called = pagy_search_args
  vars                       = pagy_searchkick_get_vars(nil, vars)
  search_args[-1][:per_page] = vars[:items]
  search_args[-1][:page]     = vars[:page]
  results                    = model.search(*search_args, &block)
  vars[:count]               = results.total_count
  pagy = Pagy.new(vars)
  # with :last_page overflow we need to re-run the method in order to get the hits
  if defined?(OVERFLOW) && pagy.overflow? && pagy.vars[:overflow] == :last_page
    return pagy_searchkick(pagy_search_args, vars.merge(page: pagy.page))
  end
  return pagy, called.empty? ? results : results.send(*called)
end

def pagy_searchkick_get_vars(_collection, vars)
  vars[:items] ||= VARS[:items]
  vars[:page]  ||= (params[ vars[:page_param] || VARS[:page_param] ] || 1).to_i
  vars
end

def pagy_with_items(vars)
  vars[:items] ||= (items = params[vars[:items_param] || VARS[:items_param]]) &&                           # :items from :items_param
                   [items.to_i, vars.key?(:max_items) ? vars[:max_items] : VARS[:max_items]].compact.min   # :items capped to :max_items
end