package org.mercury_im.messenger.android.ui.account.login;

import android.app.Application;

import androidx.annotation.NonNull;
import androidx.lifecycle.AndroidViewModel;

import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smackx.ikey.IkeyManager;
import org.jivesoftware.smackx.ox.element.SecretkeyElement;
import org.jivesoftware.smackx.pubsub.PubSubException;
import org.mercury_im.messenger.android.MercuryImApplication;
import org.mercury_im.messenger.core.connection.MercuryConnection;
import org.mercury_im.messenger.core.connection.MercuryConnectionManager;
import org.mercury_im.messenger.core.crypto.ikey.IkeyInitializer;
import org.mercury_im.messenger.core.util.Optional;

import java.util.UUID;

import javax.inject.Inject;

import io.reactivex.Maybe;
import io.reactivex.MaybeObserver;
import io.reactivex.Single;

public class IkeySetupViewModel extends AndroidViewModel {

    @Inject
    MercuryConnectionManager connectionManager;

    @Inject
    IkeyInitializer ikeyInitializer;

    IkeyManager ikeyManager;
    private SecretkeyElement secretkeyElement;

    public IkeySetupViewModel(@NonNull Application application) {
        super(application);
        MercuryImApplication.getApplication().getAppComponent().inject(this);
    }

    public void init(UUID accountId) {
        MercuryConnection connection = connectionManager.getConnection(accountId);
        ikeyManager = ikeyInitializer.initFor(connection);
    }

    public Single<Optional<SecretkeyElement>> fetchBackupElement() {
        return fetchMaybeBackupElement()
                .map(Optional::new)
                .toSingle(new Optional<>());
    }

    private Maybe<SecretkeyElement> fetchMaybeBackupElement() {
        return new Maybe<SecretkeyElement>() {
            @Override
            protected void subscribeActual(MaybeObserver<? super SecretkeyElement> observer) {
                try {
                    secretkeyElement = ikeyManager.fetchSecretIdentityKey();
                    if (secretkeyElement != null) {
                        observer.onSuccess(secretkeyElement);
                    } else {
                        observer.onComplete();
                    }
                } catch (PubSubException.NotALeafNodeException e) {
                    observer.onComplete();
                } catch (InterruptedException | XMPPException.XMPPErrorException | SmackException.NotConnectedException | SmackException.NoResponseException e) {
                    observer.onError(e);
                }
            }
        };
    }
}