module ALD::API::Conditioned

# File lib/ALD/conditioned.rb, line 11
def where(conditions)
  return self if conditions.nil? || conditions.empty?
  new_conditions = merge_conditions(conditions)

  if initialized? && Collection::LocalFilter.can_apply?(conditions, self.class::LOCAL_CONDITIONS)
    self.class::new(
      @api,
      new_conditions,
      Collection::LocalFilter.apply_conditions(@data, conditions)
    )
  else
    self.class::new(@api, new_conditions)
  end
end

# File lib/ALD/conditioned.rb, line 74
def array_queries(conds)
  Hash[
    present_conditions(conds).map { |cond| [cond, @conditions[cond.to_sym].join(',')] }
  ]
end

# File lib/ALD/conditioned.rb, line 61
def exact_queries(conds)
  Hash[
    present_conditions(conds).map { |cond| [cond, @conditions[cond.to_sym]] }
  ]
end

# File lib/ALD/conditioned.rb, line 134
def merge_conditions(conditions)
  @conditions.merge(conditions) do |key, old_value, new_value|
    if self.class::RANGE_CONDITIONS.include?(key.to_s)
      merge_ranges(key, old_value, new_value) # handle merging for cases like 'downloads >= 5' and 'downloads <= 9' etc.
    elsif self.class::ARRAY_CONDITIONS.include?(key.to_s)
      old_value + new_value
    elsif key == :range # not a "range condition" in the sense used above
      range_offset(new_value)
    elsif key == :sort
      new_value # enable re-sorting
    else
      raise ArgumentError # for other overwrites fail!
    end
  end
end

# File lib/ALD/conditioned.rb, line 162
def merge_ranges(key, old, new)
  constraints = [new, old]
  data = constraints.map do |c|
    match = RANGE_REGEX.match(c)
    if match.nil?
      [nil, c]
    elsif key == :version
      [match[1], Semantic::Version.new(match[2])]
    else
      [match[1], match[2]]
    end
  end
  ops, values = data.map(&:first), data.map(&:last)

  if ops[0] != ops[1] # one min, one max OR one min/max, one exact
    constraints # => keep both

  elsif ops.none?(&:'nil?') # two range constraints of same type
    ops[0] == '>=' ? ">= #{values.max.to_s}" : "<= #{values.min.to_s}"

  else # two exact values
    if constraints[0].strip == constraints[1].strip # if both are the same, just keep one
      constraints[0]
    else # otherwise this can't be good - throw an error
      raise ArgumentError
    end
  end
end

# File lib/ALD/conditioned.rb, line 123
def present_conditions(conds)
  conds.select { |cond| @conditions.key?(cond.to_sym) }
end

# File lib/ALD/conditioned.rb, line 101
def range_condition_queries(conds)
  Hash[
    present_conditions(conds).map { |cond|
      fields = @conditions[cond.to_sym].is_a?(Array) ? @conditions[cond.to_sym] : [@conditions[cond.to_sym]]
      fields.map do |field|
        match = RANGE_REGEX.match(field)
        if match.nil? # just a specific field
          [cond, field]
        else # min or max
          ["#{cond}-#{match[1] == '>=' ? 'min' : 'max'}", match[2]]
        end
      end
    }.flatten(1)
  ]
end

# File lib/ALD/conditioned.rb, line 201
def range_offset(new_range)
  if @conditions[:range].nil?
    min, max = 0, Float::Infinity
  else
    min, max = @conditions[:range].min, @conditions[:range].max
  end

  new_min = min + new_range.min
  new_max = new_min + new_range.max - new_range.min # == new_min + new_range.size - 1
  raise ArgumentError if new_min > max || new_max > max

  (new_min..new_max)
end

# File lib/ALD/conditioned.rb, line 34
def range_query
  data = {}
  if @conditions.key?(:range)
    data['start'] = @conditions[:range].min
    data['count'] = @conditions[:range].max - @conditions[:range].min + 1
  end
  data
end

# File lib/ALD/conditioned.rb, line 48
def sort_query
  Hash[
    present_conditions(%w[sort]).map { |cond| [cond, @conditions[cond.to_sym].map { |k, dir| "#{dir == :desc ? '-' : ''}#{k}" }.join(',')] }
  ]
end

# File lib/ALD/conditioned.rb, line 87
def switch_queries(conds)
  map = {true => 'true', false => 'false', nil => 'both'}
  Hash[
    present_conditions(conds).map { |cond| [cond, map[@conditions[cond.to_sym]]] }
  ]
end