module Pagy::Backend

def self.included(controller)
  controller.define_method(:params){{}} unless controller.method_defined?(:params)
end

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

def pagy_arel(collection, vars={})
  pagy = Pagy.new(pagy_arel_get_vars(collection, vars))
  [ 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)
  pagy_set_items_from_params(vars) if defined?(UseItemsExtra)
  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))
  [ pagy, array[pagy.offset, pagy.items] ]
end

def pagy_array_get_vars(array, vars)
  pagy_set_items_from_params(vars) if defined?(UseItemsExtra)
  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))
  [ 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
  # finalize may adjust pagy.items, so must be used after checking the size
  pagy.finalize(items_size)
  items
end

def pagy_countless_get_vars(_collection, vars)
  pagy_set_items_from_params(vars) if defined?(UseItemsExtra)
  vars[:page]  ||= params[ vars[:page_param] || VARS[:page_param] ]
  vars
end

def pagy_elasticsearch_rails(pagy_search_args, vars={})
  model, query_or_payload, options, *called = pagy_search_args
  vars           = pagy_elasticsearch_rails_get_vars(nil, vars)
  options[:size] = vars[:items]
  options[:from] = vars[:items] * (vars[:page] - 1)
  response       = model.search(query_or_payload, **options)
  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
  return pagy_elasticsearch_rails(pagy_search_args, vars.merge(page: pagy.page)) \
         if defined?(Pagy::UseOverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
  [ pagy, called.empty? ? response : response.send(*called) ]
end

def pagy_elasticsearch_rails_get_vars(_collection, vars)
  pagy_set_items_from_params(vars) if defined?(UseItemsExtra)
  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)
  pagy_set_items_from_params(vars) if defined?(UseItemsExtra)
  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)
  pagy_headers_hash(pagy).tap do |hash|
    hash['Link'] = hash['Link'].map{|rel, link| %(<#{link}>; rel="#{rel}")}.join(', ')
  end
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(pagy, PAGE_PLACEHOLDER, absolute: true)
  hash    = { 'Link' => rels.filter_map do |rel, num|
                          next unless num
                          [ rel, url_str.sub(PAGE_PLACEHOLDER, num.to_s) ]
                        end.to_h }
  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, deprecated_url=nil, absolute: nil)
  absolute = Pagy.deprecated_arg(:url, deprecated_url, :absolute, absolute) if deprecated_url
  names   = pagy.vars[:metadata]
  unknown = names - METADATA
  raise VariableError.new(pagy), "unknown metadata #{unknown.inspect}" \
        unless unknown.empty?
  scaffold_url = pagy_url_for(pagy, PAGE_PLACEHOLDER, absolute: absolute)
  {}.tap do |metadata|
    names.each do |key|
      metadata[key] = case key
                      when :scaffold_url then scaffold_url
                      when :first_url    then scaffold_url.sub(PAGE_PLACEHOLDER, 1.to_s)
                      when :prev_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.prev.to_s)
                      when :page_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.page.to_s)
                      when :next_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.next.to_s)
                      when :last_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.last.to_s)
                      else pagy.send(key)
                      end
    end
  end
end

def pagy_searchkick(pagy_search_args, vars={})
  model, term, options, block, *called = pagy_search_args
  vars               = pagy_searchkick_get_vars(nil, vars)
  options[:per_page] = vars[:items]
  options[:page]     = vars[:page]
  results            = model.search(term, **options, &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
  return pagy_searchkick(pagy_search_args, vars.merge(page: pagy.page)) \
         if defined?(Pagy::UseOverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
  [ pagy, called.empty? ? results : results.send(*called) ]
end

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

def pagy_set_items_from_params(vars)
  return if vars[:items]
  return unless vars.key?(:enable_item_extra) ? vars[:enable_item_extra] : VARS[:enable_items_extra]
  return unless (items = params[vars[:items_param] || VARS[:items_param]])                               # :items from :items_param
  vars[:items] = [items.to_i, vars.key?(:max_items) ? vars[:max_items] : VARS[:max_items]].compact.min   # :items capped to :max_items
end