Mercury-IM/app/src/main/java/org/mercury_im/messenger/android/ui/chat/AndroidChatViewModel.java

package org.mercury_im.messenger.android.ui.chat;

import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;

import org.jxmpp.jid.EntityBareJid;
import org.mercury_im.messenger.android.MercuryImApplication;
import org.mercury_im.messenger.android.ui.MercuryAndroidViewModel;
import org.mercury_im.messenger.core.Messenger;
import org.mercury_im.messenger.core.data.repository.DirectChatRepository;
import org.mercury_im.messenger.core.data.repository.MessageRepository;
import org.mercury_im.messenger.core.data.repository.PeerRepository;
import org.mercury_im.messenger.core.viewmodel.chat.ChatViewModel;
import org.mercury_im.messenger.entity.chat.DirectChat;
import org.mercury_im.messenger.entity.contact.Peer;
import org.mercury_im.messenger.entity.message.Message;

import java.util.List;
import java.util.UUID;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.inject.Inject;

import io.reactivex.Completable;
import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.schedulers.Schedulers;

public class AndroidChatViewModel extends ViewModel implements MercuryAndroidViewModel<ChatViewModel> {

    private final CompositeDisposable disposable = new CompositeDisposable();
    private static final Logger LOGGER = Logger.getLogger(AndroidChatViewModel.class.getName());

    @Inject
    ChatViewModel commonViewModel;

    @Inject
    PeerRepository contactRepository;

    @Inject
    DirectChatRepository chatRepository;

    @Inject
    MessageRepository messageRepository;

    @Inject
    Messenger messenger;

    private MutableLiveData<Peer> contact = new MutableLiveData<>();
    private MutableLiveData<List<Message>> messages = new MutableLiveData<>();
    private MutableLiveData<String> contactDisplayName = new MutableLiveData<>();
    private MutableLiveData<DirectChat> chat = new MutableLiveData<>();

    public AndroidChatViewModel() {
        super();
        MercuryImApplication.getApplication().getAppComponent().inject(this);
    }

    public void init(UUID accountId, EntityBareJid jid) {
        disposable.add(contactRepository.getOrCreatePeer(accountId, jid.toString())
                .flatMap(peer -> chatRepository.getOrCreateChatWithPeer(peer))
                .subscribe(this::init,
                        error -> LOGGER.log(Level.SEVERE, "Error subscribing to peer data", error)));
    }

    public void init(DirectChat chat) {
        this.chat.setValue(chat);
        this.contact.setValue(chat.getPeer());

        // Subscribe peer
        disposable.add(contactRepository.observePeer(chat.getPeer().getId())
                .subscribe(peer -> {
                            if (peer.isPresent()) {
                                contactDisplayName.setValue(peer.getItem().getName());
                            }
                        },
                        error -> LOGGER.log(Level.SEVERE, "Error subscribing display name to peer", error)));

        // Subscribe messages
        disposable.add(messageRepository.observeMessages(chat)
                .subscribe(messageList -> {
                            LOGGER.log(Level.INFO, "NEW MESSAGES.");
                            AndroidChatViewModel.this.messages.setValue(messageList);
                        },
                        error -> LOGGER.log(Level.SEVERE, "Error subscribing to messages", error)));
    }

    @Override
    protected void onCleared() {
        super.onCleared();
        LOGGER.log(Level.INFO, "CLEAR");
        disposable.clear();
    }

    public LiveData<List<Message>> getMessages() {
        return messages;
    }

    public LiveData<Peer> getContact() {
        return contact;
    }

    public LiveData<String> getContactDisplayName() {
        return contactDisplayName;
    }

    public void queryTextChanged(String query) {
        Observable<List<Message>> observable = query.isEmpty() ?
                messageRepository.observeMessages(chat.getValue()) :
                messageRepository.findMessagesWithBody(chat.getValue(), query);

        disposable.add(observable.subscribe(messages ->
                AndroidChatViewModel.this.messages.setValue(messages)));
    }

    public Completable requestMamMessages() {
        /*
        return Completable.fromAction(() -> {
            ChatModel chatModel = AndroidChatViewModel.this.chat.getValue();
            if (chatModel == null) {
                return;
            }
            connectionCenter.requestMamMessagesFor(chatModel);
        });

         */
        return null;
    }

    public void deleteContact() {
        Peer contact = getContact().getValue();
        disposable.add(messenger.deleteContact(contact)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(() -> LOGGER.log(Level.INFO, "Contact deleted."), e -> {
                    LOGGER.log(Level.SEVERE, e.getMessage(), e);
                }));
    }

    public void sendMessage(String body) {
        disposable.add(messenger.sendMessage(getContact().getValue(), body)
                .subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe());
    }

    @Override
    public ChatViewModel getCommonViewModel() {
        return commonViewModel;
    }
}