package org.gcube.application.geoportal.service;

import org.bson.Document;
import org.gcube.application.cms.serialization.Serialization;
import org.gcube.application.geoportal.common.model.JSONPathWrapper;
import org.gcube.application.geoportal.common.model.document.ProfiledDocument;
import org.gcube.application.geoportal.common.model.document.filesets.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.document.filesets.Materialization;
import org.gcube.application.geoportal.common.model.document.filesets.RegisteredFileSet;
import org.gcube.application.geoportal.common.model.document.lifecycle.LifecycleInformation;
import org.gcube.application.geoportal.common.model.rest.RegisterFileSetRequest;
import org.gcube.application.geoportal.common.model.rest.StepExecutionRequest;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.gcube.application.geoportal.common.utils.StorageUtils;
import org.junit.Assert;
import org.junit.Test;

import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import java.util.Collections;
import java.util.List;

import static org.junit.Assert.assertTrue;

public class DummyProfiledDocumentTest extends AbstractProfiledDocumentsTests{

    @Override
    protected WebTarget baseTarget() {
        String testProfileId="profiledConcessioni";
        return target(InterfaceConstants.Methods.PROJECTS).path(testProfileId);
    }


    @Test
    public void registerNew() throws Exception {

        ProfiledDocument doc = createNew(new Document("field","value"));

        assertTrue(doc.getTheDocument().containsKey("field"));
        assertTrue(doc.getTheDocument().getString("field").equals("value"));
    }


    @Test
    public void edit() throws Exception {
        ProfiledDocument doc=createNew(new Document());
        String beforeJson=doc.getTheDocument().toJson();
        doc.getTheDocument().put("someStrangeField","someOtherRandomValue");
        String edited=doc.getTheDocument().toJson();
        Assert.assertNotEquals(beforeJson,doc.getTheDocument().toJson());
        doc=check(baseTarget().path(doc.get_id()).request(MediaType.APPLICATION_JSON).
                put(Entity.entity(doc.getTheDocument(), MediaType.APPLICATION_JSON)),ProfiledDocument.class);
        Assert.assertEquals(edited,doc.getTheDocument().toJson());
    }

    @Test
    public void testUploadFileSet() throws Exception {

        Document baseDoc=new Document();
        baseDoc.put("relazioneScavo",new Document("title","My Title"));

        ProfiledDocument doc = createNew(baseDoc);
        assertTrue(doc.getTheDocument().containsKey("relazioneScavo"));


        // Try set releazione scavo
        String parentPath="relazioneScavo";
        String fieldName="fileset";
        String fieldDefinition="relazioneScavo.children[?(@.fileset)]";

        String filename = "relazione.pdf";



        // INSERT ONE, MERGE INFO (NB default values already exist)
        doc = upload(
                new StorageUtils(),
                doc.get_id(),
                parentPath,fieldName,
                fieldDefinition,
                new Document("customField","customFieldValue"),
                RegisterFileSetRequest.ClashOptions.REPLACE_EXISTING,
                filename);

        JSONPathWrapper wrapper = new JSONPathWrapper(doc.getTheDocument().toJson());
        assertTrue("Relazione exists",wrapper.getMatchingPaths(parentPath).size()==1);
        RegisteredFileSet fs = Serialization.convert(wrapper.getByPath(parentPath+"."+fieldName).get(0),RegisteredFileSet.class);
        assertTrue(fs.getPayloads().size()==1);
        assertTrue(fs.getString("customField").equals("customFieldValue"));

    }

    @Test
    public void testSDI() throws Exception {
        // Create new
        ProfiledDocument doc = createNew(new Document("posizionamentoScavo",new Document("title","Mio pos")));

        // register filesets
        doc = upload(
                new StorageUtils(),
                doc.get_id(),
                "posizionamentoScavo","fileset",
                "posizionamentoScavo.children[?(@.fileset)]",
               null,
                RegisterFileSetRequest.ClashOptions.REPLACE_EXISTING,
                "pos.shp","pos.shx");

        System.out.println("Registered posizionamento, result is "+ Serialization.write(doc));

        // invoke step SUBMIT-FOR-REVIEW
        StepExecutionRequest req=new StepExecutionRequest();
        req.setStepID("SUBMIT-FOR-REVIEW");
        doc=step(doc.get_id(),req);
        System.out.println(doc);
        if(doc.getLifecycleInformation().getErrorMessages()!=null) {
            System.out.println("ERROR MESSAGES");
            doc.getLifecycleInformation().getErrorMessages().forEach(s -> System.out.println(s));
        }
        if(doc.getLifecycleInformation().getWarningMessages()!=null) {
            System.out.println("WARNING MESSAGES");
            doc.getLifecycleInformation().getWarningMessages().forEach(s -> System.out.println(s));
        }

        assertTrue(doc.getLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK));

        JSONPathWrapper wrapper = new JSONPathWrapper(doc.getTheDocument().toJson());
        RegisteredFileSet fs = Serialization.convert(wrapper.getByPath("$..fileset").get(0),RegisteredFileSet.class);
        assertTrue(fs!=null);
        assertTrue(fs.getPayloads().size()==2);
        assertTrue(fs.getMaterializations().size()>0);


        for(Object matObj : wrapper.getByPath("$..fileset."+RegisteredFileSet.MATERIALIZATIONS,List.class).get(0)){
            GCubeSDILayer layer = Serialization.convert(matObj, GCubeSDILayer.class);
            System.out.println("Checking Layer : "+layer);
            assertTrue(layer.getType().equals(GCubeSDILayer.GCUBE_SDY_LAYER_TYPE));
            assertTrue(layer.getOGCLinks().size()>0);
            assertTrue(layer.getPlatformInfo().size()>0);
            assertTrue(layer.getBBox()!=null);
        }

        // Checking platform info
        for(Object platformObj : wrapper.getByPath("$..[?(@."+ Materialization.TYPE +" == '"+GCubeSDILayer.GCUBE_SDY_LAYER_TYPE+"' )]")){
            Document platform=Serialization.asDocument(platformObj);
            assertTrue(platform.containsKey("_type"));
            if(platform.get("_type").equals("GeoServer")){
                assertTrue(platform.containsKey("layerName"));
                assertTrue(platform.containsKey("workspace"));
                assertTrue(platform.containsKey("storeName"));
                assertTrue(platform.containsKey("persistencePath"));
                assertTrue(platform.get("files",List.class).size()==2);
            }
        }


    }

}