/*
    * 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.dao;
  
  import cz.zcu.mre.data.datatable.DataTableQueryCriteria;
  import java.io.File;
  import java.io.IOException;
  import java.nio.charset.Charset;
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.logging.Level;
  import org.apache.commons.io.FileUtils;
  //import org.apache.jena.query.DatasetAccessor;
  //import org.apache.jena.query.DatasetAccessorFactory;
  import org.apache.jena.query.Dataset;
  import org.apache.jena.query.DatasetFactory;
  import org.apache.jena.query.Query;
  import org.apache.jena.query.QueryExecution;
  import org.apache.jena.query.QueryExecutionFactory;
  import org.apache.jena.query.QueryParseException;
  import org.apache.jena.query.QuerySolution;
  import org.apache.jena.query.ResultSet;
  import org.apache.jena.rdf.model.Model;
  import org.apache.jena.rdf.model.Resource;
  import org.apache.jena.update.Update;
  import org.apache.jena.update.UpdateExecutionFactory;
  import org.apache.jena.update.UpdateFactory;
  import org.apache.jena.update.UpdateProcessor;
  import org.apache.jena.update.UpdateRequest;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.InitializingBean;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.data.domain.Pageable;
  
  /**
   * SPARQL Repository Implementation.
   *
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public class SPARQLRepositoryImpl implements SPARQLRepository, InitializingBean {
  
      private static final Logger LOG = LoggerFactory.getLogger(SPARQLRepositoryImpl.class);
      public static final String DEFAULT_SERVICE = "http://127.0.0.1:3030/mrecore";
  
      // set true to output query with line ends
      // set false to disable wrapping of query at line ends
      private static boolean enabledQueryWrap = true;
  
      public static enum QUERY {
          SELECT,
          INSERT,
          UPDATE,
          DELETE,
          CONSTRUCT,
          DESCRIBE
      };
      private static final String PATH_QUERY = "/query";
      private static final String PATH_UPDATE = "/update";
  
      @Value("${sparql.service.url}")
      private String serviceURL = DEFAULT_SERVICE;
  
      @Value("${sparql.service.file}")
      private String serviceURLFile;
  
      // TODO add other URLs
      private static final String DEFAULT_DOWNLOAD_FILENAME = "download.nt";
      private static final String DEFAULT_RDF_NOTATION = "N-TRIPLE";
  
      /**
       * Default constructor.
       */
      public SPARQLRepositoryImpl() {
      }
  
      @Override
      public void afterPropertiesSet() throws Exception {
 
         if (serviceURLFile == null) {
             return;
         }
 
         // read file sparql.service.file
         try {
             File file = new File(System.getProperty("user.home").concat(File.separator).concat(serviceURLFile));
             LOG.debug("Read SPARQL Endpoint URL from file {}", file.getAbsolutePath());
 
             String url = FileUtils.readFileToString(file, Charset.forName("US-ASCII")).trim();
             if (url != null) {
                 LOG.info("Use SPARQL Endpoint service {} from file {}", url, file.getAbsolutePath());
                 this.serviceURL = url;
             } else {
                 throw new IllegalArgumentException("Wrong path to file with SPARQL Endpoint URL: " + serviceURLFile);
             }
         } catch (IOException ex) {
             java.util.logging.Logger.getLogger(SPARQLRepositoryImpl.class.getName()).log(Level.SEVERE, null, ex);
         }
     }
 
     @Override
     public String getServiceURL() {
         return serviceURL;
     }
 
     @Override
     public void setServiceURL(String serviceURL) {
         this.serviceURL = serviceURL;
     }
 
     @Override
     public String getUpdateServicePath() {
         return serviceURL + PATH_UPDATE;
     }
 
     @Override
     public String getQueryServicePath() {
         return serviceURL + PATH_QUERY;
     }
 
     @Override
     public String getAllServicePath() {
         return serviceURL;
     }
 
     @Override
     public Model getGraphDefault() {
         Dataset dataset = DatasetFactory.create(getAllServicePath());
         Model model = dataset.getDefaultModel();
         return model;
     }
 
     @Override
     public Model getGraphNamed(String graphURI) {
         Dataset dataset = DatasetFactory.create(getAllServicePath());
         Model model = dataset.getNamedModel(graphURI);
         return model;
     }
 
     /**
      * Copy the whole dataset from one SPARQL service into another.
      *
      * @param sparqlServiceFrom Source SPARQL Endpoint.
      * @param sparqlServiceTo Destination SPARQL Endpoint.
      * @param graphURI Graph URI is optional.
      */
     @Override
     public void datasetClone(String sparqlServiceFrom, String sparqlServiceTo, String graphURI) {
 
         Dataset datasetFrom = DatasetFactory.create(sparqlServiceFrom);
         Dataset datasetTo = DatasetFactory.create(sparqlServiceTo);
 
         if (graphURI != null) {
             Model model = datasetFrom.getNamedModel(graphURI);
             datasetTo.getNamedModel(graphURI).add(model);
         } else {
             Model model = datasetFrom.getDefaultModel();
             datasetTo.getDefaultModel().add(model);
         }
     }
 
     @Override
     public void datasetDownload(String sparqlServiceFrom, String graphURI) {
         datasetDownload(sparqlServiceFrom, graphURI, null, null);
     }
 
     /**
      * Download the whole dataset by a SPARQL service.
      *
      * @param sparqlServiceFrom SPARQL Endpoint.
      * @param graphURI Graph URI.
      * @param outputFile Output file name.
      * @param rdfNotation Output RDF notation.
      */
     @Override
     public void datasetDownload(String sparqlServiceFrom, String graphURI, String outputFile, String rdfNotation) {
 
         if (outputFile == null || outputFile.isEmpty()) {
             outputFile = DEFAULT_DOWNLOAD_FILENAME;
         }
 
         if (rdfNotation == null || rdfNotation.isEmpty()) {
             rdfNotation = DEFAULT_RDF_NOTATION;
         }
 
         Dataset datasetFrom = DatasetFactory.create(sparqlServiceFrom);
         Model model = (graphURI != null) ? datasetFrom.getNamedModel(graphURI) : datasetFrom.getDefaultModel();
 
         try {
             model.write(Files.newOutputStream(Paths.get(outputFile)), rdfNotation);
         } catch (IOException ex) {
             LOG.error("", ex);
         }
     }
 
     @Override
     public void datasetAppend(String sparqlServiceTo, String graphURI, Model data) {
 
         Dataset dataset = DatasetFactory.create(sparqlServiceTo);
         if (graphURI != null) {
             dataset.getNamedModel(graphURI).add(data);
         } else {
             dataset.getDefaultModel().add(data);
         }
     }
 
     @Override
     public void datasetAppend(Model data, String graphURI) {
 
         Dataset dataset = DatasetFactory.create(getAllServicePath());
         if (graphURI != null) {
             // named graph
             dataset.getNamedModel(getAllServicePath() + "/" + graphURI).add(data);
         } else {
             // default graph
             dataset.getDefaultModel().add(data);
         }
     }
 
     @Override
     public boolean queryAsk(String ask) {
         LOG.debug("ASK execute on {} query {}", getQueryServicePath(), queryWrap(ask));
 
         // run Ask SPARQL query
         QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), ask);
         boolean results = qe.execAsk();
 
         LOG.info("ASK result: '{}' on {} for query: {}", results, getQueryServicePath(), queryWrap(ask));
         return results;
     }
 
     public boolean queryAsk(Query query) {
         LOG.info("ASK execute on {} query {}", getQueryServicePath(), query);
 
         // run Ask SPARQL query
         QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), query);
         boolean results = qe.execAsk();
 
         LOG.info("ASK result: '{}' on {} for query: {}", results, getQueryServicePath(), query);
         return results;
     }
 
     @Override
     public Model queryConstruct(String construct) {
         LOG.debug("CONSTRUCT execute on {} query {}", getQueryServicePath(), queryWrap(construct));
 
         // run Construct SPARQL query
         QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), construct);
         Model results = qe.execConstruct();
 
         LOG.info("CONSTRUCT result size '{}' on {} for query: {}", results.size(), getQueryServicePath(), queryWrap(construct));
         return results;
     }
 
     @Override
     public Model queryConstruct(Query query) {
         LOG.debug("CONSTRUCT execute on {} query {}", getQueryServicePath(), query);
 
         // run Construct SPARQL query
         QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), query);
         Model results = qe.execConstruct();
 
         LOG.info("CONSTRUCT result size '{}' on {} for query: {}", results.size(), getQueryServicePath(), query);
         return results;
     }
 
     @Override
     public long queryCount(String queryTotalSize) {
         LOG.debug("SELECT total size on {} query {}", getQueryServicePath(), queryWrap(queryTotalSize));
 
         long total = 0;
         List<QuerySolution> result = querySelect(queryTotalSize);
 
         if (result.size() == 1
                 && result.get(0) != null
                 && result.get(0).get("total") != null
                 && result.get(0).get("total").asLiteral() != null) {
             total = result.get(0).get("total").asLiteral().getLong();
         }
 
         LOG.info("SELECT result size '{}' on {} for query: {}", total, getQueryServicePath(), queryWrap(queryTotalSize));
         return total;
     }
 
     @Override
     public Model queryDescribe(String describe) {
         LOG.debug("DESCRIBE execute on {} query {}", getQueryServicePath(), queryWrap(describe));
 
         Model results;
         // run Describe SPARQL query
         QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), describe);
         results = qe.execDescribe();
 
         LOG.info("DESCRIBE result size '{}' on {} for query: {}", results.size(), getQueryServicePath(), queryWrap(describe));
         return results;
     }
 
     @Override
     public Model queryDescribe(Query describe) {
         LOG.debug("DESCRIBE execute on {} query {}", getQueryServicePath(), describe);
 
         // run Describe SPARQL query
         QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), describe);
         Model results = qe.execDescribe();
 
         LOG.info("DESCRIBE result size '{}' on {} for query: {}", results.size(), getQueryServicePath(), describe);
         return results;
     }
 
     @Override
     public List<QuerySolution> querySelect(String select) {
         LOG.debug("SELECT execute on {} query {}", getQueryServicePath(), queryWrap(select));
 
         List<QuerySolution> qs = new ArrayList<>();
 
         // run Select SPARQL query
         QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), select);
         ResultSet results = qe.execSelect();
 
         // ResultSet needs to be parsed before closing QueryExecution
         while (results.hasNext()) {
             qs.add(results.next());
         }
 
         LOG.info("SELECT result size '{}' on {} for query: {}", qs.size(), getQueryServicePath(), queryWrap(select));
         return qs;
     }
 
     @Override
     public List<QuerySolution> querySelect(String select, Pageable pageable) {
 
         StringBuilder sb = new StringBuilder(select);
 
         // add limit and offset to the select query
         if (pageable.getPageSize() > 0) {
             sb.append(" LIMIT ");
             sb.append(pageable.getPageSize());
             sb.append(" OFFSET ");
             sb.append(pageable.getOffset());
         }
 
         return querySelect(sb.toString());
     }
 
     @Override
     public List<QuerySolution> querySelect(Query select, Pageable pageable) {
         LOG.debug("SELECT execute on {} query {}", getQueryServicePath(), select);
 
         // add limit and offset to the select query
         if (pageable.getPageSize() > 0) {
             select.setLimit(pageable.getPageSize());
             select.setOffset(pageable.getOffset());
         }
 
         return querySelect(select);
     }
 
     @Override
     public List<QuerySolution> querySelect(Query select, DataTableQueryCriteria queryCriteria) {
         LOG.debug("SELECT execute on {} query {}", getQueryServicePath(), select);
 
         // add limit and offset to the select query
         if (queryCriteria.getPageSize() > 0) {
             select.setLimit(queryCriteria.getPageSize());
             select.setOffset(queryCriteria.getPageNumber() * queryCriteria.getPageSize());
         }
 
         return querySelect(select);
     }
 
     @Override
     public List<QuerySolution> querySelect(Query select) {
         LOG.debug("SELECT execute on {} query {}", getQueryServicePath(), select);
 
         List<QuerySolution> qs = new ArrayList<>();
 
         // run Select SPARQL query
         try (QueryExecution qe = QueryExecutionFactory.sparqlService(getQueryServicePath(), select)) {
 //            if (qe != null) {
                 ResultSet results = qe.execSelect();
 
                 // ResultSet needs to be parsed before closing QueryExecution
                 while (results.hasNext()) {
                     qs.add(results.next());
                 }
 //            }
         }
 
         LOG.info("SELECT result size '{}' on {} for query: {}", qs.size(), getQueryServicePath(), select);
         return qs;
     }
 
     @Override
     public boolean queryDelete(String delete) {
 
         return queryUpdate(delete);
     }
 
     @Override
     public boolean queryDelete(Update delete) {
 
         return queryUpdate(delete);
     }
 
     @Override
     public boolean queryInsert(String insert) {
 
         return queryUpdate(insert);
     }
 
     @Override
     public boolean queryInsert(Update insert) {
 
         return queryUpdate(insert);
     }
 
     /**
      * Update query.
      *
      * @param update Query to be executed.
      * @return True on success, false otherwise.
      */
     @Override
     public boolean queryUpdate(String update) {
         LOG.debug("UPDATE execute on {} query {}", getQueryServicePath(), queryWrap(update));
         try {
             UpdateProcessor upp = UpdateExecutionFactory.createRemote(UpdateFactory.create(update), getUpdateServicePath());
             upp.execute();
 
             LOG.info("UPDATE result '{}' on {} for query: {}", "success", getQueryServicePath(), queryWrap(update));
             return true;
 
         } catch (QueryParseException ex) {
             LOG.error("UPDATE result '{}' on {} for query: {}", "fail", getQueryServicePath(), queryWrap(update), ex);
             return false;
         }
     }
 
     /**
      * Method call that can be used with Apache Jena's UpdateBuilder.
      *
      * @param update Instance of update.
      * @return True or false.
      */
     @Override
     public boolean queryUpdate(Update update) {
 
         if (update == null) {
             throw new IllegalArgumentException("Update cannot be null");
         }
 
         UpdateRequest updateRequest = new UpdateRequest(update);
         //updateRequest.setBaseURI();
         //updateRequest.setPrefixMapping();
         //updateRequest.set...
 
         return queryUpdate(updateRequest);
     }
 //
 //    @Override
 //    public boolean query(Query query) {
 //
 //        if (query == null) {
 //            throw new IllegalArgumentException("Update cannot be null");
 //        }
 //        LOG.info("Execute on {} query {}", getQueryServicePath(), query);
 //
 //        QueryExecution qe = QueryExecutionFactory.sparqlService(getUpdateServicePath(), query);
 //        qe.execAsk();
 //
 //        try {
 //            UpdateProcessor upp = UpdateExecutionFactory.createRemote(updateRequest, getUpdateServicePath());
 //            upp.execute();
 //
 //            LOG.info("UPDATE result '{}' on {} for query: {}", "success", getQueryServicePath(), updateRequest);
 //            return true;
 //
 //        } catch (QueryParseException ex) {
 //            LOG.error("UPDATE result '{}' on {} for query: {}", "fail", getQueryServicePath(), updateRequest, ex);
 //            return false;
 //        }
 //    }
 
     @Override
     public boolean queryUpdate(UpdateRequest updateRequest) {
 
         if (updateRequest == null) {
             throw new IllegalArgumentException("Update cannot be null");
         }
         LOG.debug("UPDATE execute on {} query {}", getQueryServicePath(), updateRequest);
 
         try {
             UpdateProcessor upp = UpdateExecutionFactory.createRemote(updateRequest, getUpdateServicePath());
             upp.execute();
 
             LOG.info("UPDATE result '{}' on {} for query: {}", "success", getQueryServicePath(), updateRequest);
             return true;
 
         } catch (QueryParseException ex) {
             LOG.error("UPDATE result '{}' on {} for query: {}", "fail", getQueryServicePath(), updateRequest, ex);
             return false;
         }
     }
 
     @Override
     public boolean removeSubjectAll(Resource uri) {
         LOG.info("Remove all data of the subject {}", uri.getURI());
 
         // TODO implement method
         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 
         //return true;
     }
 
     @Override
     public Model getModel(String resourceUri) {
         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
     }
 
     private static String queryWrap(String query) {
 
         if (enabledQueryWrap) {
             return query;
         }
 
         return query.replace("\n", "");
     }
 
     public static boolean isEnabledQueryWrap() {
         return enabledQueryWrap;
     }
 
     public static void setEnabledQueryWrap(boolean enabledQueryWrap) {
         SPARQLRepositoryImpl.enabledQueryWrap = enabledQueryWrap;
     }
 
 }