Mercury-IM/app/src/main/java/org/mercury_im/messenger/ui/login/LoginViewModel.java

package org.mercury_im.messenger.ui.login;

import android.text.TextUtils;
import android.util.Log;

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

import io.reactivex.Single;
import io.reactivex.observers.DisposableSingleObserver;

import org.jxmpp.jid.EntityBareJid;
import org.jxmpp.jid.impl.JidCreate;
import org.mercury_im.messenger.MercuryImApplication;
import org.mercury_im.messenger.account.error.PasswordError;
import org.mercury_im.messenger.account.error.UsernameError;
import org.mercury_im.messenger.data.repository.AccountRepository;
import org.mercury_im.messenger.entity.Account;
import org.mercury_im.messenger.entity.IAccount;
import org.mercury_im.messenger.entity.PasswordAuthentication;

import javax.inject.Inject;

public class LoginViewModel extends ViewModel {

    @Inject
    AccountRepository accountRepository;

    // @Inject
    // ConnectionCenter connectionCenter;

    private String username;
    private String password;

    private MutableLiveData<UsernameError> usernameError = new MutableLiveData<>(UsernameError.none);
    private MutableLiveData<PasswordError> passwordError = new MutableLiveData<>(PasswordError.none);

    private MutableLiveData<Account> account = new MutableLiveData<>();

    private MutableLiveData<Boolean> signinSuccessful = new MutableLiveData<>();

    public LoginViewModel() {
        super();
        MercuryImApplication.getApplication().getAppComponent().inject(this);
        init(new IAccount());
    }

    public LiveData<Boolean> getSigninSuccessful() {
        return signinSuccessful;
    }

    public void onUsernameInputChanged(String input) {
        this.username = input;
    }

    public void onPasswordInputChanged(String input) {
        this.password = input;
    }

    public LiveData<UsernameError> getUsernameError() {
        return usernameError;
    }

    public LiveData<PasswordError> getPasswordError() {
        return passwordError;
    }

    /**
     * Try to parse the input string into a {@link EntityBareJid} and return it.
     * Return null on failure.
     * @param input input string
     * @return valid username or null
     */
    private EntityBareJid asValidUsernameOrNull(String input) {
        return JidCreate.entityBareFromOrNull(input);
    }

    private boolean isPasswordValid(String password) {
        return !password.isEmpty();
    }

    public void init(@NonNull Account account) {
        this.account.setValue(account);
    }

    public MutableLiveData<Account> getAccount() {
        return account;
    }

    public void login() {
        Account account = getAccount().getValue();
        if (account != null && account.getAddress() != null
                && !TextUtils.isEmpty(account.getAuthentication().getPassword())) {
            accountRepository.upsertAccount(account);
        }
    }

    public void loginDetailsEntered() {
        boolean loginIntact = true;
        if (username.isEmpty()) {
            usernameError.postValue(UsernameError.emptyUsername);
            loginIntact = false;
        }

        EntityBareJid bareJid = asValidUsernameOrNull(username);
        if (bareJid == null) {
            usernameError.postValue(UsernameError.invalidUsername);
            loginIntact = false;
        }

        if (!isPasswordValid(password)) {
            passwordError.postValue(PasswordError.invalidPassword);
            loginIntact = false;
        }

        if (loginIntact) {
            Account account = new IAccount();
            account.setEnabled(true);
            account.setAddress(bareJid.toString());
            account.setAuthentication(new PasswordAuthentication(password));
            Single<Account> insert = accountRepository.upsertAccount(account);
            insert.subscribe(
                    new DisposableSingleObserver<Account>() {
                        @Override
                        public void onSuccess(Account inserted) {
                            // connectionCenter.createConnection(account);
                            signinSuccessful.setValue(true);
                        }

                        @Override
                        public void onError(Throwable e) {
                            Log.e("Mercury", "Could not insert new Account data.", e);
                        }
                    });

        }
    }
}