Mercury-IM/persistence-room/src/main/java/org/mercury_im/messenger/persistence/room/repository/IRosterRepository.java

package org.mercury_im.messenger.persistence.room.repository;

import android.util.Log;

import org.jxmpp.jid.EntityBareJid;
import org.mercury_im.messenger.persistence.repository.RosterRepository;
import org.mercury_im.messenger.persistence.room.dao.ContactDao;
import org.mercury_im.messenger.persistence.room.dao.EntityDao;
import org.mercury_im.messenger.persistence.room.dao.RosterInformationDao;
import org.mercury_im.messenger.persistence.room.model.RoomContactModel;
import org.mercury_im.messenger.persistence.room.model.RoomEntityModel;
import org.mercury_im.messenger.persistence.room.model.RoomRosterInformationModel;

import java.util.List;

import javax.inject.Inject;

import io.reactivex.Completable;
import io.reactivex.CompletableSource;
import io.reactivex.Maybe;
import io.reactivex.Observable;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.SingleSource;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;

public class IRosterRepository extends RosterRepository<RoomEntityModel, RoomContactModel, RoomRosterInformationModel> {

    private final EntityDao entityDao;
    private final ContactDao contactDao;
    private final RosterInformationDao rosterInformationDao;

    @Inject
    public IRosterRepository(EntityDao entityDao, ContactDao contactDao, RosterInformationDao rosterInformationDao) {
        this.contactDao = contactDao;
        this.entityDao = entityDao;
        this.rosterInformationDao = rosterInformationDao;
    }

    /*
    RoomContactModel
     */

    @Override
    public RoomContactModel newContactModel() {
        return new RoomContactModel();
    }

    @Override
    public Observable<List<RoomContactModel>> getAllContacts() {
        return contactDao.getAllContacts()
                .flatMap(list -> {
                    for (RoomContactModel contact : list) {
                        RoomEntityModel entity = getEntityForContact(contact).blockingGet();
                        contact.setEntity(entity);
                    }
                    return Observable.just(list);
                });
    }

    @Override
    public Observable<List<RoomContactModel>> getAllContactsOfAccount(long accountId) {
        return contactDao.getContactsForAccount(accountId)
                .flatMap(list -> {
                    for (RoomContactModel contact : list) {
                        RoomEntityModel entity = getEntityForContact(contact).blockingGet();
                        contact.setEntity(entity);
                    }
                    return Observable.just(list);
                });
    }

    @Override
    public Single<Long> updateOrInsertContact(RoomContactModel contact) {
        //noinspection unchecked
        return entityDao.getEntityFor(contact.getAccountId(), contact.getEntity().getJid())
                .switchIfEmpty(insertOrReplaceEntity((RoomEntityModel) contact.getEntity())
                        .flatMap(entityId -> {
                            Log.d("Mercury", "Insert entity since maybe did not emit: " + entityId);
                            contact.getEntity().setId(entityId);
                            return (SingleSource<RoomEntityModel>) observer ->
                                    observer.onSuccess((RoomEntityModel) contact.getEntity());
                        }))
                .flatMap(entityModel -> {
                    contact.setEntityId(entityModel.getId());
                    contact.setEntity(entityModel);
                    return contactDao.insert(contact);
                });
    }

    @Override
    public Single<RoomEntityModel> getEntityForContact(long contactId) {
        Single<RoomEntityModel> s = contactDao.getEntityForContactId(contactId);
        return s;
    }

    @Override
    public Maybe<RoomContactModel> getContact(long id) {
        return contactDao.getContact(id)
                // Set the entity
                .zipWith(getEntityForContact(id).toMaybe(),
                        (contact, entity) -> {
                            contact.setEntity(entity);
                            contact.setEntityId(entity.getId());
                            return contact;
                        });
    }

    @Override
    public Maybe<RoomContactModel> getContactForEntity(long entityId) {
        return contactDao.getContactForEntityId(entityId)
                // Set the entity
                .zipWith(getEntity(entityId),
                        (contact, entity) -> {
                            contact.setEntity(entity);
                            contact.setEntityId(entityId);
                            return contact;
                        });
    }

    @Override
    public Completable deleteContact(long id) {
        return contactDao.deleteContact(id);
    }

    @Override
    public Completable deleteContact(RoomContactModel contact) {
        return contactDao.delete(contact);
    }

    @Override
    public Completable deleteContact(long accountId, EntityBareJid jid) {
        // Since Room does not support "DELETE x FROM X x INNER JOIN Y...", we have to get the
        // entity for the jid first and then delete by using its entityId
        final Maybe<RoomEntityModel> entity = getEntity(accountId, jid.asEntityBareJidOrThrow());
        return entity.flatMapCompletable(new Function<RoomEntityModel, CompletableSource>() {
            @Override
            public CompletableSource apply(RoomEntityModel entityModel) {
                return contactDao.deleteContactForEntity(entityModel.getId());
            }
        });
    }

    @Override
    public Completable deleteAllContacts() {
        return contactDao.deleteAll();
    }

    @Override
    public Completable deleteAllContactsOfAccount(long accountId) {
        return contactDao.deleteAllForAccount(accountId);
    }

    @Override
    public Completable deleteContacts(long[] ids) {
        return contactDao.deleteContacts(ids);
    }

    /*
    RoomRosterInformationModel
     */

    @Override
    public RoomRosterInformationModel newRosterInformationModel() {
        return new RoomRosterInformationModel();
    }

    @Override
    public Observable<RoomRosterInformationModel> getRosterInformationForAccount(long accountId) {
        return rosterInformationDao.getRosterInformation(accountId);
    }

    @Override
    public Single<Long> updateRosterInformation(RoomRosterInformationModel rosterInformation) {
        return rosterInformationDao.insertRosterInformation(rosterInformation);
    }

    /*
    RoomEntityModel
     */

    @Override
    public RoomEntityModel newEntityModel() {
        return new RoomEntityModel();
    }

    @Override
    public Maybe<RoomEntityModel> getEntity(long id) {
        return entityDao.getEntity(id);
    }

    @Override
    public Maybe<RoomEntityModel> getEntity(long accountId, EntityBareJid jid) {
        return entityDao.getEntityFor(accountId, jid);
    }

    @Override
    public Single<Long> insertOrReplaceEntity(RoomEntityModel entity) {
        return entityDao.insert(entity);
    }

}