gcube-cms-suite/geoportal-service/src/main/java/org/gcube/application/geoportal/service/engine/providers/ucd/UCDManager.java

package org.gcube.application.geoportal.service.engine.providers.ucd;

import lombok.extern.slf4j.Slf4j;
import org.gcube.application.cms.caches.AbstractScopedMap;
import org.gcube.application.cms.caches.Engine;
import org.gcube.application.cms.caches.ObjectManager;
import org.gcube.application.cms.implementations.ImplementationProvider;
import org.gcube.application.geoportal.common.model.rest.ConfigurationException;
import org.gcube.application.geoportal.common.model.rest.QueryRequest;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import org.gcube.application.geoportal.common.utils.ContextUtils;
import org.gcube.application.geoportal.service.engine.mongo.UCDManagerI;
import org.gcube.application.geoportal.service.engine.mongo.UCDMongoManager;
import org.gcube.application.geoportal.service.model.internal.faults.RegistrationException;

import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

import static java.lang.Thread.sleep;

@Slf4j
public class UCDManager extends AbstractScopedMap<UCDManagerI> implements UCDManagerI {



    public UCDManager() {
        super("UCD MANAGER");
    }


    @Override
    public Iterable<UseCaseDescriptor> query(QueryRequest queryRequest) throws ConfigurationException {
       return getMongoManager().query(queryRequest);
    }

    @Override
    public void deleteById(String id, boolean force) throws RegistrationException, ConfigurationException {
        log.warn("Trying to delete {} [force : {}]",id,force);
        // NB Check for existing ID
        UseCaseDescriptor found = getById(id);
        if(found!=null) {
            // TODO validate DELETE REQUEST
            // TODO STORE UCD
            // forceUpdateCache();
            throw new WebApplicationException("TO IMPLEMENT ", Response.Status.INTERNAL_SERVER_ERROR);
        } else
            throw new WebApplicationException("No Matching UCD with ID "+id, Response.Status.NOT_FOUND);
    }

    @Override
    public UseCaseDescriptor put(UseCaseDescriptor desc) throws ConfigurationException, RegistrationException {
        log.debug("Update {} ",desc.getId());
        // NB Check for existing ID
        UseCaseDescriptor found = getById(desc.getId());
        if(found!=null) {
            // TODO validate UPDATE
            // TODO STORE UCD
            // forceUpdateCache();
            throw new WebApplicationException("Update Feature is yet TO IMPLEMENT ", Response.Status.INTERNAL_SERVER_ERROR);
        } else {
            // create new
            registerNew(desc);
            do{
                log.info("Waiting for backend to update.. ");
                try{sleep(1000);}catch (Throwable t){}
                forceUpdateCache();
                found =getById(desc.getId());
            } while(found == null);

            return found;
        }
    }

    @Override
    public UseCaseDescriptor getById(String id) throws ConfigurationException, RegistrationException {
        // GET from mongo cache
        UCDMongoManager mongo=getMongoManager();
        UseCaseDescriptor toReturn=mongo.getById(id);
        log.debug("UCD ID : {} from mongo is {} ",id,toReturn);
        if(toReturn == null) {
            // IF void try from ProfileEngine
            toReturn =getLiveMap().get(id);
           if(toReturn != null ){
                log.debug("Force update of live map {} from live map ",id);
                toReturn = mongo.put(toReturn);
            }
        }
        return toReturn;
    }


    private ProfileMap getLiveMap() throws ConfigurationException {
      return ImplementationProvider.get().getProvidedObjectByClass(ProfileMap.class);
    };


    private void registerNew(UseCaseDescriptor ucd) throws ConfigurationException {
        Engine<ProfileMap> engine=ImplementationProvider.get().getEngineByManagedClass(ProfileMap.class);
        if(engine instanceof ObjectManager){
            ((ObjectManager<UseCaseDescriptor>)engine).insert(ucd);
        } else throw new ConfigurationException("Profile Map Engine is not Object Manager. Actual implementation is "+engine.getClass());
    }

    private UCDMongoManager getMongoManager() throws ConfigurationException {
        return new UCDMongoManager();
    }


    @Override
    protected UCDManagerI retrieveObject(String context) throws ConfigurationException {
        forceUpdateCache();
        return this;
    }


    ConcurrentHashMap<String,Boolean> cleanedCaches= new ConcurrentHashMap<>();


    private void forceUpdateCache() throws ConfigurationException {
        log.info("UPDATING PROFILE CACHE..");
        final UCDMongoManager manager = getMongoManager();
        manager.deleteAll();
        final AtomicLong counter= new AtomicLong(0l);
        ProfileMap liveMap=getLiveMap();
        log.debug("LiveMap size is {} ",liveMap.size());
        for (Map.Entry<String, UseCaseDescriptor> entry : liveMap.entrySet()) {
            UseCaseDescriptor useCaseDescriptor = entry.getValue();
            try {
                log.debug("Updateing cache with {} ", useCaseDescriptor.getId());
                // insert/update into DB
                manager.put(useCaseDescriptor);
            } catch (RegistrationException e) {
               log.warn("Unable to cache UCD {}",entry.getKey(),e);
            }
        }
        log.info("Cached : {} UCDs in {} ",counter.get(),ContextUtils.getCurrentScope());
    }
}