class AllocationStats::AllocationsProxy

def alias_paths(value = nil)
  # reader
  return @alias_paths if value.nil?
  # writer
  @alias_paths = value
  return self
end

def at_least(count)
  @mappers << Proc.new do |allocations|
    allocations.delete_if { |key,value| value.size < count }
  end
  self
end

def attribute_getters(faux_attributes)
  faux_attributes.map do |faux|
    if faux == :sourcefile
      lambda { |allocation| allocation.sourcefile(@alias_paths) }
    elsif Allocation::HELPERS.include?(faux) ||
          Allocation::ATTRIBUTES.include?(faux)
      lambda { |allocation| allocation.__send__(faux) }
    else
      lambda { |allocation| allocation.object.__send__(faux) }
    end
  end
end

def bytes
  @mappers << Proc.new do |allocations|
    if allocations.is_a? Array
      allocations.map(&:memsize)
    elsif allocations.is_a? Hash
      bytes_h = {}
      allocations.each do |key, allocations|
        bytes_h[key] = allocations.inject(0) { |sum, allocation| sum + allocation.memsize }
      end
      bytes_h
    end
  end
  self
end

def from(pattern)
  @wheres << Proc.new do |allocations|
    allocations.select { |allocation| allocation.sourcefile[pattern] }
  end
  self
end

def from_pwd
  @wheres << Proc.new do |allocations|
    allocations.select { |allocation| allocation.sourcefile[@pwd] }
  end
  self
end

def group_by(*args)
  @group_keys = args
  @group_by = Proc.new do |allocations|
    getters = attribute_getters(@group_keys)
    allocations.group_by do |allocation|
      getters.map { |getter| getter.call(allocation) }
    end
  end
  self
end

def initialize(allocations, alias_paths: false)
  @allocations = allocations
  @pwd = Dir.pwd
  @wheres = []
  @group_by = nil
  @mappers  = []
  @alias_paths = alias_paths
end

def not_from(pattern)
  @wheres << Proc.new do |allocations|
    allocations.reject { |allocation| allocation.sourcefile[pattern] }
  end
  self
end

def sort_by_size
  @mappers << Proc.new do |allocations|
    allocations.sort_by { |key, value| -value.size }
               .inject({}) { |hash, pair| hash[pair[0]] = pair[1]; hash }
  end
  self
end

def to_a
  results = @allocations
  @wheres.each do |where|
    results = where.call(results)
  end
  # First apply group_by
  results = @group_by.call(results) if @group_by
  # Apply each mapper
  @mappers.each do |mapper|
    results = mapper.call(results)
  end
  results
end

def to_json
  to_a.to_json
end

def to_text(columns: DEFAULT_COLUMNS)
  resolved = to_a
  # if resolved is an Array of Allocations
  if resolved.is_a?(Array) && resolved.first.is_a?(Allocation)
    to_text_from_plain(resolved, columns: columns)
  # if resolved is a Hash (was grouped)
  elsif resolved.is_a?(Hash)
    to_text_from_groups(resolved)
  end
end

def to_text_from_groups(resolved)
  columns = @group_keys + ["count"]
  keys = resolved.is_a?(Hash) ? resolved.keys : resolved.map(&:first)
  widths = columns.each_with_index.map do |column, idx|
    (keys.map { |group| group[idx].to_s.size } << columns[idx].to_s.size).max
  end
  text = []
  text << columns.each_with_index.map { |attr, idx|
    attr.to_s.center(widths[idx])
  }.join("  ").rstrip
  text << widths.map { |width| "-" * width }.join("  ")
  text += resolved.map { |group, allocations|
    line = group.each_with_index.map { |attr, idx|
      NUMERIC_COLUMNS.include?(columns[idx]) ?
        attr.to_s.rjust(widths[idx]) :
        attr.to_s.ljust(widths[idx])
    }.join("  ")
    line << "  " + allocations.size.to_s.rjust(5)
  }
  text.join("\n")
end

def to_text_from_plain(resolved, columns: DEFAULT_COLUMNS)
  getters = attribute_getters(columns)
  widths = getters.each_with_index.map do |attr, idx|
    (resolved.map { |a| attr.call(a).to_s.size } << columns[idx].to_s.size).max
  end
  text = []
  text << columns.each_with_index.map { |attr, idx|
    attr.to_s.center(widths[idx])
  }.join("  ").rstrip
  text << widths.map { |width| "-" * width }.join("  ")
  text += resolved.map { |allocation|
    getters.each_with_index.map { |getter, idx|
      value = getter.call(allocation).to_s
      NUMERIC_COLUMNS.include?(columns[idx]) ? value.rjust(widths[idx]) : value.ljust(widths[idx])
    }.join("  ").rstrip
  }
  text.join("\n")
end

def where(conditions)
  @wheres << Proc.new do |allocations|
    conditions = conditions.inject({}) do |memo, pair|
      faux, value = *pair
      getter = attribute_getters([faux]).first
      memo.merge(getter => value)
    end
    allocations.select do |allocation|
      conditions.all? { |getter, value| getter.call(allocation) == value }
    end
  end
  self
end