class Pagy

def self.new_from_elasticsearch_rails(response, vars={})
  vars[:items] = response.search.options[:size] || 10
  vars[:page]  = (response.search.options[:from] || 0) / vars[:items] + 1
  vars[:count] = response.raw_response['hits']['total']
  new(vars)
end

def self.new_from_searchkick(results, vars={})
  vars[:items] = results.options[:per_page]
  vars[:page]  = results.options[:page]
  vars[:count] = results.total_count
  new(vars)
end

def self.root; @root ||= Pathname.new(__FILE__).dirname.freeze end

def initialize(vars)
  @vars = VARS.merge(vars.delete_if{|_,v| v.nil? || v == '' })               # default vars + cleaned vars
  { count:0, items:1, outset:0, page:1 }.each do |k,min|                     # validate instance variables
    (@vars[k] && instance_variable_set(:"@#{k}", @vars[k].to_i) >= min) \
       or raise(ArgumentError, "expected :#{k} >= #{min}; got #{@vars[k].inspect}")
  end
  @pages = @last = [(@count.to_f / @items).ceil, 1].max                      # cardinal and ordinal meanings
  @page <= @last or raise(OverflowError.new(self), "expected :page in 1..#{@last}; got #{@page.inspect}")
  @offset = @items * (@page - 1) + @outset                                   # pagination offset + outset (initial offset)
  @items  = @count - ((@pages-1) * @items) if @page == @last && @count > 0   # adjust items for last non-empty page
  @from   = @count == 0 ? 0 : @offset+1 - @outset                            # page begins from item
  @to     = @count == 0 ? 0 : @offset + @items - @outset                     # page ends to item
  @prev   = (@page-1 unless @page == 1)                                      # nil if no prev page
  @next   = @page == @last ? (1 if @vars[:cycle]) : @page+1                  # nil if no next page, 1 if :cycle
end

def initialize_with_overflow(vars)
  @overflow ||= false                         # don't override if :last_page re-run the method after an overflow
  initialize_without_overflow(vars)
rescue OverflowError
  @overflow = true                            # add the overflow flag
  case @vars[:overflow]
  when :exception
    raise                                     # same as without the extra
  when :last_page
    initial_page = @vars[:page]               # save the very initial page (even after re-run)
    initialize(vars.merge!(page: @last))      # re-run with the last page
    @vars[:page] = initial_page               # restore the inital page
  when :empty_page
    @offset = @items = @from = @to = 0        # vars relative to the actual page
    @prev = @last                             # prev relative to the actual page
    extend(Series)                            # special series for :empty_page
  else
    raise ArgumentError, "expected :overflow variable in [:last_page, :empty_page, :exception]; got #{@vars[:overflow].inspect}"
  end
end

def overflow?; @overflow end

def responsive
  @responsive ||= {items: [], series: {}, widths:[]}.tap do |r|
    @vars[:breakpoints].key?(0) || raise(ArgumentError, "expected :breakpoints to contain the 0 size; got #{@vars[:breakpoints].inspect}")
    @vars[:breakpoints].each {|width, size| r[:items] |= r[:series][width] = series(size)}
    r[:widths] = r[:series].keys.sort!{|a,b| b <=> a}
  end
end

def series(size=@vars[:size])
  (series = []) and size.empty? and return series
  4.times{|i| (size[i]>=0 rescue nil) or raise(ArgumentError, "expected 4 items >= 0 in :size; got #{size.inspect}")}
  [*0..size[0], *@page-size[1]..@page+size[2], *@last-size[3]+1..@last+1].sort!.each_cons(2) do |a, b|
    if    a<0 || a==b || a>@last                                        # skip out of range and duplicates
    elsif a+1 == b; series.push(a)                                      # no gap     -> no additions
    elsif a+2 == b; series.push(a, a+1)                                 # 1 page gap -> fill with missing page
    else            series.push(a, :gap)                                # n page gap -> add :gap
    end                                                                 # skip the end boundary (last+1)
  end                                                                   # shift the start boundary (0) and
  series.tap{|s| s.shift; s[s.index(@page)] = @page.to_s}               # convert the current page to String
end

def to_h
  { count:  defined?(@count) && @count,
    page:   @page,
    items:  @items,
    pages:  @pages,
    last:   @last,
    offset: @offset,
    from:   @from,
    to:     @to,
    prev:   @prev,
    next:   @next,
    vars:   @vars,
    series: series }
end