/*
    * Copyright 2018-2022 Medical Information Systems Research Group (https://medical.zcu.cz),
    * Department of Computer Science and Engineering, University of West Bohemia.
    * Address: Univerzitni 8, 306 14 Plzen, Czech Republic.
    *
    * Author Petr Vcelak (vcelak@kiv.zcu.cz).
    *
    * This file is part of MRECore project.
    *
   * MRECore is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License.
   *
   * MRECore is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with MRECore. If not, see <http://www.gnu.org/licenses/>.
   */
  package cz.zcu.mre.service.data;
  
  import cz.zcu.mre.data.core.MREData;
  import cz.zcu.mre.data.core.MREStringLang;
  import cz.zcu.mre.mrelib.util.DateUtil;
  import java.time.LocalDate;
  import java.time.LocalDateTime;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import org.apache.jena.arq.querybuilder.AbstractQueryBuilder;
  import org.apache.jena.arq.querybuilder.AskBuilder;
  import org.apache.jena.arq.querybuilder.ConstructBuilder;
  import org.apache.jena.arq.querybuilder.DescribeBuilder;
  import org.apache.jena.arq.querybuilder.SelectBuilder;
  import org.apache.jena.arq.querybuilder.UpdateBuilder;
  import org.apache.jena.datatypes.xsd.impl.XSDDateType;
  import org.apache.jena.graph.Node;
  import org.apache.jena.graph.NodeFactory;
  import org.apache.jena.graph.Triple;
  import org.apache.jena.ontology.Individual;
  import org.apache.jena.query.Query;
  import org.apache.jena.rdf.model.Literal;
  import org.apache.jena.rdf.model.Resource;
  import org.apache.jena.rdf.model.ResourceFactory;
  import org.apache.jena.sparql.modify.request.UpdateDeleteInsert;
  import org.apache.jena.vocabulary.RDF;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * 
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public class SPARQLBuilderImpl implements SPARQLBuilder {
  
      private static final Logger LOG = LoggerFactory.getLogger(SPARQLBuilderImpl.class);
  
      //@Autowired
      private MREDataService dataService;
  
      /**
       * Default constructor.
       */
      public SPARQLBuilderImpl() {
      }
  
      public SPARQLBuilderImpl(MREDataService dataService) {
          this.dataService = dataService;
      }
  
      public void setDataService(MREDataService dataService) {
          this.dataService = dataService;
      }
  
      /**
       * Build ASK query for the instance.
       *
       * @param instance The instance.
       * @return Prepared Query instance.
       */
      @Override
      public Query ask(Object instance) {
  
          AbstractQueryBuilder b = builderQuery(QUERY.ASK, instance, false, true);
          return b.build();
      }
  
      /**
       * Build ASK query for test if the instance URI and type is
       * persistent/exist. This method produces only one triple (instance URI,
       * rdf:type property and class URI for object) in the WHERE part.
       *
       * @param instance The instance.
       * @return The ASK Query with only one triple (instance URI, rdf:type
       * property and class URI for object).
      */
     @Override
     public Query askExist(Object instance) {
 
         AskBuilder builder = (AskBuilder) builderQuery(QUERY.ASK, instance, false, false);
 
         return builder.build();
     }
 
     /**
      * Build ASK query for test if the instance is persistent/exist. This method
      * produces only one triple (instance URI, rdf:type property and class URI
      * for object) in the WHERE part.
      *
      * @param instance The instance.
      * @return The ASK Query with only one triple (instance URI, rdf:type
      * property and class URI for object).
      */
     @Override
     public Query askExistAll(Object instance) {
 
         AskBuilder builder = (AskBuilder) builderQuery(QUERY.ASK, instance, false, true);
 
         return builder.build();
     }
     
     /**
      * Generate SELECT for list of instances that is based on the instance
      * (type) and its attributes.
      *
      * This can work as query for "select all instances" and "select instance(s)
      * with value of one/more attributes".
      *
      * @param instance The instance for building a complete general SELECT.
      * @return Query instance that defines member attributes and rdf:type.
      */
     @Override
     public Query select(Object instance) {
 
         return builderQuery(QUERY.SELECT, instance, false, true).build();
     }
 
     /**
      * Generate SELECT for list all instances that is based on the instance
      * (type) and NO its attribute values.
      *
      * This can work as query for "select all instances" and "select instance(s)
      * with value of one/more attributes".
      *
      * @param instance The instance for building a complete general SELECT.
      * @return Query instance that defines member attributes and rdf:type.
      */
     @Override
     public Query selectAll(MREData instance) {
 
         return selectAllBuilder(instance).build();
     }
 
     @Override
     public SelectBuilder selectAllBuilder(MREData instance) {
 
         return (SelectBuilder) builderQuery(QUERY.SELECT, instance, false, false);
     }
 
     /**
      * Build query to SELECT the resource rdf:type.
      *
      * @param resourceURI The resource URI as a String.
      * @return Prepared Query instance.
      */
     @Override
     public Query selectType(String resourceURI) {
 
         return selectType(ResourceFactory.createResource(resourceURI));
     }
 
     /**
      * Build query to SELECT the resource rdf:type.
      *
      * @param resource The resource URI.
      * @return Prepared Query instance.
      */
     @Override
     public Query selectType(Resource resource) {
 
         SelectBuilder selectBuilder = new SelectBuilder();
         selectBuilder.setDistinct(true);
         selectBuilder.addVar("type");
         selectBuilder.addWhere(Triple.create(resource.asNode(), RDF.type.asNode(), NodeFactory.createVariable("type")));
 
         return selectBuilder.build();
     }
 
     /**
      * Build DELETE update query for the instance removal.
      *
      * @param instance The instance to remove.
      * @return Prepared UpdateBuilder instance.
      */
     @Override
     public UpdateBuilder delete(Object instance) {
 
         return builderUpdate(QUERY.DELETE, instance, false);
     }
 
     /**
      * Build DELETE update query for the deep instance removal. Remove
      * recursively all sub-instances.
      *
      * @param instance The instance to deeply remove.
      * @return Prepared UpdateBuilder instance.
      */
     @Override
     public UpdateBuilder deleteAll(Object instance) {
 
         return builderUpdate(QUERY.DELETE, instance, true);
     }
 
     /**
      * Build INSERT update query for making instance persistent.
      *
      * @param instance The instance for insert.
      * @return Prepared UpdateBuilder instance.
      */
     @Override
     public UpdateBuilder insert(Object instance) {
         return builderUpdate(QUERY.INSERT, instance, false);
     }
 
     /**
      * Build INSERT update query for making the instance persistent. Inserts
      * recursively all sub-instances.
      *
      * @param instance The instance for insert.
      * @return Prepared UpdateBuilder instance.
      */
     @Override
     public UpdateBuilder insertAll(Object instance) {
         return builderUpdate(QUERY.INSERT, instance, true);
     }
 
     /**
      * Build DELETE INSERT update query for updating the instance.
      *
      * @param instanceOld The old instance is for delete part.
      * @param instanceNew The new instance is for insert part.
      * @return Prepared UpdateDeleteInsert builder instance.
      */
     @Override
     public UpdateDeleteInsert update(Object instanceOld, Object instanceNew) {
 
         return update(instanceOld, instanceNew, false);
     }
 
     /**
      * Build DELETE INSERT update query for updating the instance. Prepare
      * delete and inserts recursively for all sub-instances.
      *
      * @param instanceOld The old instance is for delete part.
      * @param instanceNew The new instance is for insert part.
      * @return Prepared UpdateDeleteInsert builder instance.
      */
     @Override
     public UpdateDeleteInsert updateAll(Object instanceOld, Object instanceNew) {
         return update(instanceOld, instanceNew, true);
     }
 
     /**
      * Build DELETE INSERT update query based on old and new instances of
      * object.
      *
      * @param instanceOld The old (previous) version.
      * @param instanceNew The new (actual) version.
      * @param deep Produce update query on the top level or recursive (deep)
      * one.
      * @return UpdateDeleteInsert query builder instance.
      */
     private UpdateDeleteInsert update(Object instanceOld, Object instanceNew, boolean deep) {
 
         List<Triple> triplesOld = buildTriples(QUERY.DELETE, instanceOld, deep);
         List<Triple> triplesNew = buildTriples(QUERY.INSERT, instanceNew, deep);
 
         UpdateDeleteInsert update = new UpdateDeleteInsert();
         triplesOld.stream().forEach(t -> update.getDeleteAcc().addTriple(t));
         triplesNew.stream().forEach(t -> update.getInsertAcc().addTriple(t));
 
         return update;
     }
 
     /**
      * Build the query (ASK, CONSTRUCT, DESCRIBE, SELECT) on the instance.
      *
      * It is not possible to make UPDATE queries by this method.
      *
      * @param type The query type.
      * @param instance The instance.
      * @param deep Indicates if method should generate query for all
      * sub-instances (deep=true).
      * @return Instance of builder that implements AbstractQueryBuilder:
      * AskBuilder, ConstructBuilder, DescribeBuilder or SelectBuilder.
      */
     private AbstractQueryBuilder builderQuery(QUERY type, Object instance, boolean deep, boolean withValues) {
 
         AbstractQueryBuilder queryBuilder = null;
         List<Triple> triples = buildTriples(type, instance, deep);
 
         switch (type) {
             case ASK:
                 AskBuilder askBuilder = new AskBuilder();
                 //triples.stream().forEach(t -> askBuilder.addWhere(t));
 
                 if (!withValues) {
                     triples.clear();
 
                     // rdf:type only, no WHERE triples
                     MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
                     addTripleRDFType(triples, fields, instance);
                 }
                 triples.stream().forEach(t -> {
                     askBuilder.addWhere(t);
                 });
 
                 queryBuilder = askBuilder;
                 break;
             case CONSTRUCT:
                 ConstructBuilder constructBuilder = new ConstructBuilder();
                 triples.stream().forEach(t -> constructBuilder.addWhere(t));
                 queryBuilder = constructBuilder;
                 break;
             case DESCRIBE:
                 DescribeBuilder describeBuilder = new DescribeBuilder();
                 triples.stream().forEach(t -> describeBuilder.addWhere(t));
                 queryBuilder = describeBuilder;
                 break;
 
             case SELECT:
                 SelectBuilder selectBuilder = new SelectBuilder();
 
                 if (!withValues) {
                     // rdf:type only, no WHERE triples
                     MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
                     triples.clear();
                     addTripleRDFType(triples, fields, instance);
                 }
                 triples.stream().forEach(t -> {
                     selectBuilder.addWhere(t);
                 });
 
                 selectAddVariables(selectBuilder, instance);
                 selectAddWhereVariables(selectBuilder, instance);
 
                 // add VALUE keyword with a resource value for ?mreuri
                 Resource subject = ((MREData) instance).getResource();
                 if (subject != null) {
                     selectBuilder.addValueVar(SPARQLBuilderVariables.VARIABLE_URI, ((MREData) instance).getResource());
                 }
 
                 queryBuilder = selectBuilder;
                 break;
 
             default: {
                 throw new IllegalArgumentException("Method does not produce update queries.");
             }
         }
 
         return queryBuilder;
     }
 
     /**
      * Build the update query (INSERT, DELETE) on the instance.
      *
      * It is not possible to make ASK, CONSTRUCT, DESCRIBE or SELECT queries by
      * this method.
      *
      * @param type The query type.
      * @param instance The instance.
      * @param deep Indicates if method should generate query for all
      * sub-instances (deep=true).
      * @return Instance of builder that implements AbstractQueryBuilder:
      * AskBuilder, ConstructBuilder, DescribeBuilder or SelectBuilder.
      */
     private UpdateBuilder builderUpdate(QUERY type, Object instance, boolean deep) {
 
         UpdateBuilder updateBuilder = new UpdateBuilder();
         List<Triple> triples = buildTriples(type, instance, deep);
 
         switch (type) {
 
             case INSERT:
                 triples.stream().forEach(t -> updateBuilder.addInsert(t));
                 break;
 
             case DELETE:
                 triples.stream().forEach(t -> updateBuilder.addDelete(t));
                 break;
 
             case UPDATE:
                 // TODO remove all triples and new ones for the instance object.
                 break;
 
             default: {
                 throw new IllegalArgumentException("Method does not produce update queries.");
             }
         }
 
         return updateBuilder;
     }
 
     /**
      * Generate the List of Triple instances for the instance.
      *
      * @param type The query type.
      * @param instance The instance.
      * @param deep Indicates if method should generate Triple also for all
      * sub-instances (deep=true).
      * @return List of Triple instances.
      */
     private List<Triple> buildTriples(QUERY type, Object instance, boolean deep) {
 
         List<Triple> triples = new ArrayList<>();
 
         if (type == null || instance == null) {
             return triples;
         }
 
         checkMREData(type, instance);
 
         // is primitive data type?
         if (dataService.isPrimitiveDataType(instance)) {
 
             LOG.debug("Primitive data type {} has value {}", instance.getClass(), instance);
             return triples;
         }
 
         MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
         for (int i = 0; i < fields.length; i++) {
 
             Set<Object> fieldValues = fields[i].getValue();
 
             // ignore empty fields
             if (fieldValues.isEmpty()) {
                 continue;
             }
 
             // add rdf:type only once when i=0
             if (i == 0) {
                 addTripleRDFType(triples, fields, instance);
             }
 
             // loop over all values
             Iterator<Object> it = fieldValues.iterator();
             while (it.hasNext()) {
                 Object object = it.next();
 
                 // ignore empty values
                 if (object == null) {
                     continue;
                 }
 
                 if (object instanceof List) {
 
                     // save list of objects
                     List list = (List) object;
                     for (Object o : list) {
                         LOG.debug("Build triples - {}, List field '{}'", o.getClass(), fields[i].getName());
                         addTriples(triples, type, fields[i], o, deep);
                         if (deep) {
                             triples.addAll(buildTriples(type, o, deep));
                         }
                     }
 
                 } else if (object instanceof Set) {
 
                     // save set of objects
                     Set set = (Set) object;
                     for (Object o : set) {
                         LOG.debug("Build triples - {}, Set field '{}'", o.getClass(), fields[i].getName());
                         addTriples(triples, type, fields[i], o, deep);
                         if (deep) {
                             triples.addAll(buildTriples(type, o, deep));
                         }
                     }
 
                 } else if (object instanceof MREData) {
 
                     // FIX initialize if MREData instance has no URI -- need for deep insert/delete
                     if (!((MREData) object).hasURI() && (type == QUERY.INSERT || type == QUERY.DELETE)) {
                         ((MREData) object).generateNewResource();
                     }
 
                     LOG.debug("Build triples - {}, MREData field '{}', type {}", instance.getClass(), fields[i].getName(), object.getClass());
                     addTripleObject(triples, type, fields[i], object);
 
                 } else if (object instanceof Individual) {
 
                     LOG.debug("Build triples - {}, Individual field '{}', type {}", instance.getClass(), fields[i].getName(), object.getClass());
                     addTripleObject(triples, type, fields[i], object);
 
                 } else {
                     LOG.debug("Build triples - {}, primitive type field '{}', type {}", instance.getClass(), fields[i].getName(), object.getClass());
                     addTriples(triples, type, fields[i], object, deep);
                 }
             }
         }
 
         // return triples
         return triples;
     }
 
     /**
      * Build the rdf:type triple and add to the list.
      *
      * @param triples List of Triple instances.
      * @param fields Preprocessed all fields of the instance.
      * @param i The number of active field that should be processed.
      * @param instance The instance.
      */
     private static void addTripleRDFType(List<Triple> triples, MREDataFieldValue[] fields, Object instance) {
 
         int i = 0;
 
         Node s;
         if (fields[i].getSubject() != null) {
             s = NodeFactory.createURI(fields[i].getSubject());
         } else {
             s = VARIABLE_URI;
         }
 
         Node p = RDF.type.asNode();
         Node o;
 
         String object;
         if (fields[i].getConfig().getTypeRDF() == null) {
             object = fields[i].getConfig().getOntology().concat(instance.getClass().getSimpleName());
         } else {
             object = fields[i].getConfig().getTypeRDF();
         }
         o = NodeFactory.createURI(object);
 
         // add triple
         triples.add(Triple.create(s, p, o));
     }
 
     /**
      * Build and add triples to the list.
      *
      * @param triples List of Triple instances.
      * @param fields Preprocessed all fields of the instance.
      * @param i The number of active field that should be processed.
      * @param instance The instance.
      */
     private void addTriples(List<Triple> triples, QUERY type, MREDataFieldValue field, Object object, boolean deep) {
 
         if (object == null) {
             return;
         }
 
         if (object instanceof List) {
             triples.addAll(buildTriples(type, object, deep));
         } else if (object instanceof Set) {
             triples.addAll(buildTriples(type, object, deep));
         } else if (object instanceof Individual) {
             addTripleObject(triples, type, field, ((Individual) object).getURI());
         } else if (object instanceof MREData) {
             checkMREData(type, (MREData) object);
             addTripleObject(triples, type, field, ((MREData) object).getUri());
         } else {
             addTripleDatatype(triples, type, field, object);
         }
     }
 
     /**
      * Check MREData instance if resource URI is defined. Generate a new one If
      * not.
      *
      * @param type Query type.
      * @param instance The instance.
      */
     private static void checkMREData(QUERY type, Object instance) {
 
         if (type == QUERY.INSERT && instance instanceof MREData && !((MREData) instance).hasURI()) {
             ((MREData) instance).generateNewResource();
             LOG.info("Auto-generated new resource URI for the instance: {}", ((MREData) instance).getResource());
         }
 
     }
 
     /**
      * Build and add triples for objects to the list.
      *
      * @param triples List of Triple instances.
      * @param type The query type.
      * @param field Preprocessed field of the instance.
      * @param object The value as an Object.
      */
     private static void addTripleObject(List<Triple> triples, QUERY type, MREDataFieldValue field, Object object) {
 
         if (object == null) {
             return;
         }
 
         if (field.getSubject() == null) {
             throw new IllegalArgumentException("Subject cannot be null.");
         }
 
         Node s = NodeFactory.createURI(field.getSubject());
         Node p = NodeFactory.createURI(field.getProperty().toString());
         Node o;
 
         if (object instanceof MREData) {
             // add MREData instance resource URI
             o = ((MREData) object).getResource().asNode();
         } else if (object instanceof Individual) {
             o = ((Individual) object).asNode();
         } else if (object instanceof String) {
             o = NodeFactory.createURI(((String) object));
         } else {
             LOG.warn("Unsupported Java {} value {}. Using toString() method.", object.getClass(), object);
             // use toString() for other Java classes
             o = NodeFactory.createURI(object.toString());
         }
 
         // add triple
         triples.add(Triple.create(s, p, o));
     }
 
     /**
      * Build and add triples for objects to the list.
      *
      * @param triples List of Triple instances.
      * @param type The query type.
      * @param field Preprocessed field of the instance.
      * @param value The value as an Object.
      */
     private static void addTripleDatatype(List<Triple> triples, QUERY type, MREDataFieldValue field, Object value) {
 
         Node s;
         if (field.getSubject() != null) {
             s = NodeFactory.createURI(field.getSubject());
         } else {
             s = VARIABLE_URI;
         }
 
         Node p = NodeFactory.createURI(field.getProperty().toString());
         Node o = null;
 
         Literal literalValue;
         if (value instanceof Date) {
             // XSD Date format as String
             String date = DateUtil.xsdDate((Date) value);
             literalValue = ResourceFactory.createTypedLiteral(date);
 
         } else if (value instanceof LocalDate) {
             // XSD Date format as String
             LocalDate localDate = (LocalDate) value;
             String date = localDate.toString();
             literalValue = ResourceFactory.createTypedLiteral(date, XSDDateType.XSDdate);
 
         } else if (value instanceof LocalDateTime) {
             // XSD Date format as String
             LocalDateTime localDateTime = (LocalDateTime) value;
             String dateTime = localDateTime.toString();
 
             // TODO check for dateTime format (due to ignored zeros) to fill in correct date type
             literalValue = ResourceFactory.createTypedLiteral(dateTime, XSDDateType.XSDdateTime);
 
         } else {
             // literal value
             literalValue = createLiteralValue(type, field, value);
         }
 
         // output literal value in N-TRIPLE
         if (literalValue != null) {
             o = literalValue.asNode();
         }
 
         // add triple
         triples.add(Triple.create(s, p, o));
     }
 
     /**
      * Create a Literal value for the value.
      *
      * @param type Query type.
      * @param field Preprocessed field of the instance.
      * @param value The value as an Object.
      * @return The Literal instance or null.
      */
     private static Literal createLiteralValue(QUERY type, MREDataFieldValue field, Object value) {
 
         if (value == null) {
             return null;
         }
 
         if (value instanceof String) {
             // just string, no language, (default)
             return ResourceFactory.createPlainLiteral((String) value);
 
         } else if (value instanceof MREStringLang) {            
 
             // no lang specified here means plain literal
             if (((MREStringLang) value).getLang() == null) {
                 return ResourceFactory.createPlainLiteral(((MREStringLang) value).getString());
             }
 
             // string with language
             return ResourceFactory.createLangLiteral(((MREStringLang) value).getString(), ((MREStringLang) value).getLang());
         }
 
         // typed literal
         return ResourceFactory.createTypedLiteral(value);
     }
 
     /**
      * Get the string with all variable names to the SELECT part.
      *
      * @param instance MREData instance.
      * @return String with all variable names for the instance class/type.
      */
     private void selectAddVariables(SelectBuilder selectBuilder, Object instance) {
 
         selectBuilder.addVar(VARIABLE_URI);
         selectBuilder.addVar(VARIABLE_TYPE);
 
         MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
         for (MREDataFieldValue field : fields) {
             selectBuilder.addVar(field.getName());
         }
     }
 
     /**
      * Get WHERE part (triples) with variables definition as a String.
      *
      * @param instance MREData instance.
      * @return String with variables for SELECT clause. The first variable is
      * ?mreuri (see static field VARIABLE_URI), the second is ?mretype (see
      * static field VARIABLE_TYPE) and all other variables follows.
      */
     private void selectAddWhereVariables(SelectBuilder selectBuilder, Object instance) {
 
         MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
 
         // add default variables for all generated SELECT queries (URI, rdf:type)
         selectBuilder.addWhere(VARIABLE_URI, RDF.type, VARIABLE_TYPE);
 
         // add instance specific where triples with variable
         for (MREDataFieldValue field : fields) {
 
             // add OPTIONAL keyword for WHERE clause of SELECT
             selectBuilder.addOptional(VARIABLE_URI, field.getProperty(), NodeFactory.createVariable(field.getName()));
         }
     }
 
 }