package org.gcube.application.cms.concessioni.plugins;

import com.mongodb.util.JSON;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
import org.gcube.application.cms.concessioni.sdi.SDIManager;
import org.gcube.application.cms.concessioni.sdi.faults.SDIInteractionException;
import org.gcube.application.cms.plugins.MaterializationPlugin;
import org.gcube.application.cms.plugins.faults.InitializationException;
import org.gcube.application.cms.plugins.faults.MaterializationException;
import org.gcube.application.cms.plugins.faults.ShutDownException;
import org.gcube.application.cms.plugins.model.PluginDescriptor;
import org.gcube.application.cms.plugins.reports.InitializationReport;
import org.gcube.application.cms.plugins.reports.MaterializationReport;
import org.gcube.application.cms.plugins.reports.Report;
import org.gcube.application.cms.plugins.requests.MaterializationRequest;
import org.gcube.application.cms.serialization.Serialization;
import org.gcube.application.geoportal.common.model.JSONPathWrapper;
import org.gcube.application.geoportal.common.model.document.filesets.Materialization;
import org.gcube.application.geoportal.common.model.document.lifecycle.LifecycleInformation;
import org.gcube.application.geoportal.common.model.document.ProfiledDocument;
import org.gcube.application.geoportal.common.model.document.filesets.RegisteredFileSet;
import org.gcube.application.geoportal.common.model.profile.Field;
import org.gcube.application.geoportal.common.model.profile.HandlerDeclaration;
import org.gcube.application.geoportal.common.model.profile.Profile;

import java.util.List;

@Slf4j
public class SDIMaterializerPlugin implements MaterializationPlugin {

    @Data
    public static class MaterializationConfig{
        private String schemaField;
        private String documentPath;
    }

    SDIManager sdiManager;

    @Override
    public InitializationReport initInContext() throws InitializationException {
        return null;
    }

    @Override
    public InitializationReport init() throws InitializationException {
        return null;
    }

    @Override
    public void shutdown() throws ShutDownException {

    }

    /**
     * Expected params :
     *          -workspace MANDATORY
     *          -titleField
     *
     * @param request
     * @return
     * @throws MaterializationException
     */
    @Override
    public MaterializationReport materialize(MaterializationRequest request) throws MaterializationException {
        log.info("Materializer {} : Performing {} ",this.getDescriptor().getId(),request);
        ProfiledDocument profiledDocument=request.getDocument();
        Profile profile = request.getProfile();
        Document configuration=request.getParameters();
        Document profileConfiguration =null;
        for (HandlerDeclaration h : profile.getHandlers()) {
            if (h.getId().equals("SDI-Default-Materializer")) {
                profileConfiguration = h.getConfiguration();
            }
        }

        MaterializationReport report= new MaterializationReport();

        log.debug("Profile Configuration is {} ",profileConfiguration);
        try{
            JSONPathWrapper documentNavigator=new JSONPathWrapper(profiledDocument.getTheDocument().toJson());
            JSONPathWrapper profileNavigator=new JSONPathWrapper(profile.getSchema().toJson());

            for(Object fsConfigObj : configuration.get("registeredFileSetPaths", List.class)){
                log.debug("Managing {} ",fsConfigObj);
                MaterializationConfig fsConfig=Serialization.convert(fsConfigObj,MaterializationConfig.class);
                Field f = profileNavigator.getByPath(fsConfig.getSchemaField(), Field.class).get(0);

                // TODO Check if schema points to RegisteredFileSet

                for(RegisteredFileSet fs : documentNavigator.getByPath(fsConfig.getDocumentPath(),RegisteredFileSet.class)){
                    log.debug("Found {} ",fs);
                    configuration.putIfAbsent("basePersistencePath",profile.getId());
                    configuration.putIfAbsent("documentID",profiledDocument.get_id());
                    if(configuration.containsKey("titleField"))
                        configuration.putIfAbsent("layerTitle",fs.getString(configuration.getString("titleField")));
                    else configuration.putIfAbsent("layerTitle",fs.getUUID());

                    RegisteredFileSet obtained = sdiManager.materializeLayer(fs,configuration);
                    log.debug("Obtained {} ",obtained);
                    documentNavigator.set("$..[?(@.uuid == "+fs.getUUID()+")]",obtained);
                }
            }

            profiledDocument.setTheDocument(Document.parse(documentNavigator.getCtx().json()));
            report.setResultDocument(profiledDocument);
            report.setStatus(Report.Status.OK);
        }catch (SDIInteractionException e){
            log.error("Unable to materialize "+request,e);
            report.setStatus(Report.Status.ERROR);
            report.putMessage(e.getMessage());
        }catch (Throwable t){
            log.error("Unable to materialize "+request,t);
            report.setStatus(Report.Status.ERROR);
            report.putMessage(t.getMessage());
        }finally{
            return report;
        }
    }

    @Override
    public PluginDescriptor getDescriptor() {
        return null;
    }
}