/*
    * 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.resourceStorage;
  
  import cz.zcu.mre.sparkle.Messages;
  import cz.zcu.mre.sparkle.SparklePreferences;
  import cz.zcu.mre.sparkle.data.DataAgent;
  import cz.zcu.mre.sparkle.data.dataAgentFactory.DataAgentFactory;
  import cz.zcu.mre.sparkle.gui.dialogs.other.ErrorDialog;
  import cz.zcu.mre.sparkle.gui.dialogs.other.ProgressDialog;
  import cz.zcu.mre.sparkle.tools.CancellableConsumer;
  import javafx.beans.property.SimpleBooleanProperty;
  import javafx.beans.value.ChangeListener;
  import javafx.beans.value.ObservableBooleanValue;
  import javafx.concurrent.Task;
  import javafx.stage.Stage;
  import org.apache.jena.query.QuerySolution;
  import org.apache.jena.rdf.model.Property;
  import org.apache.jena.rdf.model.RDFNode;
  import org.apache.jena.rdf.model.Resource;
  import org.apache.jena.vocabulary.OWL;
  import org.apache.jena.vocabulary.RDF;
  import java.io.File;
  import java.io.Serializable;
  import java.lang.reflect.Field;
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.ExecutionException;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  /**
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   * @author Klara Hlavacova
   */
  class ResourceStorageUpdater
          implements Serializable {
  
      private static final long serialVersionUID = 324354987984654654L;
  
      private static final Logger LOG = Logger.getLogger(ResourceStorageUpdater.class.getName());
  
      private final ResourcesStorage resourcesStorage;
  
      public ResourceStorageUpdater(ResourcesStorage resourcesStorage) {
          this.resourcesStorage = resourcesStorage;
      }
  
      /**
       * Přidá pojmy z uvedeného jmenného prostoru z úložiště.
       *
       * @param namespace Jmenný prostor.
       * @param includeNamedIndividuals Pokud je <code>false</code>, budou
       * filtrovány instance owl:NamedIndividual.
       * @param cancelled Sledovatelná {@link Boolean} hodnota. Pokud je nastavena
       * na <code>true</code>, bude požádáno o přerušení operace.
       *
       * @return Počet přidaných pojmů.
       */
      public final int addFromStorage(
              final String namespace, final boolean includeNamedIndividuals, final ObservableBooleanValue cancelled) {
  
          return addFromStorage(namespace, includeNamedIndividuals, cancelled, resourcesStorage.getDataAgent());
      }
  
      /**
       * Přidá pojmy z uvedeného jmenného prostoru z úložiště.
       *
       * @param namespace Jmenný prostor.
       * @param includeNamedIndividuals Pokud je <code>false</code>, budou
       * filtrovány instance owl:NamedIndividual.
       * @param cancelled Sledovatelná {@link Boolean} hodnota. Pokud je nastavena
       * na <code>true</code>, bude požádáno o přerušení operace.
       * @param dataAgent Zdroj dat.
       *
       * @return Počet přidaných pojmů.
       */
      public int addFromStorage(final String namespace, final boolean includeNamedIndividuals,
              final ObservableBooleanValue cancelled, final DataAgent dataAgent) {
          final int[] result = {0};
  
          List<String> langs = ResourceQueryBuilder.getCommaSeparatedPreferences(SparklePreferences.TITLES_LANG);
         List<String> titles = ResourceQueryBuilder.getCommaSeparatedPreferences(SparklePreferences.TITLES);
         List<String> langVars = ResourceQueryBuilder.getVarsNames(langs, titles);
 
         final CancellableConsumer<QuerySolution> consumer = new CancellableConsumer<QuerySolution>() {
             @Override
             public void accept(final QuerySolution qs) {
                 if (addFromQuerySolution(qs, "r", langVars)) { //$NON-NLS-2$
                     result[0]++;
                 }
             }
         };
 
         final ChangeListener<Boolean> cancellationListener = (observable, oldValue, newValue) -> {
             if (newValue) {
                 consumer.cancel();
             }
         };
 
         cancelled.addListener(cancellationListener);
 
         String query = ResourceQueryBuilder.getQuery(namespace, includeNamedIndividuals, langs, titles, langVars,
                 resourcesStorage.getPrefixesStorage().getPrefixToIri());
         dataAgent.select(query, consumer);
 
         cancelled.removeListener(cancellationListener);
 
         return result[0];
     }
 
     /**
      * Ulozi zdroj ziskany dotazem
      * <p>
      * Pro použití pouze z
      * {@link #addFromStorage(String, boolean, ObservableBooleanValue, DataAgent)}.
      *
      * @param qs {@code QuerySolution}
      * @param varName jmeno promenne se zdrojem
      * @param titles seznam promennych s titulky
      */
     @SuppressWarnings("SameParameterValue")
     private boolean addFromQuerySolution(final QuerySolution qs, final String varName,
             List<String> titles) {
 
         if (!qs.contains(varName)) {
             return false;
         }
         String title = "";
         for (String lang : titles) {
             if (!qs.contains(lang)) {
                 continue;
             }
             title = qs.get(lang).asLiteral().getString();
             if (!title.isEmpty()) {
                 break;
             }
         }
 
         final RDFNode resourceNode = qs.get(varName);
         if (!resourceNode.isResource()) {
             return false;
         }
 
         final Resource resource = resourceNode.asResource();
         return addPropertyOrResource(resource, title);
     }
 
     /**
      * Pokusí se o získání objektu {@link Resource} z předaného atributu třídy,
      * který poté přidá na seznam.
      *
      * @param field Atribut.
      *
      * @return Výsledek operace.
      *
      * @throws IllegalArgumentException
      * @throws IllegalAccessException
      */
     boolean addFromField(final Field field)
             throws IllegalArgumentException, IllegalAccessException {
         if (!java.lang.reflect.Modifier.isStatic(field.getModifiers())
                 || !Resource.class.isAssignableFrom(field.getType())) {
             return false;
         }
 
         final Object o = field.get(null);
         if (o == null) {
             return false;
         }
 
         final Resource r = Resource.class.cast(field.get(null));
         if (r.getLocalName().isEmpty()) {
             return false;
         }
 
         return addPropertyOrResource(r, "");
     }
 
     /**
      * Přidá zdroj. Nejprve ale zkontroluje, jestli jde o vlastnost. Tato
      * schopnost je závislá na připojeném úložišti, resp. to, jestli je zdroj
      * přidán jako instance rdf:Property závisí na jeho obsahu.
      *
      * @param r Zdroj.
      * @param title popisek zdroje (rdfs:label, ...)
      *
      * @return Výsledek operace.
      */
     private boolean addPropertyOrResource(Resource r, String title) {
         if (r instanceof Property) {
             return addPropertyOrResource((Property) r, title);
         }
         if (r.getModel() == null) {
             r = resourcesStorage.getDataAgent().inModel(r);
         }
         //TODO:????
         boolean hasOWLProperty = r.hasProperty(RDF.type, OWL.ObjectProperty)
                 || r.hasProperty(RDF.type, OWL.FunctionalProperty)
                 || r.hasProperty(RDF.type, OWL.DatatypeProperty)
                 || r.hasProperty(RDF.type, OWL.OntologyProperty)
                 || r.hasProperty(RDF.type, OWL.AnnotationProperty)
                 || r.hasProperty(RDF.type, OWL.SymmetricProperty)
                 || r.hasProperty(RDF.type, OWL.TransitiveProperty);
         boolean hasRdfProperty = r.hasProperty(RDF.type, RDF.Property);
 
         return resourcesStorage.addTerm(hasRdfProperty || hasOWLProperty
                 ? new PropertyStorageEntry(r.as(Property.class), title)
                 : new ResourceStorageEntry(r, title));
     }
 
     /**
      * Přidá vlastnost.
      *
      * @param p Vlastnost.
      *
      * @return Výsledek operace.
      */
     private boolean addPropertyOrResource(Property p, String title) {
         if (p.getModel() == null) {
             p = resourcesStorage.getDataAgent().inModel(p);
         }
         return resourcesStorage.addTerm(new PropertyStorageEntry(p, title));
     }
 
     /**
      * Aktualizace uloziste (po nahrani dat do uloziste)
      *
      * @param stage Instance {@link Stage}
      * @param files seznam souboru s daty
      * @param namespaces seznam jmennych prostoru
      */
     public void updateResourceStorage(Stage stage, List<File> files, Set<String> namespaces) {
 
         final Task<Boolean> task = new Task<Boolean>() {
             @Override
             protected Boolean call() throws Exception {
 
                 updateMessage(Messages.getString("TERMS_LOADING_IN_PROGRESS"));
 
                 final SimpleBooleanProperty cancelled = new SimpleBooleanProperty(false);
 
                 int index = 1;
                 updateProgress(0, files.size());
 
                 for (File file : files) {
                     DataAgent tempDA = DataAgentFactory.createTemp();
                     tempDA.addToModel(file);
 
                     for (String namespace : namespaces) {
                         updateTitle(Messages.getString("UPDATING") + ": " + index + "/"
                                 + (files.size() * namespaces.size()));//$NON-NLS-1$
                         index = updateStorageFromFile(cancelled, index, file, tempDA, namespace);
                     }
                 }
                 return true;
             }
 
             /**
              * Aktualizuje jedno uloziste ze souboru
              *
              * @param cancelled true - ukonceno
              * @param index index
              * @param file nahravany soubor
              * @param tempDA data agent
              * @param namespace jmenny prostor
              *
              * @return novy index
              */
             private int updateStorageFromFile(SimpleBooleanProperty cancelled, int index, File file, DataAgent tempDA,
                     String namespace) {
                 try {
                     updateMessage(file.getName() + "\n" + namespace + "\n"
                             + Messages.getString("TERMS_LOADING_IN_PROGRESS"));
 
                     addFromStorage(namespace, true, cancelled, tempDA);
                     updateProgress(++index, files.size());
 
                 } catch (Error e) {
                     ErrorDialog.open(stage, Messages.getString("ERROR"),
                             Messages.getString("OPERATION_FAILED"), e);
                     LOG.log(Level.SEVERE, "Exception: ", e); //$NON-NLS-2$
                 }
                 return index;
             }
 
         };
 
         performUpdateStorageFromFIle(stage, task, true);
     }
 
     /**
      * Aktualizace uloziste z url
      *
      * @param stage Instance {@link Stage}
      * @param namespace jmenny prostor
      * @param size pocet namespace, ktere se aktualizuje
      * @param index index nacitane uri
      */
     public int updateResourceStorage(Stage stage, String namespace, int size, int index) {
         return updateResourceStorage(stage, namespace, size, index, true);
     }
 
     /**
      * Aktualizace uloziste z url
      *
      * @param stage Instance {@link Stage}
      * @param namespace jmenny prostor
      * @param size pocet namespace, ktere se aktualizuje
      * @param index index nacitane uri
      * @param includeIndividuals {@code true} - zahrnout individualy
      */
     public int updateResourceStorage(Stage stage, String namespace, int size, int index, boolean includeIndividuals) {
 
         int updated = index;
 
         final Task<Boolean> task = new Task<Boolean>() {
             @Override
             protected Boolean call() {
 
                 LOG.log(Level.INFO, "Updating {0}: {1}/{2}", new Object[]{namespace, updated, size});//$NON-NLS-1$
 
                 updateTitle(Messages.getString("UPDATING") + ": " + updated + "/" + size);//$NON-NLS-1$
                 String prefix = resourcesStorage.getPrefixesStorage().getNsURIPrefix(namespace);
                 updateMessage(prefix + ": " + namespace + "\n" + Messages.getString("TERMS_LOADING_IN_PROGRESS"));
 
                 final SimpleBooleanProperty cancelled = new SimpleBooleanProperty(false);
 
                 updateProgress(0, 1);
 
                 DataAgent tempDA = DataAgentFactory.createTemp();
 
                 try {
                     tempDA.getFullModel().read(namespace);
 
                     addFromStorage(namespace, includeIndividuals, cancelled, tempDA);
                     updateProgress(1, 1);
 
                 } catch (Exception | Error e) {
                     LOG.log(Level.INFO, "Exception: {0}\n{1}", new Object[]{namespace, e.getCause().getLocalizedMessage()}); //$NON-NLS-2$
                     return false;
                 }
 
                 return true;
             }
 
         };
 
         if (!performUpdateStorageFromFIle(stage, task, false)) {
             return index;
         }
 
         return ++index;
     }
 
     /**
      * Provede aktualizaci uloziste
      *
      * @param stage scena
      * @param task spoustena uloha
      */
     private boolean performUpdateStorageFromFIle(Stage stage, Task<Boolean> task, boolean showDialog) {
         try {
             return ProgressDialog.performTask(stage, task);
 
         } catch (final OutOfMemoryError e) {
             ErrorDialog.open(stage, Messages.getString("ERROR"),
                     Messages.getString("OUT_OF_MEMORY_FILE_LARGE"), e);
 
             return false;
 
         } catch (InterruptedException | ExecutionException | Error e) {
             LOG.log(Level.INFO, "Exception: {0}", e.getCause().getLocalizedMessage()); //$NON-NLS-2$
             if (showDialog) {
                 ErrorDialog.open(stage, Messages.getString("ERROR"), Messages.getString("IMPORT_FAILED"), e);
             }
             return false;
         }
     }
 
 }