/*
    * 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 java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import jakarta.servlet.http.HttpServletRequest;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * The Class DataTableRequest.
   *
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   * @param <T> Class type.
   */
  public class DataTableRequest<T> {
  
      private static final Logger LOG = LoggerFactory.getLogger(DataTableRequest.class);
      /**
       * The unique id.
       */
      private String uniqueId;
  
      /**
       * The draw.
       */
      private String draw;
  
      /**
       * The start.
       */
      private Long start;
  
      /**
       * The length.
       */
      private Long length;
  
      /**
       * Filtered count.
       */
      private Long filteredCount;
      /**
       * The search.
       */
      private String search;
  
      /**
       * The regex.
       */
      private boolean regex;
  
      /**
       * The columns.
       */
      private List<DataTableColumnSpecs> columns;
  
      /**
       * The order.
       */
      private List<DataTableColumnSpecs> order = null;
  
      /**
       * The is global search.
       */
      private boolean globalSearch;
  
      /**
       * The max params to check.
       */
      private int maxParamsToCheck = 0;
  
      /**
       * Instantiates a new data table request.
       *
       * @param request the request
      */
     public DataTableRequest(HttpServletRequest request) {
 
         prepareDataTableRequest(request);
     }
 
     /**
      * Prepare data table request.
      *
      * @param request the request
      */
     private void prepareDataTableRequest(HttpServletRequest request) {
 
         Enumeration<String> parameterNames = request.getParameterNames();
 
         while (parameterNames.hasMoreElements()) {
             String name = parameterNames.nextElement();
             String value = request.getParameter(name);
             LOG.debug("PARAMETER NAMES " + name + "=" + value);
         }
 
         parameterNames = request.getParameterNames();
         if (parameterNames.hasMoreElements()) {
             LOG.debug("HttpServletRequest has more elements");
 
             this.setStart(Long.parseLong(request.getParameter(DataTableQueryCriteria.PAGE_NUMBER)));
             LOG.debug("page number {}", getStart());
             this.setLength(Long.parseLong(request.getParameter(DataTableQueryCriteria.PAGE_SIZE)));
             LOG.debug("page size {}", getLength());
 
             this.setUniqueId(request.getParameter(DataTableQueryCriteria.UNIQUE_ID));
             LOG.debug("uniq ID {}", getUniqueId());
 
             this.setDraw(request.getParameter(DataTableQueryCriteria.DRAW));
             LOG.debug("draw {}", getDraw());
 
             this.setSearch(request.getParameter("search[value]"));
             LOG.debug("search {}", getSearch());
 
             this.setRegex(Boolean.valueOf(request.getParameter("search[regex]")));
             LOG.debug("regex {}", isRegex());
 
             if (!DataTableUtils.isObjectEmpty(this.getSearch())) {
                 this.setGlobalSearch(true);
                 LOG.debug("isGlobalSearch {}", isGlobalSearch());
             }
 
             // parse specification for all columns
             List<DataTableColumnSpecs> localColumns = new ArrayList<>();
             maxParamsToCheck = getNumberOfColumns(request);
             for (int i = 0; i < maxParamsToCheck; i++) {
                 if (request.getParameter("columns[" + i + "][data]") != null
                         && !"null".equalsIgnoreCase(request.getParameter("columns[" + i + "][data]"))
                         && !DataTableUtils.isObjectEmpty(request.getParameter("columns[" + i + "][data]"))) {
 
                     DataTableColumnSpecs colSpec = new DataTableColumnSpecs(request, i);
                     LOG.debug("DataTableColumnSpec {}", colSpec);
 
                     localColumns.add(colSpec);
 
                     if (!DataTableUtils.isObjectEmpty(colSpec.getSearch())) {
                         this.setGlobalSearch(false);
                         LOG.debug("isGlobalSearch {}", isGlobalSearch());
                     }
                 }
             }
 
             // parse data for order by clause
             for (int i = 0; i < maxParamsToCheck; i++) {
                 if (request.getParameter("order[" + i + "][column]") != null
                         && !"null".equalsIgnoreCase(request.getParameter("order[" + i + "][column]"))
                         && !DataTableUtils.isObjectEmpty(request.getParameter("order[" + i + "][column]"))) {
 
                     int columnIndex = Integer.parseInt(request.getParameter("order[" + i + "][column]"));
                     String sortDirection = request.getParameter("order[" + i + "][dir]");
                     LOG.info("DataTable sort by ({}) column {} in direction {}", i, columnIndex, sortDirection);
 
                     // get specification for the column by its index
                     DataTableColumnSpecs dtcs = localColumns.get(columnIndex);
                     if (dtcs == null) {
                         LOG.warn("Column specification for ordering not found.");
                         continue;
                     }
 
                     // set sort direction
                     dtcs.setSortDir(sortDirection);
 
                     // add to the list of columns used for sorting the data
                     addOrderByColumn(dtcs);
                 }
             }
 
             if (!DataTableUtils.isObjectEmpty(localColumns)) {
                 this.setColumns(localColumns);
                 LOG.debug("column.size {}", getColumns().size());
             }
         }
 
     }
 
     private int getNumberOfColumns(HttpServletRequest request) {
 
         Pattern p = Pattern.compile("columns\\[[0-9]+\\]\\[data\\]");
         @SuppressWarnings("rawtypes")
         Enumeration params = request.getParameterNames();
         List<String> lstOfParams = new ArrayList<>();
         while (params.hasMoreElements()) {
             String paramName = (String) params.nextElement();
             Matcher m = p.matcher(paramName);
             if (m.matches()) {
                 lstOfParams.add(paramName);
             }
         }
 
         return lstOfParams.size();
     }
 
     /**
      * Gets the pagination request.
      *
      * @return the pagination request
      */
     public DataTableQueryCriteria getQueryCriteria() {
 
         DataTableQueryCriteria queryCriteria = new DataTableQueryCriteria();
         queryCriteria.setPageNumber(this.getStart() / this.getLength()); // have to compute the page number
         queryCriteria.setPageSize(this.getLength());
 
         // prepare order-by list for DataTable query criteria
         DataTableQuerySortBy sortBy = new DataTableQuerySortBy();
         if (!DataTableUtils.isObjectEmpty(this.getOrder())) {
             getOrder().stream().forEach((col) -> {
                 // add all order-by columns
                 sortBy.addSort(col.getData(), DataTableQuerySortOrder.fromValue(col.getSortDir()));
             });
         }
         queryCriteria.setSortBy(sortBy);
 
         DataTableQueryFilterBy filterBy = new DataTableQueryFilterBy();
         filterBy.setGlobalSearch(this.isGlobalSearch());
 
         if (getColumns() != null) {
             this.getColumns().stream().filter((colSpec) -> (colSpec.isSearchable())).filter((colSpec) -> (!DataTableUtils.isObjectEmpty(this.getSearch()) || !DataTableUtils.isObjectEmpty(colSpec.getSearch()))).forEachOrdered((colSpec) -> {
                 filterBy.addFilter(colSpec.getData(), (this.isGlobalSearch()) ? this.getSearch() : colSpec.getSearch());
             });
             queryCriteria.setFilterBy(filterBy);
         }
 
         return queryCriteria;
     }
 
     public String getUniqueId() {
         return uniqueId;
     }
 
     public void setUniqueId(String uniqueId) {
         this.uniqueId = uniqueId;
     }
 
     public String getDraw() {
         return draw;
     }
 
     public void setDraw(String draw) {
         this.draw = draw;
     }
 
     public Long getStart() {
         return start;
     }
 
     public void setStart(Long start) {
         this.start = start;
     }
 
     public Long getLength() {
         return length;
     }
 
     public void setLength(Long length) {
         this.length = length;
     }
 
     public String getSearch() {
         return search;
     }
 
     public void setSearch(String search) {
         this.search = search;
     }
 
     public boolean isRegex() {
         return regex;
     }
 
     public void setRegex(boolean regex) {
         this.regex = regex;
     }
 
     public List<DataTableColumnSpecs> getColumns() {
         return columns;
     }
 
     public void setColumns(List<DataTableColumnSpecs> columns) {
         this.columns = columns;
     }
 
     public List<DataTableColumnSpecs> getOrder() {
         return order;
     }
 
     public void setOrder(List<DataTableColumnSpecs> order) {
         this.order = order;
     }
 
     public void addOrderByColumn(DataTableColumnSpecs column) {
         if (this.order == null) {
             this.order = new ArrayList<>();
         }
 
         this.order.add(column);
     }
 
     public boolean isGlobalSearch() {
         return globalSearch;
     }
 
     public void setGlobalSearch(boolean globalSearch) {
         this.globalSearch = globalSearch;
     }
 
     public int getMaxParamsToCheck() {
         return maxParamsToCheck;
     }
 
     public void setMaxParamsToCheck(int maxParamsToCheck) {
         this.maxParamsToCheck = maxParamsToCheck;
     }
 
     public Long getFilteredCount() {
         return filteredCount;
     }
 
     public void setFilteredCount(Long filteredCount) {
         this.filteredCount = filteredCount;
     }
 
     @Override
     public String toString() {
         return "DataTableRequest{" + "uniqueId=" + uniqueId + ", draw=" + draw + ", start=" + start + ", length=" + length + ", filtered=" + filteredCount + ", search=" + search + ", regex=" + regex + ", columns=" + columns + ", order=" + order + ", globalSearch=" + globalSearch + ", maxParamsToCheck=" + maxParamsToCheck + '}';
     }
 
 }