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

package org.mercury_im.messenger.core.stores;

import org.jivesoftware.smack.util.PacketParserUtils;
import org.jivesoftware.smack.xml.XmlPullParser;
import org.jivesoftware.smackx.caps.cache.EntityCapsPersistentCache;
import org.jivesoftware.smackx.disco.packet.DiscoverInfo;
import org.mercury_im.messenger.persistence.model.EntityCapsModel;
import org.mercury_im.messenger.persistence.repository.EntityCapsRepository;

import java.io.StringReader;
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.Observable;
import io.reactivex.Single;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.functions.Consumer;
import io.reactivex.observers.DisposableSingleObserver;
import io.reactivex.schedulers.Schedulers;

public class EntityCapsStore implements EntityCapsPersistentCache {

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

    private final EntityCapsRepository entityCapsRepository;
    private final Map<String, DiscoverInfo> discoverInfoMap = new HashMap<>();

    private final CompositeDisposable disposable = new CompositeDisposable();
    private Observable<List<EntityCapsModel>> allEntityCaps;

    @Inject
    public EntityCapsStore(EntityCapsRepository repository) {
        this.entityCapsRepository = repository;
        populateFromDatabase();
    }

    private void populateFromDatabase() {
        allEntityCaps = entityCapsRepository.getAllEntityCaps();
        disposable.add(allEntityCaps.subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(entityCapsModels -> {
                    discoverInfoMap.clear();
                    for (EntityCapsModel c : entityCapsModels) {
                        DiscoverInfo info;
                        try {
                            XmlPullParser parser = PacketParserUtils.getParserFor(new StringReader(c.getXml()));
                            info = (DiscoverInfo) PacketParserUtils.parseIQ(parser);
                            discoverInfoMap.put(c.getNodeVer(), info);
                        } catch (Exception e) {
                            LOGGER.log(Level.SEVERE, "Error parsing EntityCaps: ", e);
                        }
                    }
                }, throwable -> LOGGER.log(Level.SEVERE, "Error accessing database", throwable)));
    }

    @Override
    public void addDiscoverInfoByNodePersistent(String nodeVer, DiscoverInfo info) {
        EntityCapsModel model = entityCapsRepository.newEntityCapsModel(nodeVer);
        CharSequence xml = info.toXML();
        String string = xml.toString();
        model.setXml(string);
        disposable.add(entityCapsRepository.insertOrReplaceEntityCaps(model)
                .subscribeOn(Schedulers.io())
                .subscribe());
    }

    @Override
    public DiscoverInfo lookup(String nodeVer) {
        LOGGER.log(Level.INFO, "Looking up caps for " + nodeVer + " in cache...");
        DiscoverInfo info = discoverInfoMap.get(nodeVer);
        LOGGER.log(Level.INFO, "Entry found: " + (info != null ? info.toXML().toString() : "null"));
        return info;
    }

    @Override
    public void emptyCache() {
        entityCapsRepository.deleteAllEntityCaps()
                .subscribeOn(Schedulers.io())
                .subscribe();
    }
}