package fr.ifremer.quadrige3.ui.core.dto;
   
   /*-
    * #%L
    * Quadrige3 Core :: UI Core Common
    * %%
    * Copyright (C) 2017 - 2019 Ifremer
    * %%
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program 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 Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import fr.ifremer.quadrige3.core.dao.referential.Status;
  import fr.ifremer.quadrige3.core.dao.referential.StatusCode;
  import fr.ifremer.quadrige3.core.dao.referential.UnitId;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.dao.technical.Beans;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.ui.core.dto.referential.BaseReferentialDTO;
  import fr.ifremer.quadrige3.ui.core.dto.referential.StatusDTO;
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.lang3.ArrayUtils;
  import org.apache.commons.lang3.StringUtils;
  
  import java.lang.reflect.InvocationTargetException;
  import java.math.BigDecimal;
  import java.math.RoundingMode;
  import java.sql.Array;
  import java.sql.SQLException;
  import java.text.DecimalFormat;
  import java.text.DecimalFormatSymbols;
  import java.util.*;
  import java.util.function.Function;
  import java.util.stream.Collectors;
  
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * useful methods around quadrige bean.
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   * <p>
   * TODO move common methods to fr.ifremer.quadrige3.core.dao.technical.Beans
   */
  public class QuadrigeBeans extends Beans {
  
      /**
       * Constant <code>GET_ID_STRING</code>
       */
      public static final Function<QuadrigeBean, String> GET_ID_STRING = input -> (input == null) ? null : input.getId().toString();
      /**
       * Constant <code>ID_MAPPER</code>
       */
      public static final Function<String, Integer> ID_MAPPER = id -> (id == null || id.isEmpty()) ? null : Integer.valueOf(id);
      /**
       * Constant <code>GET_CODE</code>
       */
      public static final Function<QuadrigeBean, String> GET_CODE = p -> (p == null) ? null : (String) getProperty(p, "code");
      /**
       * Constant <code>DEFAULT_DATE_FORMAT="dd/MM/yyyy"</code>
       */
      public static final String DEFAULT_DATE_FORMAT = "dd/MM/yyyy";
      /**
       * Constant <code>DEFAULT_STRING_SEPARATOR=" - "</code>
       */
      public static final String DEFAULT_STRING_SEPARATOR = " - ";
      private static DecimalFormatSymbols symbols;
      private static DecimalFormat decimalFormat;
  
      /**
       * <p>Constructor for QuadrigeBeans.</p>
       */
      protected QuadrigeBeans() {
          // helper class does not instantiate
      }
  
      /**
       * <p>collectIds.</p>
       *
       * @param collection a {@link Collection} object.
       * @param <B>        a B object.
       * @return a {@link List} object.
       */
      public static <B extends QuadrigeBean> List<Integer> collectIds(Collection<B> collection) {
          if (CollectionUtils.isEmpty(collection)) return new ArrayList<>();
          return collection.stream().filter(Objects::nonNull).map(QuadrigeBean::getId).filter(Objects::nonNull).collect(Collectors.toList());
      }
 
     public static <B extends QuadrigeBean> List<String> collectStringIds(Collection<B> collection) {
         if (CollectionUtils.isEmpty(collection)) return new ArrayList<>();
         return collection.stream().filter(Objects::nonNull)
                 .map(bean -> bean instanceof CodeOnly ? ((CodeOnly) bean).getCode() : bean.getId().toString())
                 .filter(Objects::nonNull).collect(Collectors.toList());
     }
 
     public static <B extends QuadrigeBean> String joinIds(Collection<B> collection, String separator) {
         return String.join(separator, collectStringIds(collection));
     }
 
     /**
      * Return an ImmutableMap of list as values with each id of elements in list as key.
      *
      * @param beans a {@link Collection} object.
      * @return ImmutableMap
      */
     public static <B extends QuadrigeBean> Map<Integer, B> mapById(Collection<B> beans) {
         return CollectionUtils.isNotEmpty(beans)
                 ?
                 beans.stream().collect(Collectors.toMap(
                                 QuadrigeBean::getId, // the key mapper
                                 o -> o, // the value mapper (= the bean itself)
                                 (k1, k2) -> { // if duplicates found
                                     throw new IllegalStateException(String.format("Duplicate key %s", k1));
                                 },
                                 HashMap::new))
                 : new HashMap<>();
 //        return list != null
 //                ? new HashMap<>(Maps.uniqueIndex(list, QuadrigeBean::getId))
 //                : new HashMap<>();
     }
 
     /**
      * <p>findById.</p>
      *
      * @param <B>   a B object.
      * @param beans a {@link Collection} object.
      * @param id    a {@link Integer} object.
      * @return a B object.
      */
     public static <B extends QuadrigeBean> B findById(Collection<B> beans, Integer id) {
         if (CollectionUtils.isEmpty(beans) || id == null) return null;
         return beans.stream().filter(Objects::nonNull).filter(b -> id.equals(b.getId())).findFirst().orElse(null);
     }
 
     /**
      * <p>getDecimalFormatSymbols.</p>
      *
      * @return a {@link DecimalFormatSymbols} object.
      */
     public static DecimalFormatSymbols getDecimalFormatSymbols() {
         if (symbols == null) {
             symbols = new DecimalFormatSymbols();
             symbols.setDecimalSeparator('.');
             symbols.setGroupingSeparator(' ');
         }
         return symbols;
     }
 
     /**
      * <p>Getter for the field <code>decimalFormat</code>.</p>
      *
      * @param minDecimal a int.
      * @param maxDecimal a int.
      * @return a {@link DecimalFormat} object.
      */
     public static DecimalFormat getDecimalFormat(int minDecimal, int maxDecimal) {
         if (decimalFormat == null) {
             decimalFormat = new DecimalFormat();
             decimalFormat.setDecimalFormatSymbols(getDecimalFormatSymbols());
             decimalFormat.setGroupingUsed(false);
         }
         decimalFormat.setMinimumFractionDigits(minDecimal);
         decimalFormat.setMaximumFractionDigits(maxDecimal);
         return decimalFormat;
     }
 
     /**
      * transform the string to a secured format (eg for file name):
      * - strip accents
      * - remove special characters
      *
      * @param text to transform
      * @return transformed string
      */
     public static String toSecuredString(String text) {
         if (text == null) return null;
         // remove special characters
         String result = text.trim().replaceAll("[.,:;'\"()\\[\\]{}?!^=+/\\\\#~%²&|`¨@$£€¤µ*§]+", "");
         // transform accented characters
         return StringUtils.stripAccents(result);
     }
 
     /**
      * transform the string to a fully secured format (eg for extraction):
      * - strip accents
      * - remove article with apostrophe
      * - remove special characters
      * - replace space by underscore
      *
      * @param text to transform
      * @return transformed string
      */
     public static String toFullySecuredString(String text) {
         if (text == null) return null;
         // remove d' l'
         String result = text.replaceAll("[a-zA-Z]'", "");
         // transform accented characters and remove special characters
         result = toSecuredString(result);
         // replace space by underscore
         return result != null ? result.replaceAll(" ", "_") : null;
     }
 
     /**
      * <p>clone.</p>
      *
      * @param bean a B object.
      * @param <B>  a B object.
      * @return a T object.
      * @throws QuadrigeTechnicalException if any.
      */
     @SuppressWarnings("unchecked")
     public static <B extends QuadrigeBean> B clone(final B bean) throws QuadrigeTechnicalException {
         if (bean == null) return null;
         try {
             // Clone bean
             return (B) BeanUtils.cloneBean(bean);
         } catch (final IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException e) {
             throw new QuadrigeTechnicalException(t("quadrige.error.exception.duplicateBean"), e);
         }
     }
 
     public static <B extends QuadrigeBean> List<B> clone(final Collection<B> beans) {
         if (beans == null) return null;
         return beans.stream().map(QuadrigeBeans::clone).collect(Collectors.toList());
     }
 
     public static <B extends QuadrigeBean> Set<B> clone(final Set<B> beans) {
         if (beans == null) return null;
         return beans.stream().map(QuadrigeBeans::clone).collect(Collectors.toSet());
     }
 
     public static BigDecimal convertLengthValue(BigDecimal length, int fromUnitId, int toUnitId) {
 
         if (length == null) {
             return null;
         }
         if (length.intValue() == 0) {
             return BigDecimal.valueOf(0);
         }
         if (fromUnitId == toUnitId) {
             return length;
         }
 
         UnitId[] availableUnits = new UnitId[]{UnitId.METER, UnitId.CENTIMENTER, UnitId.MILLIMETER, UnitId.MICROMETER};
         UnitId fromUnit;
         UnitId toUnit;
         try {
             fromUnit = UnitId.fromValue(fromUnitId);
             if (!ArrayUtils.contains(availableUnits, fromUnit)) {
                 throw new IllegalArgumentException();
             }
         } catch (IllegalArgumentException e) {
             throw new QuadrigeTechnicalException(t("quadrige.error.length.conversion", fromUnitId));
         }
         try {
             toUnit = UnitId.fromValue(toUnitId);
             if (!ArrayUtils.contains(availableUnits, toUnit)) {
                 throw new IllegalArgumentException();
             }
         } catch (IllegalArgumentException e) {
             throw new QuadrigeTechnicalException(t("quadrige.error.length.conversion", toUnitId));
         }
 
         Map<UnitId, BigDecimal> conversionMap = new HashMap<>();
         conversionMap.put(UnitId.METER, BigDecimal.valueOf(1));
         conversionMap.put(UnitId.CENTIMENTER, BigDecimal.valueOf(100));
         conversionMap.put(UnitId.MILLIMETER, BigDecimal.valueOf(1000));
         conversionMap.put(UnitId.MICROMETER, BigDecimal.valueOf(1000L * 1000));
 
         return length.multiply(conversionMap.get(toUnit)).divide(conversionMap.get(fromUnit), RoundingMode.FLOOR);
     }
 
     public static Integer toInteger(BigDecimal bigDecimal) {
         return bigDecimal != null ? bigDecimal.intValue() : null;
     }
 
     public static Double toDouble(BigDecimal bigDecimal) {
         return bigDecimal != null ? bigDecimal.doubleValue() : null;
     }
 
     /**
      * Method used as external function for HSQLDB
      * see fr.ifremer.dali.service.extraction.ExtractionServiceImpl#createConcatDistinctFunction(java.lang.String, java.lang.String)
      *
      * @param array     the input array (any type)
      * @param separator the separator to use
      * @return the unified string
      */
     @SuppressWarnings(value = "unused")
     public static String getUnifiedSQLString(Array array, String separator) {
 
         try {
 
             return getUnifiedString(
                     Arrays.stream((Object[]) array.getArray())
                             .filter(Objects::nonNull)
                             .map(Object::toString)
                             .collect(Collectors.toList()),
                     separator);
 
         } catch (SQLException e) {
 
             return "";
         }
     }
 
     /**
      * Get the unified string from a list of string
      * <p>
      * It concat all unique occurrence of string in the list.
      * If an item already contains a joined string with the separator, the inner items are splitted before.
      *
      * @param strings   the list to proceed
      * @param separator the separator to use
      * @return the unified string
      */
     public static String getUnifiedString(List<String> strings, String separator) {
 
         Set<String> stringSet = new LinkedHashSet<>();
 
         for (String string : strings) {
             if (StringUtils.isNotBlank(string)) {
 
                 // split already joined comment
                 if (string.contains(separator)) {
                     List<String> subComments = split(string, separator);
                     stringSet.addAll(subComments);
                 } else {
                     stringSet.add(string);
                 }
             }
         }
 
         return stringSet.stream().filter(Objects::nonNull).collect(Collectors.joining(separator));
 //        return Joiner.on(separator).skipNulls().join(stringSet);
     }
 
     /**
      * return true only if bean has blocking errors (control errors and warnings are not blocking)
      *
      * @param bean a {@link ErrorAware} object.
      * @return a boolean.
      */
     public static boolean hasNoBlockingError(ErrorAware bean) {
         if (bean != null && CollectionUtils.isNotEmpty(bean.getErrors())) {
             for (ErrorDTO error : bean.getErrors()) {
                 if (error.isError() && !error.isControl()) {
                     return false;
                 }
             }
         }
         return true;
     }
 
     /**
      * <p>removeBlockingErrors.</p>
      *
      * @param bean a {@link ErrorAware} object.
      */
     public static void removeBlockingErrors(ErrorAware bean) {
         bean.getErrors().removeIf(error -> !error.isControl());
     }
 
     /**
      * <p>getErrors.</p>
      *
      * @param bean        a {@link ErrorAware} object.
      * @param controlOnly a {@link Boolean} object.
      * @return a {@link List} object.
      */
     public static List<ErrorDTO> getErrors(ErrorAware bean, final Boolean controlOnly) {
         if (bean == null || CollectionUtils.isEmpty(bean.getErrors())) {
             return new ArrayList<>();
         }
         return filterCollection(bean.getErrors(), error -> error.isError() && (controlOnly == null || (controlOnly == error.isControl())));
     }
 
     /**
      * <p>getErrorMessages.</p>
      *
      * @param bean a {@link ErrorAware} object.
      * @return a {@link List} object.
      */
     public static List<String> getErrorMessages(ErrorAware bean) {
         return collectProperties(getErrors(bean, null), ErrorDTO.PROPERTY_MESSAGE);
     }
 
     /**
      * <p>getErrors.</p>
      *
      * @param bean         a {@link ErrorAware} object.
      * @param propertyName a {@link String} object.
      * @param pmfmId       a {@link Integer} object.
      * @param controlOnly  a {@link Boolean} object.
      * @return a {@link List} object.
      */
     public static List<ErrorDTO> getErrors(ErrorAware bean, final String propertyName, final Integer pmfmId, final Boolean controlOnly) {
         if (bean == null || CollectionUtils.isEmpty(bean.getErrors())) {
             return new ArrayList<>();
         }
         return filterCollection(bean.getErrors(), error -> error.isError()
                 && (controlOnly == null || (controlOnly == error.isControl()))
                 && error.containsPropertyName(propertyName)
                 && (pmfmId == null || pmfmId.equals(error.getPmfmId()))
         );
     }
 
     /**
      * <p>getErrorMessages.</p>
      *
      * @param bean         a {@link ErrorAware} object.
      * @param propertyName a {@link String} object.
      * @param pmfmId       a {@link Integer} object.
      * @return a {@link List} object.
      */
     public static List<String> getErrorMessages(ErrorAware bean, String propertyName, Integer pmfmId) {
         return collectProperties(getErrors(bean, propertyName, pmfmId, null), ErrorDTO.PROPERTY_MESSAGE);
     }
 
     /**
      * <p>getWarnings.</p>
      *
      * @param bean        a {@link ErrorAware} object.
      * @param controlOnly a {@link Boolean} object.
      * @return a {@link List} object.
      */
     public static List<ErrorDTO> getWarnings(ErrorAware bean, final Boolean controlOnly) {
         if (bean == null || CollectionUtils.isEmpty(bean.getErrors())) {
             return new ArrayList<>();
         }
         return filterCollection(bean.getErrors(), error -> error.isWarning() && (controlOnly == null || (controlOnly == error.isControl())));
     }
 
     /**
      * <p>getWarningMessages.</p>
      *
      * @param bean a {@link ErrorAware} object.
      * @return a {@link List} object.
      */
     public static List<String> getWarningMessages(ErrorAware bean) {
         return collectProperties(getWarnings(bean, null), ErrorDTO.PROPERTY_MESSAGE);
     }
 
     /**
      * <p>getWarnings.</p>
      *
      * @param bean         a {@link ErrorAware} object.
      * @param propertyName a {@link String} object.
      * @param pmfmId       a {@link Integer} object.
      * @param controlOnly  a {@link Boolean} object.
      * @return a {@link List} object.
      */
     public static List<ErrorDTO> getWarnings(ErrorAware bean, final String propertyName, final Integer pmfmId, final Boolean controlOnly) {
         if (bean == null || CollectionUtils.isEmpty(bean.getErrors())
                 // if an error is found, return empty list because error is priority
                 || !getErrors(bean, propertyName, pmfmId, controlOnly).isEmpty()) {
             return new ArrayList<>();
         }
         return filterCollection(bean.getErrors(), error -> error.isWarning()
                 && (controlOnly == null || (controlOnly == error.isControl()))
                 && error.containsPropertyName(propertyName)
                 && (pmfmId == null || pmfmId.equals(error.getPmfmId())));
     }
 
     /**
      * <p>getWarningMessages.</p>
      *
      * @param bean         a {@link ErrorAware} object.
      * @param propertyName a {@link String} object.
      * @param pmfmId       a {@link Integer} object.
      * @return a {@link List} object.
      */
     public static List<String> getWarningMessages(ErrorAware bean, String propertyName, Integer pmfmId) {
         return collectProperties(getWarnings(bean, propertyName, pmfmId, null), ErrorDTO.PROPERTY_MESSAGE);
     }
 
     /**
      * <p>addError.</p>
      *
      * @param bean       a {@link ErrorAware} object.
      * @param message    a {@link String} object.
      * @param properties a {@link String} object.
      */
     public static void addError(ErrorAware bean, String message, String... properties) {
         addError(bean, message, null, properties);
     }
 
     /**
      * <p>addError.</p>
      *
      * @param bean       a {@link ErrorAware} object.
      * @param message    a {@link String} object.
      * @param pmfmId     a {@link Integer} object.
      * @param properties a {@link String} object.
      */
     public static void addError(ErrorAware bean, String message, Integer pmfmId, String... properties) {
         addErrorDTOToBean(bean, false, message, pmfmId, properties);
     }
 
     /**
      * <p>addWarning.</p>
      *
      * @param bean       a {@link ErrorAware} object.
      * @param message    a {@link String} object.
      * @param properties a {@link String} object.
      */
     public static void addWarning(ErrorAware bean, String message, String... properties) {
         addWarning(bean, message, null, properties);
     }
 
     /**
      * <p>addWarning.</p>
      *
      * @param bean       a {@link ErrorAware} object.
      * @param message    a {@link String} object.
      * @param pmfmId     a {@link Integer} object.
      * @param properties a {@link String} object.
      */
     public static void addWarning(ErrorAware bean, String message, Integer pmfmId, String... properties) {
         addErrorDTOToBean(bean, true, message, pmfmId, properties);
     }
 
     private static void addErrorDTOToBean(ErrorAware bean, boolean warning, String message, Integer pmfmId, String... properties) {
         ErrorDTO error = QuadrigeBeanFactory.newErrorDTO();
         error.setError(!warning);
         error.setWarning(warning);
         error.setMessage(message);
         error.setPropertyName(properties != null ? Arrays.asList(properties) : null);
         error.setPmfmId(pmfmId);
         bean.getErrors().add(error);
     }
 
     /**
      * <p>addUniqueErrors.</p>
      *
      * @param bean   a {@link ErrorAware} object.
      * @param errors a {@link Collection} object.
      */
     public static void addUniqueErrors(ErrorAware bean, Collection<ErrorDTO> errors) {
 
         if (CollectionUtils.isNotEmpty(errors)) {
             for (ErrorDTO errorToAdd : errors) {
                 boolean canAdd = true;
                 for (ErrorDTO existingError : bean.getErrors()) {
                     if (isErrorEquals(errorToAdd, existingError)) {
                         canAdd = false;
                         break;
                     }
                 }
                 if (canAdd) {
                     bean.getErrors().add(errorToAdd);
                 }
             }
         }
 
     }
 
     private static boolean isErrorEquals(ErrorDTO error1, ErrorDTO error2) {
         return error1.isError() == error2.isError()
                 && error1.isWarning() == error2.isWarning()
                 && error1.isControl() == error2.isControl()
                 && Objects.equals(error1.getControlElementCode(), error2.getControlElementCode())
                 && Objects.deepEquals(error1.getPropertyName().toArray(), error2.getPropertyName().toArray())
                 && Objects.equals(error1.getPmfmId(), error2.getPmfmId())
                 && Objects.equals(error1.getIndividualId(), error2.getIndividualId())
                 && Objects.equals(error1.getMessage(), error2.getMessage());
     }
 
     /**
      * Create a dummy BaseReferentialDTO bean with the specified id
      *
      * @param id the id
      * @return the BaseReferentialDTO bean
      */
     public static BaseReferentialDTO newDummyBaseReferentialBean(int id) {
         BaseReferentialDTO bean = QuadrigeBeanFactory.newBaseReferentialDTO();
         bean.setId(id);
         return bean;
     }
 
     /**
      * <p>filterLocalReferential.</p>
      *
      * @param list a {@link List} object.
      * @param <E>  a E object.
      * @return a {@link List} object.
      */
     public static <E extends BaseReferentialDTO> List<E> filterLocalReferential(List<E> list) {
         return filterReferential(list, true);
     }
 
     /**
      * <p>filterNationalReferential.</p>
      *
      * @param list a {@link List} object.
      * @param <E>  a E object.
      * @return a {@link List} object.
      */
     public static <E extends BaseReferentialDTO> List<E> filterNationalReferential(List<E> list) {
         return filterReferential(list, false);
     }
 
     /**
      * <p>filterReferential.</p>
      *
      * @param list  a {@link List} object.
      * @param local a boolean.
      * @param <E>   a E object.
      * @return a {@link List} object.
      */
     public static <E extends BaseReferentialDTO> List<E> filterReferential(List<E> list, final boolean local) {
         if (CollectionUtils.isNotEmpty(list)) {
             return filterCollection(list, input -> isLocalReferential(input) == local);
         }
         return new ArrayList<>();
     }
 
     public static boolean isLocalReferential(BaseReferentialDTO dto) {
         return (dto.getStatus() != null && isLocalStatus(dto.getStatus())) || (dto.getId() != null && dto.getId() < 0);
     }
 
     /**
      * Return true if the status is a local status (only on local DB)
      *
      * @param statusDTO a {@link StatusDTO} object.
      * @return true for a local status
      */
     public static boolean isLocalStatus(StatusDTO statusDTO) {
         Assert.notNull(statusDTO);
         return isLocalStatus(statusDTO.getCode());
     }
 
     /**
      * Return true if the status is a local status (only on local DB)
      *
      * @param status a not null Status entity
      * @return true for a local status
      */
     public static boolean isLocalStatus(Status status) {
         Assert.notNull(status);
         return isLocalStatus(status.getStatusCd());
     }
 
     /**
      * Return true if the status code is a local status (only on local DB)
      *
      * @param statusCode a {@link java.lang.String} object.
      * @return a boolean.
      */
     public static boolean isLocalStatus(String statusCode) {
         Assert.notBlank(statusCode);
         return StatusCode.LOCAL_DISABLE.value().equals(statusCode)
                 || StatusCode.LOCAL_ENABLE.value().equals(statusCode);
     }
 
 
     public static boolean isDisabledReferential(BaseReferentialDTO dto) {
         return dto.getStatus() != null && isDisabledStatus(dto.getStatus());
     }
 
     public static boolean isDisabledStatus(StatusDTO statusDTO) {
         Assert.notNull(statusDTO);
         return isDisabledStatus(statusDTO.getCode());
     }
 
     public static boolean isDisabledStatus(String statusCode) {
         Assert.notBlank(statusCode);
         return StatusCode.LOCAL_DISABLE.value().equals(statusCode) || StatusCode.DISABLE.value().equals(statusCode);
     }
 
 }