/*
    * Copyright 2013-2023 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.
    *
    * This file is part of Sparkle project.
    *
    * Sparkle 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.
   *
   * Sparkle 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 Sparkle. If not, see <http://www.gnu.org/licenses/>.
   */
  package cz.zcu.mre.sparkle.data;
  
  import cz.zcu.mre.sparkle.data.dataAgentFactory.DataAgentFactory;
  import cz.zcu.mre.sparkle.data.dataAgentFactory.SparqlEndpointDataAgent;
  import cz.zcu.mre.sparkle.tools.CancellableConsumer;
  import cz.zcu.mre.sparkle.tools.CancellableConsumer.State;
  import cz.zcu.mre.sparkle.tools.Changeable;
  import javafx.beans.Observable;
  import javafx.beans.property.SimpleBooleanProperty;
  import javafx.beans.value.ChangeListener;
  import org.apache.jena.query.*;
  import org.apache.jena.rdf.model.*;
  import org.apache.jena.update.UpdateAction;
  import org.apache.jena.update.UpdateRequest;
  import org.apache.jena.util.FileManager;
  import org.apache.jena.vocabulary.RDF;
  import org.apache.jena.vocabulary.RDFS;
  import java.io.File;
  import java.sql.SQLException;
  import java.util.AbstractMap.SimpleEntry;
  import java.util.*;
  import org.apache.jena.sparql.exec.http.QueryExecutionHTTPBuilder;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Třída představující rozhraní mezi úložištěm a zbytkem aplikace. Pro vytvoření
   * instance je nutné použít metod třídy {@link DataAgentFactory}.
   *
   * @author Jan Smucr
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   * @author Klara Hlavacova
   */
  public abstract class DataAgent implements Observable, Changeable {
  
      private static final Logger LOG = LoggerFactory.getLogger(DataAgent.class);
  
      protected DataAgent() {
  
      }
  
      public abstract SimpleBooleanProperty isNullProperty();
  
      /**
       * @return {@link Model} pro přístup k úložišti.
       */
      protected abstract Model getModel();
  
      /**
       * @return Název úložiště (connection string, umístění a pod.).
       */
      public abstract String getStorageName();
  
      /**
       * It makes class instance that implementing {@link Query}.
       *
       * @param query Query text.
       *
       * @return Instance of class that implementing {@link Query}.
       */
      public static Query createQuery(final String query) {
          return QueryFactory.create(query);
      }
  
      /**
       * Vrati {@code QueryExecution} pro dany model nebo sparql sluzbu ktera se
       * provede pres http
       *
       * @param query sparql dotaz
       *
       * @return {@code QueryExecution} pro dany modelem nebo sparql sluzbu ktera
       * se provede pres http
       */
      private QueryExecution getQueryExecution(Query query) {
          // sparqlService - pripojeni pres htttp k sparql endpoint
          // create - lokalni/vzdalene uloziste
          if (getModel() == null) {
              QueryExecutionHTTPBuilder builder = QueryExecution.service(getStorageName());
              builder.httpClient(SparqlEndpointDataAgent.getHttpClient());
              builder.query(query);
             return builder.build();
         } else {
             return QueryExecution.create(query, getModel());
         }
     }
 
     /**
      * Vykoná dotaz typu SELECT.
      *
      * @param query Znění dotazu.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void select(final String query, final CancellableConsumer<? super QuerySolution> consumer) {
         select(QueryFactory.create(query), consumer);
     }
 
     /**
      * javascript cannot recognize the correct select function to call, call
      * this one for 100 % correctness
      *
      * @param query
      * @param consumer
      */
     public void selectVisual(final String query, final CancellableConsumer<? super QuerySolution> consumer) {
         select(QueryFactory.create(query), consumer);
     }
 
     /**
      * Vykoná dotaz typu SELECT.
      *
      * @param query Dotaz.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void select(final Query query, final CancellableConsumer<? super QuerySolution> consumer) {
         //System.out.println(query);
         final QueryExecution queryExecution = getQueryExecution(query);
 
         if (consumer == null) {
             // System.out.println(ResultSetFormatter.asText(queryExecution.execSelect()));
 
             try {
                 queryExecution.close();
             } catch (final Exception e) {
                 //System.out.println("e");
                 LOG.error("Exception: ", e);//$NON-NLS-1$
             }
         } else {
             // Vytvoří posluchače, který přeruší vykonávání dotazu, pokud přejde consumer do stavu Cancelled.
             final ChangeListener<State> cancellationListener = createStateListener(queryExecution);
 
             consumer.addListener(cancellationListener);
 
             try {
                 final Iterator<QuerySolution> iter = queryExecution.execSelect();
                 final Model model = getModel();
 
                 while (iter.hasNext()) {
                     if (consumer.isCancelled() || model != null && model.isClosed()) {
                         break;
                     }
                     consumer.accept(iter.next());
                     if (consumer.isCancelled() || model != null && model.isClosed()) {
                         break;
                     }
                 }
             } finally {
                 consumer.removeListener(cancellationListener);
                 consumer.notifyFinished();
                 try {
 
                     queryExecution.close();
                 } catch (final Exception e) {
                     LOG.error("Exception: ", e);//$NON-NLS-1$
                 }
             }
         }
     }
 
     /**
      * Vykoná dotaz typu ASK.
      *
      * @param query Znění dotazu.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void ask(final String query, final CancellableConsumer<? super Boolean> consumer) {
         ask(QueryFactory.create(query), consumer);
     }
 
     /**
      * Vykoná dotaz typu ASK.
      *
      * @param query Dotaz.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void ask(final Query query, final CancellableConsumer<? super Boolean> consumer) {
         final QueryExecution queryExecution = getQueryExecution(query);
 
         if (consumer == null) {
             // System.out.println(queryExecution.execAsk());
 
             try {
                 queryExecution.close();
             } catch (final Exception e) {
                 LOG.error("Exception: ", e);//$NON-NLS-1$
             }
         } else {
             // Vytvoří posluchače, který přeruší vykonávání dotazu, pokud přejde consumer do stavu Cancelled.
             final ChangeListener<State> cancellationListener = createStateListener(queryExecution);
             consumer.addListener(cancellationListener);
 
             try {
                 consumer.accept(queryExecution.execAsk());
             } finally {
                 consumer.removeListener(cancellationListener);
                 consumer.notifyFinished();
                 try {
                     queryExecution.close();
                 } catch (final Exception e) {
                     LOG.error("Exception: ", e);//$NON-NLS-1$
                 }
             }
         }
     }
 
     /**
      * Vykoná dotaz typu CONSTRUCT.
      *
      * @param query Znění dotazu.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void construct(final String query, final CancellableConsumer<? super Model> consumer) {
         construct(QueryFactory.create(query), consumer);
     }
 
     /**
      * Vykoná dotaz typu CONSTRUCT.
      *
      * @param query Dotaz.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void construct(final Query query, final CancellableConsumer<? super Model> consumer) {
         //System.err.println(query);
         final QueryExecution queryExecution = getQueryExecution(query);
 
         if (consumer == null) {
             queryExecution.execConstruct().write(System.out);
 
             try {
                 queryExecution.close();
             } catch (final Exception e) {
                 LOG.error("Exception: ", e);//$NON-NLS-1$
             }
         } else {
             // Vytvoří posluchače, který přeruší vykonávání dotazu, pokud přejde consumer do stavu Cancelled.
             final ChangeListener<State> cancellationListener = createStateListener(queryExecution);
             consumer.addListener(cancellationListener);
 
             try {
                 consumer.accept(queryExecution.execConstruct());
             } finally {
                 consumer.removeListener(cancellationListener);
                 consumer.notifyFinished();
 
                 try {
                     queryExecution.close();
                 } catch (final Exception e) {
                     LOG.error("Exception: ", e);//$NON-NLS-1$
                 }
             }
         }
     }
 
     /**
      * Vykoná dotaz typu DESCRIBE.
      *
      * @param query Znění dotazu.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void describe(final String query, final CancellableConsumer<? super Model> consumer) {
         describe(QueryFactory.create(query), consumer);
     }
 
     /**
      * Vykoná dotaz typu DESCRIBE.
      *
      * @param query Dotaz.
      * @param consumer Instance třídy sloužící k předání výsledků. Pokud je
      * <code>null</code>, výsledek je vypsán do {@link System#out}.
      */
     public void describe(final Query query, final CancellableConsumer<? super Model> consumer) {
         final QueryExecution queryExecution = getQueryExecution(query);
 
         if (consumer == null) {
             queryExecution.execDescribe().write(System.out);
 
             try {
                 queryExecution.close();
             } catch (final Exception e) {
                 LOG.error("Exception: ", e);//$NON-NLS-1$
             }
         } else {
             // Vytvoří posluchače, který přeruší vykonávání dotazu, pokud přejde consumer do stavu Cancelled.
             final ChangeListener<State> cancellationListener = createStateListener(queryExecution);
             consumer.addListener(cancellationListener);
 
             try {
                 consumer.accept(queryExecution.execDescribe());
             } finally {
                 consumer.removeListener(cancellationListener);
                 consumer.notifyFinished();
 
                 try {
                     queryExecution.close();
                 } catch (final Exception e) {
                     LOG.error("Exception: ", e);//$NON-NLS-1$
                 }
             }
         }
     }
 
     /**
      * Vytvoří posluchače, který přeruší vykonávání dotazu, pokud přejde
      * consumer do stavu Cancelled.
      *
      * @param queryExecution Objekt zodpověný za vykonání dotazu.
      *
      * @return Posluchač.
      */
     private static ChangeListener<State> createStateListener(final QueryExecution queryExecution) {
         return (observable, oldValue, newValue) -> {
             if (newValue == State.Cancelled) {
                 queryExecution.abort();
             }
         };
     }
 
     /**
      * It executes INSERT, DELETE and INSERT/DELETE query.
      *
      * @param request Query text.
      * @param consumer Instance of class used for transmission of results. If it
      * is <Code>null</code>, the result is printed in {@link System#out}.
      */
     public void updateAction(final UpdateRequest request, final CancellableConsumer<? super Boolean> consumer)
             throws UnsupportedOperationException {
 
         //TODO: endpoint - model == null -> hlaska
         if (getModel() == null) {
             throw new UnsupportedOperationException();
         }
 
         try {
             UpdateAction.execute(request, getModel());
 
             consumer.accept(true);
             consumer.notifyFinished();
 
         } catch (final Exception e) {
             consumer.accept(false);
             LOG.error("Exception: ", e);//$NON-NLS-1$
         }
     }
 
     /**
      * Přidá do grafu RDF soubor v jednom z formátů podporovaných knihovnou
      * Jena.
      *
      * @param file Soubor.
      */
     public void addToModel(final File file) {
         //getModel().read(file.toURI().toASCIIString());
         FileManager.get().readModel(getModel(), file.getAbsolutePath());
     }
 
     public Model getFullModel() {
         return getModel();
     }
 
     /**
      * Vyčistí graf.
      */
     public void clearModel() {
         final Model model = getModel();
         model.removeAll();
     }
 
     /**
      * Uzavře graf (u lokálního úložiště způsobí uložení na disk).
      *
      * @throws SQLException when closing the graph.
      */
     public abstract void close() throws SQLException;
 
     /**
      * Pokusí se o nalezení cesty mezi dvěma zdroji.
      *
      * @param start Počáteční zdroj v kontextu aktuálního grafu.
      * @param end Koncový zdroj v kontextu aktuálního grafu.
      *
      * @return Cesta.
      */
     public LinkedList<Resource> findForwardOntologyPath(Resource start, Resource end) {
         if (start.getModel() == null) {
             start = inModel(start);
         }
         if (end.getModel() == null) {
             end = inModel(end);
         }
 
         // Navštívené uzly
         final LinkedHashMap<Resource, Resource> visited = new LinkedHashMap<>();
         // Nenavštívené ale již objevené uzly
         final LinkedList<SimpleEntry<Resource, Resource>> queue = new LinkedList<>();
 
         // Identifikace všech možných konců cesty (podtřídy nebo odděděné vlastnosti)
         final boolean endIsProperty = end.hasProperty(RDF.type, RDF.Property);
         final LinkedHashSet<String> endSubClassesOrSubPropertiesIRIs = new LinkedHashSet<>();
         final StmtIterator si = end.listProperties(endIsProperty ? RDFS.subPropertyOf : RDFS.subClassOf);
 
         while (si.hasNext()) {
             final RDFNode objectNode = si.next().getObject();
             if (objectNode.isURIResource()) {
                 endSubClassesOrSubPropertiesIRIs.add(objectNode.asResource().getURI());
             }
         }
         si.close();
 
         // Počáteční bod cesty do fronty
         queue.add(new SimpleEntry<>(start, null));
 
         // Flag nalezení cesty
         boolean found = false;
 
         // Předchůdce aktuálně prohledávaného uzlu
         Resource parent = start;
 
         while (!queue.isEmpty()) {
             final SimpleEntry<Resource, Resource> entry = queue.pollFirst();
             if (entry == null) {
                 continue;
             }
             final Resource resource = entry.getKey();
             parent = entry.getValue();
 
             // Uložení uzlu i předchůdce kvůli rekonstrukci cesty
             visited.put(resource, parent);
 
             // Druhá část podmínky by mohla působit problémy
             if (resource.equals(end)
                     || (resource.isURIResource() && endSubClassesOrSubPropertiesIRIs.contains(resource.getURI()))) {
                 found = true;
                 break;
             }
 
             final Set<? extends Resource> _toVisit;
 
             // Stanovení, zda jde nebo nejde o vlastnost a rozbalení uzlu
             if (resource.hasProperty(RDF.type, RDF.Property)) {
                 final Property property = resource.as(Property.class);
                 final Set<Resource> toVisit = DataHelper.getResourcesInRange(property);
                 DataHelper.eliminateParentTypes(toVisit);
                 _toVisit = toVisit;
             } else {
                 final Set<Property> toVisit = DataHelper.getPropertiesWithResourceInDomain(resource);
                 toVisit.addAll(DataHelper.getResourceKeys(resource));
                 _toVisit = toVisit;
             }
 
             // Vyhodí ze seznamu všechny typy rodičovské pro ostatní typy na seznamu
             //DataHelper.eliminateParentTypes(toVisit);
             _toVisit.stream().filter((resourceToVisit) -> (!visited.containsKey(resourceToVisit)))
                     .forEach((resourceToVisit) -> queue.addLast(new SimpleEntry<>(resourceToVisit, resource))); // Ochrana proti zacyklení
         }
 
         if (!found) {
             return null;
         }
 
         // Rekonstrukce cesty
         final LinkedList<Resource> path = new LinkedList<>();
         path.addFirst(end);
         Resource pathItem = parent;
 
         while (pathItem != start) {
             path.addFirst(pathItem);
             pathItem = visited.get(pathItem);
         }
         path.addFirst(pathItem);
 
         return path;
     }
 
     /**
      * Převede zdroj do kontextu aktuálního grafu.
      *
      * @param <T> type of Resource.
      * @param resource Zdroj.
      *
      * @return Zdroj v kontextu grafu.
      */
     @SuppressWarnings("unchecked")
     public <T extends Resource> T inModel(final Resource resource) {
         final Class<? extends Resource> classOfResource = resource.getClass();
         return (T) resource.inModel(getModel()).as(classOfResource);
     }
 
     /**
      * Vrati seznam cest k datovym souborum importovanych do uloziste,
      * {@code null} pokud neni podporovano
      *
      * @return Seznam datovych souboru importovanych do uloziste, {@code null}
      * pokud neni podporovano
      */
     public abstract List<String> getImportedFiles();
 }