Mercury-IM/data/src/main/java/org/mercury_im/messenger/data/repository/XmppDirectChatRepository.java

package org.mercury_im.messenger.data.repository;

import org.mercury_im.messenger.data.mapping.AccountMapping;
import org.mercury_im.messenger.data.mapping.DirectChatMapping;
import org.mercury_im.messenger.data.mapping.PeerMapping;
import org.mercury_im.messenger.data.model.DirectChatModel;
import org.mercury_im.messenger.data.util.Optional;
import org.mercury_im.messenger.entity.chat.DirectChat;
import org.mercury_im.messenger.entity.chat.IDirectChat;
import org.mercury_im.messenger.entity.contact.Peer;
import org.mercury_im.messenger.entity.message.Message;
import org.mercury_im.messenger.util.ThreadUtils;

import java.util.ArrayList;
import java.util.List;

import javax.inject.Inject;
import javax.inject.Named;

import io.reactivex.Completable;
import io.reactivex.Maybe;
import io.reactivex.Observable;
import io.reactivex.Scheduler;
import io.reactivex.Single;
import io.requery.Persistable;
import io.requery.query.ResultDelegate;
import io.requery.reactivex.ReactiveEntityStore;

public class XmppDirectChatRepository
        extends RequeryRepository
        implements DirectChatRepository {

    private final AccountMapping accountMapping;

    private final PeerMapping peerMapping;

    private final DirectChatMapping directChatMapping;

    @Inject
    public XmppDirectChatRepository(
            ReactiveEntityStore<Persistable> data,
            @Named(value = ThreadUtils.SCHEDULER_IO) Scheduler subscriberScheduler,
            @Named(value = ThreadUtils.SCHEDULER_UI) Scheduler observerScheduler,
            AccountMapping accountMapping,
            PeerMapping peerMapping,
            DirectChatMapping directChatMapping) {
        super(data, subscriberScheduler, observerScheduler);
        this.accountMapping = accountMapping;
        this.peerMapping = peerMapping;
        this.directChatMapping = directChatMapping;
    }



    @Override
    public Single<DirectChat> insertDirectChat(DirectChat chat) {
        return data().insert(directChatMapping.entityToModel(chat, new DirectChatModel()))
                .map(model -> directChatMapping.modelToEntity(model, chat))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Observable<Optional<DirectChat>> observeDirectChat(long chatId) {
        return data().select(DirectChatModel.class)
                .where(DirectChatModel.ID.eq(chatId))
                .get().observableResult()
                .map(result -> new Optional<>(
                        directChatMapping.modelToEntity(result.firstOrNull(), new IDirectChat())))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Maybe<DirectChat> getDirectChat(long chatId) {
        return data().select(DirectChatModel.class)
                .where(DirectChatModel.ID.eq(chatId))
                .get().maybe()
                .map(result -> directChatMapping.modelToEntity(result, new IDirectChat()))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Single<DirectChat> getOrCreateChatWithPeer(Peer _peer) {
        return getDirectChatByPeer(_peer)
                .switchIfEmpty(insertDirectChat(new IDirectChat(){
                    {
                        setAccount(_peer.getAccount());
                        setPeer(_peer);
                    }
                }))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Observable<Optional<DirectChat>> observeDirectChatByPeer(Peer peer) {
        return data().select(DirectChatModel.class)
                .where(DirectChatModel.PEER_ID.eq(peer.getId()))
                .get().observableResult()
                .map(result -> new Optional<>(
                        directChatMapping.modelToEntity(result.firstOrNull(), new IDirectChat())))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Maybe<DirectChat> getDirectChatByPeer(Peer peer) {
        return data().select(DirectChatModel.class)
                .where(DirectChatModel.PEER_ID.eq(peer.getId()))
                .get().maybe()
                .map(model -> directChatMapping.modelToEntity(model, new IDirectChat()))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Observable<List<DirectChat>> observeAllDirectChats() {
        return data().select(DirectChatModel.class)
                .get().observableResult()
                .map(ResultDelegate::toList)
                .map(list -> {
                    List<DirectChat> entities = new ArrayList<>(list.size());
                    for (DirectChatModel model : list) {
                        entities.add(directChatMapping.modelToEntity(model, new IDirectChat()));
                    }
                    return entities;
                })
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Single<DirectChat> updateDirectChat(DirectChat chat) {
        return data().select(DirectChatModel.class)
                .where(DirectChatModel.ID.eq(chat.getId()))
                .get().maybe().toSingle()
                .flatMap(model -> {
                    model = directChatMapping.entityToModel(chat, model);
                    return data().update(model);
                })
                .map(model -> directChatMapping.modelToEntity(model, chat))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Single<DirectChat> upsertDirectChat(DirectChat chat) {
        return data().select(DirectChatModel.class)
                .where(DirectChatModel.ID.eq(chat.getId()))
                .get().maybe()
                .switchIfEmpty(data().insert(directChatMapping.entityToModel(chat, new DirectChatModel())))
                .flatMap(model -> {
                    model = directChatMapping.entityToModel(chat, model);
                    return data().update(model);
                })
                .map(model -> directChatMapping.modelToEntity(model, chat))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Completable deleteDirectChat(DirectChat chat) {
        return data().delete(DirectChatModel.class)
                .where(DirectChatModel.ID.eq(chat.getId()))
                .get().single().ignoreElement()
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

    @Override
    public Single<Message> insertMessage(DirectChat chat, Message message) {
        return null;
    }

    @Override
    public Observable<List<Message>> observeMessages(DirectChat chat) {
        return null;
    }

    @Override
    public Single<Message> updateMessage(Message message) {
        return null;
    }

    @Override
    public Single<Message> upsertMessage(DirectChat chat, Message message) {
        return null;
    }

    @Override
    public Completable deleteMessage(Message message) {
        return null;
    }
}