/*
    * 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.data.datatable;
  
  import com.google.gson.Gson;
  import cz.zcu.mre.vocab.NS;
  import cz.zcu.mre.vocab.Prefix;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import org.apache.jena.arq.querybuilder.ExprFactory;
  import org.apache.jena.arq.querybuilder.Order;
  import org.apache.jena.arq.querybuilder.SelectBuilder;
  import org.apache.jena.sparql.expr.E_Function;
  import org.apache.jena.sparql.lang.sparql_11.ParseException;
  import org.apache.jena.vocabulary.XSD;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   *
   */
  public class DataTableUtils {
  
      private static final Logger LOG = LoggerFactory.getLogger(DataTableUtils.class);
  
      /**
       * Checks if is collection empty.
       *
       * @param collection the collection
       * @return true, if is collection empty
       */
      private static boolean isCollectionEmpty(Collection<?> collection) {
          return collection == null || collection.isEmpty();
      }
  
      /**
       * Checks if is object empty.
       *
       * @param object the object
       * @return true, if is object empty
       */
      public static boolean isObjectEmpty(Object object) {
          if (object == null) {
              return true;
          } else if (object instanceof String) {
              if (((String) object).trim().length() == 0) {
                  return true;
              }
          } else if (object instanceof Collection) {
              return isCollectionEmpty((Collection<?>) object);
          }
          return false;
      }
  
      /**
       * Gets the bean to json string.
       *
       * @param beanClass the bean class
       * @return the bean to json string
       */
      public static String getBeanToJsonString(Object beanClass) {
          return new Gson().toJson(beanClass);
      }
  
      /**
       * Gets the bean to json string.
       *
       * @param beanClasses the bean classes
       * @return the bean to json string
       */
      public static String getBeanToJsonString(Object... beanClasses) {
          StringBuilder stringBuilder = new StringBuilder();
          for (Object beanClass : beanClasses) {
              stringBuilder.append(getBeanToJsonString(beanClass));
              stringBuilder.append(", ");
          }
          return stringBuilder.toString();
     }
 
     /**
      * Concatenate.
      *
      * @param listOfItems the list of items
      * @param separator the separator
      * @return the string
      */
     public String concatenate(List<String> listOfItems, String separator) {
         StringBuilder sb = new StringBuilder();
         Iterator<String> stit = listOfItems.iterator();
 
         while (stit.hasNext()) {
             sb.append(stit.next());
             if (stit.hasNext()) {
                 sb.append(separator);
             }
         }
 
         return sb.toString();
     }
 
     public static void appendQuerySort(SelectBuilder builder, DataTableQuerySortBy dtqsb) {
 
         Map<String, DataTableQuerySortOrder> sortby = dtqsb.getSortBys();
         sortby.forEach((k, v) -> {
 
             Order order = v.value().equals("ASC") ? Order.ASCENDING : Order.DESCENDING;
 
             if (k.equals("id")) {
                 builder.addPrefix(Prefix.XSD, NS.XSD);
                 ExprFactory exprFact = builder.getExprFactory();
                 E_Function func = exprFact.function(XSD.integer.toString(), exprFact.asList(exprFact.asVar(k)));
                 builder.addOrderBy(func, order);
 
             } else {
                 builder.addOrderBy(k, order);
             }
         });
     }
 
     public static void appendQueryFilter(SelectBuilder builder, DataTableQueryFilterBy dtqfb) {
 
         Map<String, String> filterby = dtqfb.getMapOfFilters();
 
         if (filterby.isEmpty()) {
             return;
         }
 
         // build filter part
         StringBuilder sb = new StringBuilder("(");
         filterby.forEach((k, v) -> {
 
             // OR regexps
             if (sb.length() > 1) {
                 sb.append(" || ");
             }
 
             String filter = "fn:matches(str(?" + k + "), \"" + v + "\", \"iq\")";
 
             LOG.debug("Filter by column={} and value={} in SPARQL: {}", k, v, filter);
             sb.append(filter);
         });
         sb.append(")");
 
         LOG.debug("Query filter for SelectBuilder is {}", sb);
 //        try {
             // add required prefixes
             builder.addPrefix(Prefix.FN, NS.FN);
 
             // add FILTER part to SelectBuilder
             builder.addFilter(sb.toString());
 //        } catch (ParseException ex) {
 //            LOG.error("Exception when parsing FILTER part of SelectBuilder", ex);
 //        }
     }
 }