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

package org.mercury_im.messenger.ui.chat;

import android.os.Bundle;
import android.util.Log;
import android.view.Menu;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.lifecycle.ViewModelProviders;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import org.jxmpp.jid.EntityBareJid;
import org.jxmpp.jid.impl.JidCreate;
import org.mercury_im.messenger.MercuryImApplication;
import org.mercury_im.messenger.R;
import org.mercury_im.messenger.persistence.model.AccountModel;
import org.mercury_im.messenger.persistence.model.ContactModel;
import org.mercury_im.messenger.persistence.model.MessageModel;
import org.mercury_im.messenger.persistence.repository.AccountRepository;
import org.mercury_im.messenger.persistence.repository.MessageRepository;
import org.mercury_im.messenger.persistence.repository.RosterRepository;

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

import javax.inject.Inject;

import butterknife.BindView;
import butterknife.ButterKnife;
import io.reactivex.Maybe;
import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

public class ChatActivity extends AppCompatActivity implements ChatInputFragment.OnChatInputActionListener {

    public static final String EXTRA_JID = "JID";
    public static final String EXTRA_ACCOUNT = "ACCOUNT";

    @Inject
    AccountRepository accountRepository;

    @Inject
    MessageRepository messageRepository;

    @Inject
    RosterRepository rosterRepository;

    @BindView(R.id.toolbar)
    Toolbar toolbar;

    @BindView(R.id.recyclerView)
    RecyclerView recyclerView;

    private ChatViewModel chatViewModel;

    private final CompositeDisposable disposable = new CompositeDisposable();

    private EntityBareJid jid;

    private long accountId;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("Mercury", "onCreate");
        setContentView(R.layout.activity_chat);
        ButterKnife.bind(this);

        setSupportActionBar(toolbar);
        MercuryImApplication.getApplication().getAppComponent().inject(this);

        ChatRecyclerViewAdapter adapter = new ChatRecyclerViewAdapter();
        recyclerView.setAdapter(adapter);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));

        if (savedInstanceState == null) {
            savedInstanceState = getIntent().getExtras();
            if (savedInstanceState == null) return;
        }

        String jidString = savedInstanceState.getString(EXTRA_JID);
        if (jidString != null) {
            jid = JidCreate.entityBareFromOrThrowUnchecked(jidString);
            accountId = savedInstanceState.getLong(EXTRA_ACCOUNT);

            Maybe<AccountModel> account = accountRepository.getAccount(accountId);
            chatViewModel = ViewModelProviders.of(this).get(ChatViewModel.class);

            disposable.add(
                    account.subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe(accountModel -> {
                                chatViewModel.init(accountModel, jid);
                            }));

            disposable.add(
                    rosterRepository.getContact(accountId, jid)
                            .toObservable()
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe((Consumer<ContactModel>) o -> {
                                Logger.getLogger("AAAAAAAA").log(Level.INFO, "Title change?");
                                String title = o.getRosterName();
                                if (title == null) {
                                    title = jidString;
                                }
                                getSupportActionBar().setTitle(title);
                            }));

            Observable<List<MessageModel>> messages = messageRepository.getAllMessagesOfChat(accountId, jid);
            disposable.add(
                    messages.subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .doOnNext(messageModels -> Log.d(MercuryImApplication.TAG, "Updating messages: " + messageModels.size()))
                            .subscribe(messageModels -> {
                                adapter.updateMessages(messageModels);
                                recyclerView.scrollToPosition(messageModels.size() - 1);
                            }));

            ChatInputFragment composer = (ChatInputFragment) getSupportFragmentManager()
                    .findFragmentById(R.id.fragment_compose);
        }
    }

    public void onStop() {
        super.onStop();
        disposable.clear();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_chat, menu);
        return true;
    }

    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        outState.putString(EXTRA_JID, jid.toString());
        outState.putLong(EXTRA_ACCOUNT, accountId);
        super.onSaveInstanceState(outState);
    }

    @Override
    public void onButtonMediaClicked() {

    }

    @Override
    public void onComposingBodyChanged(String body) {

    }

    @Override
    public void onComposingBodySend(String body) {
        String msg = body.trim();
        if (msg.isEmpty()) {
            return;
        }

        MessageModel messageModel = messageRepository.newMessageModel();
        AccountModel account = (AccountModel) accountRepository.getAccount(accountId)
                .subscribeOn(Schedulers.io()).blockingGet();
        messageModel.setFrom(account.getJid());
        messageModel.setTo(jid);
        messageModel.setSendDate(new Date());
        messageModel.setBody(msg);
        messageModel.setIncoming(false);
        messageModel.setAccountId(accountId);

        disposable.add(messageRepository
                .insertMessage(messageModel)
                .subscribeOn(Schedulers.io())
                .subscribe());
        /*
        new Thread() {
            @Override
            public void run() {
                try {
                    ChatManager.getInstanceFor(connectionService.getConnection(accountId).getConnection())
                            .chatWith(jid).send(msg);
                } catch (SmackException.NotConnectedException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        */
    }
}