class RearORM
  include RearUtils

  attr_reader :model, :pkey

  def initialize model, pkey = :id
    @model, @pkey, @orm = model, pkey, orm(model)
  end

  def [] id
    return model[id] if sequel?
    return model.where(pkey => id).first if activerecord?
    model.first(pkey => id) # DataMapper
  end

  def count conditions = {}
    return sequel_dataset(model, conditions).count if sequel?
    return model.where(conditions[:conditions]).count if activerecord?
    model.count(conditions) # DataMapper
  end

  def filter conditions = {}
    return sequel_dataset(model, conditions).all if sequel?
    return activerecord_dataset(model.where(conditions[:conditions]), conditions) if activerecord?
    model.all(conditions) # DataMapper
  end

  def assoc_filter assoc, item, conditions
    if sequel?
      return sequel_dataset(item.send('%s_dataset' % assoc), conditions).all
    elsif activerecord?
      dataset = item.send(assoc, conditions[:conditions])
      return [] if dataset.nil?
      return [dataset] unless dataset.respond_to?(:to_a)
      return activerecord_dataset(dataset, conditions)
    end
    # DataMapper
    result = item.send(assoc, conditions)
    result.respond_to?(:size) ? result : [result].compact
  end

  def assoc_count assoc, item, conditions
    return sequel_dataset(item.send('%s_dataset' % assoc), conditions).count if sequel?
    return 0 unless result = item.send(assoc)
    if activerecord?
      result.respond_to?(:where) ? result.where(conditions[:conditions]).count : 1
    else # DataMapper
      result.respond_to?(:count) ? result.count(conditions) : 1
    end
  end

  def delete_multiple *ids
    ids.flatten!
    return model.filter(pkey => ids).destroy if sequel?
    return model.destroy(ids) if activerecord?
    model.all(pkey => ids).destroy! # DataMapper
  end

  def sequel?; @orm == :sq; end
  def activerecord?; @orm == :ar; end

  private
  def sequel_dataset dataset, conditions = {}
    filters, limit, offset, order =
      conditions.values_at(:conditions, :limit, :offset, :order)
    ds = limit ? dataset.limit(*[limit, offset].compact) : dataset
    ds.filter(filters || {}).order(*[order].compact)
  end

  def activerecord_dataset dataset, conditions = {}
    (x = conditions[:offset]) && dataset = dataset.offset(x)
    (x = conditions[:limit])  && dataset = dataset.limit(x)
    (x = conditions[:order])  && dataset = dataset.order(x)
    dataset
  end
end