/*
    * 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.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import org.apache.jena.datatypes.xsd.XSDDatatype;
  import org.apache.jena.datatypes.xsd.impl.XSDDateType;
  import org.apache.jena.ontology.Individual;
  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.vocabulary.RDF;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   *
   * SPARQL Builder String Implementation.
   *
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public class SPARQLBuilderStringImpl implements SPARQLBuilderString {
  
      private static final Logger LOG = LoggerFactory.getLogger(SPARQLBuilderStringImpl.class);
      private static final String EMPTY_STRING = "";
      private static final String GRAPH_BEGIN = "{ GRAPH ";
      private static final String GRAPH_NAME = "<NAME>";
      private static final String GRAPH_END = "}";
  
      private static final String TEMPLATE_ASK = "ASK { TRIPLES }";
      private static final String TEMPLATE_INSERT = "INSERT DATA GRAPH_BEGIN { TRIPLES } GRAPH_END";
      private static final String TEMPLATE_DELETE = "DELETE DATA GRAPH_BEGIN { TRIPLES } GRAPH_END";
      private static final String TEMPLATE_SELECT = "SELECT DISTINCT ATTRIBUTES WHERE {\nTRIPLES}";
  
      private String graph = null;
  
      //@Autowired
      private MREDataService dataService;
  
      /**
       * Default constructor.
       */
      public SPARQLBuilderStringImpl() {
      }
  
      public SPARQLBuilderStringImpl(MREDataService dataService) {
          this.dataService = dataService;
      }
  
      @Override
      public String ask(Object instance) {
          return buildQuery(QUERY.ASK, instance, false);
      }
  
      @Override
      public String ask(String queryTriples) {
  
          String ask = TEMPLATE_ASK.replace("TRIPLES", queryTriples);
          return ask;
      }
  
      @Override
      public String insert(Object instance) {
          return buildQuery(QUERY.INSERT, instance, false);
      }
  
      @Override
      public String insertAll(Object instance) {
          return buildQuery(QUERY.INSERT, instance, true);
      }
  
      @Override
     public String delete(Object instance) {
         return buildQuery(QUERY.DELETE, instance, false);
     }
 
     @Override
     public String deleteAll(Object instance) {
         return buildQuery(QUERY.DELETE, instance, true);
     }
 
     @Override
     public String update(Object instanceOld, Object instanceNew) {
         StringBuilder sb = new StringBuilder();
 
         sb.append(buildQuery(QUERY.DELETE, instanceOld, false));
         sb.append(buildQuery(QUERY.INSERT, instanceNew, false));
 
         return sb.toString();
     }
 
     @Override
     public String updateAll(Object instanceOld, Object instanceNew) {
         StringBuilder sb = new StringBuilder();
 
         sb.append(buildQuery(QUERY.DELETE, instanceOld, true));
         sb.append(buildQuery(QUERY.INSERT, instanceNew, true));
 
         return sb.toString();
     }
 
     /**
      * 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 Instance that defines member attributes and rdf:type.
      * @return Generated SELECT query.
      */
     @Override
     public String select(Object instance) {
 
         return buildQuery(QUERY.SELECT, instance, false);
     }
 
     private String buildQuery(QUERY type, Object instance, boolean deep) {
 
         StringBuilder query = new StringBuilder();
         // TODO query template
         switch (type) {
             case INSERT:
                 query.append(TEMPLATE_INSERT);
                 break;
             case DELETE:
                 query.append(TEMPLATE_DELETE);
                 break;
             case SELECT:
                 query.append(TEMPLATE_SELECT);
                 break;
             case ASK:
                 query.append(TEMPLATE_ASK);
                 break;
             default:
                 break;
         }
 
         String result = query.toString();
 
         if (graph != null) {
             result = result.replace("GRAPH_BEGIN", GRAPH_BEGIN);
             String graphName = GRAPH_NAME.replace("NAME", graph);
             result = result.replace("GRAPH", "GRAPH " + graphName);
             result = result.replace("GRAPH_END", GRAPH_END);
         } else {
             result = result.replace("GRAPH_BEGIN", "");
             result = result.replace("GRAPH_END", "");
         }
 
         String queryWherePart = buildTriples(type, instance, deep);
 
         if (type == QUERY.SELECT) {
             // all where variables definition
             queryWherePart = queryWherePart.concat(getSelectWhereVariables(instance));
 
             // replace all instance URIs by variable
             String uri = getInstanceURI(instance);
             if (uri != null) {
                 // replace all subject URIs to SELECT_VARIABLE_URI
                 queryWherePart = queryWherePart.replaceAll("<" + uri + ">", SELECT_VARIABLE_URI);
 
                 // insert: VALUES ?mreuri {<the_uri>}
                 queryWherePart = queryWherePart.replaceFirst(SELECT_VARIABLE_URI.replace("?", "\\?"), " VALUES " + SELECT_VARIABLE_URI + " { <" + uri + "> }\n " + SELECT_VARIABLE_URI);
             }
 
             result = result.replace("ATTRIBUTES", getSelectVariables(instance));
         }
 
         result = result.replace("TRIPLES", queryWherePart);
 
         return result;
     }
 
     private String buildTriples(QUERY type, Object instance, boolean deep) {
 
         if (type == null) {
             return "";
         }
 
         StringBuilder sb = new StringBuilder();
 
         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;
             }
 
             // rdf:type only once
             if (i == 0) {
                 buildTripleRDFType(sb, fields, i, instance);
                 sb.append("\n");
             }
 
             // 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());
                         sb.append(buildTriple(type, fields[i], o, deep));
                         if (deep) {
                             sb.append(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());
                         sb.append(buildTriple(type, fields[i], o, deep));
                         if (deep) {
                             sb.append(buildTriples(type, o, deep));
                         }
                     }
 
                 } else if (object instanceof MREData
                         || object instanceof Individual) {
 
                     LOG.debug("Build triples - {}, MREData field '{}', type {}", instance.getClass(), fields[i].getName(), object.getClass());
                     sb.append(buildTripleObject(type, fields[i], object, deep));
 
                 } else {
                     LOG.debug("Build triples - {}, primitive type field '{}', type {}", instance.getClass(), fields[i].getName(), object.getClass());
                     sb.append(buildTriple(type, fields[i], object, deep));
                 }
             }
         }
 
         // The query.
         String query = sb.toString();
 
         // return the query
         return query;
     }
 
     private void buildTripleRDFType(StringBuilder sb, MREDataFieldValue[] fields, int i, Object instance) {
 
         sb.append(" <").append(fields[i].getSubject()).append("> ");
         sb.append("<").append(RDF.type).append("> ");
         if (fields[i].getConfig().getTypeRDF() == null) {
             sb.append("<").append(fields[i].getConfig().getOntology().concat(instance.getClass().getSimpleName())).append("> .");
         } else {
             sb.append("<").append(fields[i].getConfig().getTypeRDF()).append("> .");
         }
     }
 
     /**
      * 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 String getSelectVariables(Object instance) {
 
         StringBuilder variables = new StringBuilder();
         MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
         variables.append(SELECT_VARIABLE_URI);
         variables.append(" ");
         variables.append(SELECT_VARIABLE_TYPE).append(" ");
         for (MREDataFieldValue field : fields) {
             variables.append("?");
             variables.append(field.getName());
             variables.append(" ");
         }
 
         return variables.toString();
     }
 
     /**
      * 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 SELECT_VARIABLE_URI), the second is ?mretype
      * (see static field SELECT_VARIABLE_TYPE) and all other variables follows.
      */
     private String getSelectWhereVariables(Object instance) {
 
         MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
 
         StringBuilder variables = new StringBuilder();
 
         // default variables for all generated SELECT queries (URI, rdf:type)
         variables.append(" ");
         variables.append(SELECT_VARIABLE_URI);
         variables.append(" <");
         variables.append(RDF.type);
         variables.append("> ");
         variables.append(SELECT_VARIABLE_TYPE);
         variables.append(" .");
         variables.append("\n");
 
         for (MREDataFieldValue field : fields) {
             // put OPTIONAL keyword for SELECT
             variables.append(" OPTIONAL {");
             variables.append(" ");
             variables.append(SELECT_VARIABLE_URI);
             variables.append(" <");
             variables.append(field.getProperty());
             variables.append("> ?");
             variables.append(field.getName());
             variables.append(" .");
             variables.append(" }"); // end OPTIONAL block
             variables.append("\n");
         }
 
         return variables.toString();
     }
 
     /**
      * Get instance URI.
      *
      * @param instance MREData instance.
      * @return URI as a String or null.
      */
     private String getInstanceURI(Object instance) {
 
         if (instance instanceof MREData) {
             MREData data = (MREData) instance;
             if (data.hasURI()) {
                 return data.getUri();
             }
         }
 
         return null;
     }
 
     private String buildTriple(QUERY type, MREDataFieldValue field, Object object, boolean deep) {
 
         if (object == null) {
             return EMPTY_STRING;
         }
 
         //LOG.debug("Build triple - {} field {}", object.getClass(), field.getName());
         if (object instanceof List) {
             return buildTriples(type, object, deep);
         } else if (object instanceof Set) {
             return buildTriples(type, object, deep);
         }
 
         if (object instanceof Individual) {
             return buildTripleObject(type, field, ((Individual) object).getURI(), deep);
         } else if (object instanceof MREData) {
             return buildTripleObject(type, field, ((MREData) object).getUri(), deep);
         } else {
             return buildTripleDatatype(type, field, object);
         }
     }
 
     private String buildTripleObject(QUERY type, MREDataFieldValue field, Object object, boolean deep) {
 
         if (object == null) {
             return EMPTY_STRING;
         }
 
         StringBuilder sb = new StringBuilder();
 
         sb.append(" <").append(field.getSubject()).append("> ");
         sb.append("<").append(field.getProperty().toString()).append("> ");
 
         sb.append("<");
         if (object instanceof MREData) {
             // add MREData instance resource URI
             sb.append(((MREData) object).getResource().getURI());
         } else if (object instanceof Individual) {
             sb.append(((Individual) object).getURI());
         } else if (object instanceof String) {
             sb.append(((String) object));
         } else {
             LOG.warn("Unsupported Java {} value {}. Using toString() method.", object.getClass(), object);
             // use toString() for other Java classes
             sb.append(object.toString());
         }
 
         sb.append("> .");
         sb.append("\n");
         return sb.toString();
     }
 
     private String buildTripleDatatype(QUERY type, MREDataFieldValue field, Object value) {
         StringBuilder sb = new StringBuilder();
 
         sb.append(" <").append(field.getSubject()).append("> ");
         sb.append("<").append(field.getProperty().toString()).append("> ");
 
         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 = buildTripleDatatypeValue(type, field, value);
         }
 
         // output literal value in N-TRIPLE
         if (literalValue != null) {
 
             if (literalValue.getLanguage() != null
                     && !literalValue.getLanguage().isEmpty()) {
                 // only for a non empty language
                 sb.append("\"").append(literalValue.getString()).append("\"@").append(literalValue.getLanguage());
             } else if (literalValue.getDatatype() != null
                     && !literalValue.getDatatype().equals(XSDDatatype.XSDstring)) {
                 // only for datatype different to xsd:string
                 sb.append("\"").append(makeValidString(literalValue.getString())).append("\"^^<").append(literalValue.getDatatypeURI()).append(">");
             } else {
                 sb.append("\"").append(makeValidString(literalValue.getString())).append("\"");
                 //sb.append(literalValue);
             }
         }
 
         sb.append(" .");
         sb.append("\n");
         return sb.toString();
     }
 
     private String makeValidString(String textContent) {
 
         String result = textContent;
 
         if (textContent.contains("\"")) {
             result = textContent.replace("\"", "\\\"");
         }
 
         return result;
     }
 
     private Literal buildTripleDatatypeValue(QUERY type, MREDataFieldValue field, Object instance) {
 
         if (instance == null) {
             return null;
         }
 
         if (instance instanceof String) {
             // just string, no language, (default)
             return ResourceFactory.createPlainLiteral((String) instance);
 
         } else if (instance instanceof MREStringLang) {
 
             // no lang specified here means plain literal
             if (((MREStringLang) instance).getLang() == null) {
                 return ResourceFactory.createPlainLiteral(((MREStringLang) instance).getString());
             }
 
             // string with language
             return ResourceFactory.createLangLiteral(((MREStringLang) instance).getString(), ((MREStringLang) instance).getLang());
         }
 
         // typed literal
         return ResourceFactory.createTypedLiteral(instance);
     }
 
     /**
      * Build ASK query for test if the instance is persistent/exist.
      *
      * @param instance MREData instance.
      * @return String with ASK query with only one triple (instance URI,
      * rdf:type property and class URI for object).
      */
     @Override
     public String askExist(MREData instance) {
 
         StringBuilder sb = new StringBuilder();
         MREDataFieldValue[] fields = dataService.builderValuesGet(instance);
         int i = 0;
 
         // add rdf:type triple
         buildTripleRDFType(sb, fields, i, instance);
 
         String ask = TEMPLATE_ASK.replace("TRIPLES", sb.toString());
 
         return ask;
     }
 
     @Override
     public String selectType(String resourceURI) {
 
         StringBuilder sb = new StringBuilder();
         sb.append("SELECT DISTINCT ?type WHERE { ");
         sb.append("<").append(resourceURI).append("> ");
         sb.append("<").append(RDF.type).append("> ");
         sb.append("?type . } ");
 
         return sb.toString();
     }
 
     @Override
     public String selectType(Resource resource) {
 
         return selectType(resource.getURI());
     }
 
     @Override
     public String getGraph() {
         return graph;
     }
 
     @Override
     public void setGraph(String graph) {
         this.graph = graph;
     }
 
 }