Mercury-IM/core/src/main/java/org/mercury_im/messenger/core/RosterStore.java

package org.mercury_im.messenger.core;

import org.jivesoftware.smack.roster.packet.RosterPacket;
import org.jxmpp.jid.Jid;
import org.mercury_im.messenger.persistence.model.ContactModel;
import org.mercury_im.messenger.persistence.model.EntityModel;
import org.mercury_im.messenger.persistence.model.RosterInformationModel;
import org.mercury_im.messenger.persistence.repository.RosterRepository;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.inject.Inject;

import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

public class RosterStore implements org.jivesoftware.smack.roster.rosterstore.RosterStore {

    private static final Logger LOGGER = Logger.getLogger(RosterStore.class.getName());

    private final RosterRepository rosterRepository;
    private long accountId;

    private CompositeDisposable disposable = null;

    private final Map<Jid, RosterPacket.Item> itemMap = new HashMap<>();
    private String rosterVersion;

    @Inject
    public RosterStore(RosterRepository rosterRepository) {
        this.rosterRepository = rosterRepository;
    }

    public void subscribe() {
        LOGGER.log(Level.INFO, "Subscribing...");
        if (disposable != null) {
            return;
        }
        disposable = new CompositeDisposable();

        disposable.add(rosterRepository.getAllContactsOfAccount(accountId)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe((Consumer<List<? extends ContactModel>>) o -> {
                    itemMap.clear();
                    for (ContactModel c : o) {
                        rosterRepository.getEntityForContact(c.getId()).subscribeOn(Schedulers.io())
                                .subscribe((Consumer<EntityModel>) o1 -> itemMap.put(o1.getJid(), fromModel(c)));
                        LOGGER.log(Level.INFO, "Populate itemMap with " + o.size() + " items");

                    }
                }));

        disposable.add(rosterRepository.getRosterInformationForAccount(accountId)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe((Consumer<RosterInformationModel>) s -> {
                    LOGGER.log(Level.INFO, "Set rosterVer = " + s.getRosterVersion());
                    rosterVersion = s.getRosterVersion();
                }));
    }

    public void unsubscribe() {
        if (disposable == null) {
            return;
        }
        disposable.dispose();
        disposable = null;
    }

    public void setAccountId(long accountId) {
        this.accountId = accountId;
    }

    @Override
    public List<RosterPacket.Item> getEntries() {
        return new ArrayList<>(itemMap.values());
    }

    @Override
    public RosterPacket.Item getEntry(Jid bareJid) {
        return itemMap.get(bareJid);
    }

    @Override
    public String getRosterVersion() {
        return rosterVersion != null ? rosterVersion : "";
    }

    @Override
    public boolean addEntry(RosterPacket.Item item, String version) {
        LOGGER.log(Level.INFO, "Add entry " + item.toXML().toString());
        // Update database
        ContactModel contact = toModel(item);
        rosterRepository.updateOrInsertContact(contact)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe();
        rosterRepository.updateRosterVersionForAccount(accountId, version)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe();

        return true;
    }

    @Override
    public boolean resetEntries(Collection<RosterPacket.Item> items, String version) {
        // Update database
        for (RosterPacket.Item item : items) {
            rosterRepository.updateOrInsertContact(toModel(item))
                    .subscribeOn(Schedulers.io())
                    .observeOn(Schedulers.computation())
                    .subscribe();
        }
        rosterRepository.updateRosterVersionForAccount(accountId, version)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe();

        return true;
    }

    @Override
    public boolean removeEntry(Jid bareJid, String version) {
        rosterRepository.deleteContact(accountId, bareJid.asEntityBareJidOrThrow())
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe();
        rosterRepository.updateRosterVersionForAccount(accountId, version)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe();
        return true;
    }

    @Override
    public void resetStore() {
        rosterRepository.deleteAllContactsOfAccount(accountId)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe();
        rosterRepository.updateRosterVersionForAccount(accountId, "")
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .subscribe();
    }

    public RosterPacket.Item fromModel(ContactModel contactModel) {
        RosterPacket.Item item = new RosterPacket.Item(
                contactModel.getEntity().getJid(),
                contactModel.getRosterName());
        if (contactModel.getDirection() != null) {
            item.setItemType(convert(contactModel.getDirection()));
        }
        item.setApproved(contactModel.isApproved());
        item.setSubscriptionPending(contactModel.isSubscriptionPending());
        return item;
    }

    public ContactModel toModel(RosterPacket.Item item) {
        ContactModel contact = rosterRepository.newContactModel();
        contact.setAccountId(accountId);

        ContactModel attributes = rosterRepository.newContactModel();
        attributes.setRosterName(item.getName());
        if (item.getItemType() != null) {
            attributes.setDirection(convert(item.getItemType()));
        }
        attributes.setApproved(item.isApproved());
        attributes.setSubscriptionPending(item.isSubscriptionPending());

        EntityModel entity = rosterRepository.newEntityModel();
        entity.setAccountId(accountId);
        entity.setJid(item.getJid().asEntityBareJidOrThrow());

        contact.setEntity(entity);

        return contact;
    }

    public ContactModel.DIRECTION convert(RosterPacket.ItemType type) {
        return ContactModel.DIRECTION.valueOf(type.toString());
    }

    public RosterPacket.ItemType convert(ContactModel.DIRECTION direction) {
        return RosterPacket.ItemType.fromString(direction.toString());
    }
}