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

package org.mercury_im.messenger.data.repository;

import org.mercury_im.messenger.data.mapping.DirectChatMapping;
import org.mercury_im.messenger.data.mapping.GroupChatMapping;
import org.mercury_im.messenger.data.mapping.MessageMapping;
import org.mercury_im.messenger.data.model.DirectChatModel;
import org.mercury_im.messenger.data.model.DirectMessagesRelation;
import org.mercury_im.messenger.data.model.MessageModel;
import org.mercury_im.messenger.entity.chat.DirectChat;
import org.mercury_im.messenger.entity.chat.GroupChat;
import org.mercury_im.messenger.entity.message.Message;
import org.mercury_im.messenger.util.ThreadUtils;

import java.util.List;

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

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

public class XmppMessageRepository
        extends RequeryRepository
        implements MessageRepository {

    private final MessageMapping messageMapping;
    private final DirectChatMapping directChatMapping;
    private final GroupChatMapping groupChatMapping;
    private final DirectChatRepository directChatRepository;
    private final GroupChatRepository groupChatRepository;

    @Inject
    public XmppMessageRepository(ReactiveEntityStore<Persistable> data,
                                    @Named(value = ThreadUtils.SCHEDULER_IO) Scheduler subscriberScheduler,
                                    @Named(value = ThreadUtils.SCHEDULER_UI) Scheduler observerScheduler,
                                    MessageMapping messageMapping,
                                    DirectChatMapping directChatMapping,
                                    GroupChatMapping groupChatMapping,
                                    DirectChatRepository directChatRepository,
                                    GroupChatRepository groupChatRepository) {
        super(data, subscriberScheduler, observerScheduler);
        this.messageMapping = messageMapping;
        this.directChatMapping = directChatMapping;
        this.groupChatMapping = groupChatMapping;
        this.directChatRepository = directChatRepository;
        this.groupChatRepository = groupChatRepository;
    }

    @Override
    public Single<Message> insertMessage(DirectChat chat, Message message) {
        return data()
                // fetch chat model
                .select(DirectChatModel.class)
                .where(DirectChatModel.ID.eq(chat.getId()))
                .get().maybe()
                // if not exists, insert chat into db
                .switchIfEmpty(data().insert(directChatMapping.toModel(chat, new DirectChatModel())))
                // place chat and message in relation
                .map(chatModel -> {
                    DirectMessagesRelation relation = new DirectMessagesRelation();
                    relation.setChat(chatModel);
                    relation.setMessage(messageMapping.toModel(message, new MessageModel()));
                    return relation;
                })
                // insert relation
                .flatMap(relationModel -> data().insert(relationModel))
                // prepare resulting message to be returned
                .map(DirectMessagesRelation::getMessage)
                .map(messageModel -> messageMapping.toEntity(messageModel, message))
                .subscribeOn(subscriberScheduler())
                .observeOn(observerScheduler());
    }

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

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

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

    @Override
    public Observable<List<Message>> findMessagesWithBody(String body) {
        return null;
    }

    @Override
    public Observable<List<Message>> findMessagesWithBody(DirectChat chat, String body) {
        return null;
    }

    @Override
    public Observable<List<Message>> findMessagesWithBody(GroupChat chat, String body) {
        return null;
    }

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

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

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

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