class Mongoid::Criteria::Queryable::Selector

def evolve_hash(serializer, value)
  value.each_pair do |operator, _value|
    if operator =~ /exists|type|size/
      value[operator] = _value
    else
      value[operator] = evolve(serializer, _value)
    end
  end
end

def evolve_multi(specs)
  unless specs.is_a?(Array)
    raise ArgumentError, "specs is not an array: #{specs.inspect}"
  end
  specs.map do |spec|
    Hash[spec.map do |key, value|
      # If an application nests conditionals, e.g.
      # {'$or' => [{'$or' => {...}}]},
      # when evolve_multi is called for the top level hash,
      # this call recursively transforms the bottom level $or.
      if multi_selection?(key)
        value = evolve_multi(value)
      end
      # storage_pair handles field aliases but not localization for
      # some reason, although per its documentation Smash supposedly
      # owns both.
      name, serializer = storage_pair(key)
      final_key = localized_key(name, serializer)
      # This performs type conversions on the value and transformations
      # that depend on the type of the field that the value is stored
      # in, but not transformations that have to do with query shape.
      evolved_value = evolve(serializer, value)
      # This builds a query shape around the value, when the query
      # involves complex keys. For example, {:foo.lt => 5} produces
      # {'foo' => {'$lt' => 5}}. This step should be done after all
      # value-based processing is complete.
      if key.is_a?(Key)
        evolved_value = key.transform_value(evolved_value)
      end
      [ final_key, evolved_value ]
    end]
  end.uniq
end

def merge!(other)
  other.each_pair do |key, value|
    if value.is_a?(Hash) && self[key.to_s].is_a?(Hash)
      value = self[key.to_s].merge(value) do |_key, old_val, new_val|
        case _key
        when '$in'
          new_val & old_val
        when '$nin'
          (old_val + new_val).uniq
        else
          new_val
        end
      end
    end
    if multi_selection?(key)
      value = (self[key.to_s] || []).concat(value)
    end
    store(key, value)
  end
end

def multi_selection?(key)
  %w($and $or $nor).include?(key)
end

def store(key, value)
  name, serializer = storage_pair(key)
  if multi_selection?(name)
    store_name = name
    store_value = evolve_multi(value)
  else
    store_name = localized_key(name, serializer)
    store_value = evolve(serializer, value)
  end
  super(store_name, store_value)
end

def to_pipeline
  pipeline = []
  pipeline.push({ "$match" => self }) unless empty?
  pipeline
end