module Mongoid::Extensions::Hash

def __consolidate__(klass)
  consolidated = {}
  each_pair do |key, value|
    if key =~ /\$/
      value.each_pair do |_key, _value|
        value[_key] = (key == "$rename") ? _value.to_s : mongoize_for(key, klass, _key, _value)
      end
      consolidated[key] ||= {}
      consolidated[key].update(value)
    else
      consolidated["$set"] ||= {}
      consolidated["$set"].update(key => mongoize_for(key, klass, key, value))
    end
  end
  consolidated
end

def __evolve_object_id__
  transform_values!(&:__evolve_object_id__)
end

def __mongoize_object_id__
  if id = self['$oid']
    BSON::ObjectId.from_string(id)
  else
    transform_values!(&:__mongoize_object_id__)
  end
end

def __nested__(string)
  keys = string.split(".")
  value = self
  keys.each do |key|
    return nil if value.nil?
    value_for_key = value[key]
    if value_for_key.nil? && key.to_i.to_s == key
      value_for_key = value[key.to_i]
    end
    value = value_for_key
  end
  value
end

def _mongoid_unsatisfiable_criteria?
  unsatisfiable_criteria = { "_id" => { "$in" => [] }}
  return true if self == unsatisfiable_criteria
  return false unless length == 1 && keys == %w($and)
  value = values.first
  value.is_a?(Array) && value.any? do |sub_v|
    sub_v.is_a?(Hash) && sub_v._mongoid_unsatisfiable_criteria?
  end
end

def delete_id
  delete("_id") || delete(:_id) || delete("id") || delete(:id)
end

def extract_id
  self["_id"] || self[:_id] || self["id"] || self[:id]
end

def mongoize
  ::Hash.mongoize(self)
end

def mongoize_for(operator, klass, key, value)
  field = klass.fields[key.to_s]
  if field
    val = field.mongoize(value)
    if Mongoid::Persistable::LIST_OPERATIONS.include?(operator) && field.resizable?
      val = val.first if !value.is_a?(Array)
    end
    val
  else
    value
  end
end

def resizable?
  true
end

def to_criteria
  criteria = Criteria.new(delete(:klass) || delete("klass"))
  each_pair do |method, args|
    criteria = criteria.__send__(method, args)
  end
  criteria
end