package fr.ifremer.quadrige3.core.dao.technical;
   
   /*
    * #%L
    * Reef DB :: Core
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2014 - 2015 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 org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.lang3.StringUtils;
  
  import java.util.*;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * String iterator with pattern
   * <p/>
   * Created by Ludovic on 16/07/2015.
   */
  public class StringIterator implements Iterator<String> {
  
      public static final String DEFAULT_PATTERN = "%s";
      private final String pattern;
  
      private int number;
  
      /**
       * Create a new StringIterator
       *
       * @param objects      a {@link Collection} object.
       * @param propertyName a {@link String} object.
       * @return a {@link fr.ifremer.quadrige3.core.dao.technical.StringIterator} object.
       */
      public static StringIterator newStringIteratorByProperty(Collection<?> objects, String propertyName) {
          return newStringIteratorByProperty(objects, propertyName, null);
      }
  
      /**
       * Create a new StringIterator
       *
       * @param objects         a {@link Collection} object.
       * @param propertyName    a {@link String} object.
       * @param preferredPrefix a {@link String} object.
       * @return a {@link fr.ifremer.quadrige3.core.dao.technical.StringIterator} object.
       */
      public static StringIterator newStringIteratorByProperty(Collection<?> objects, String propertyName, String preferredPrefix) {
  
          // compute preferred pattern
          String preferredPattern = StringUtils.isNotBlank(preferredPrefix) ? preferredPrefix + DEFAULT_PATTERN : null;
  
          if (CollectionUtils.isEmpty(objects) || StringUtils.isBlank(propertyName)) {
              return StringUtils.isNotBlank(preferredPattern)
                      ? new StringIterator(preferredPattern, 0)
                      : new StringIterator();
          }
  
          Map<String, Integer> patternMap = new HashMap<>();
          if (StringUtils.isNotBlank(preferredPattern)) {
              patternMap.put(preferredPattern, 0);
          }
  
          for (Object object : objects) {
              String property = Beans.getProperty(object, propertyName);
              if (StringUtils.isNotBlank(property)) {
  
                  // find by regex
                  Matcher matcher = Pattern.compile("(\\d+)(?!.*\\d)").matcher(property);
                  if (matcher.find()) {
  
                      // build pattern
                      int thisIncrement = Integer.parseInt(matcher.group(1));
                      String thisPattern = matcher.replaceAll(DEFAULT_PATTERN);
                      Integer actualIncrement = patternMap.get(thisPattern);
                      if (actualIncrement != null) {
                          thisIncrement = Math.max(actualIncrement, thisIncrement);
                      }
                      patternMap.put(thisPattern, thisIncrement);
  
                  } else {
  
                      // only a string
                     int thisIncrement = 0;
                     String thisPattern = property + DEFAULT_PATTERN;
                     Integer actualIncrement = patternMap.get(thisPattern);
                     if (actualIncrement != null) {
                         thisIncrement = Math.max(actualIncrement, thisIncrement);
                     }
                     patternMap.put(thisPattern, thisIncrement);
                 }
             }
         }
 
         if (StringUtils.isNotBlank(preferredPattern)) {
 
             // choose the preferred pattern
             return new StringIterator(preferredPattern, patternMap.get(preferredPattern));
         }
 
         if (!patternMap.isEmpty()) {
 
             String pattern;
             if (patternMap.size() == 1) {
 
                 // only one pattern
                 pattern = patternMap.keySet().iterator().next();
 
             } else {
 
                 // choose the lexically highest pattern
                 List<String> patterns = new ArrayList<>(patternMap.keySet());
                 Collections.sort(patterns);
                 pattern = patterns.get(patterns.size() - 1);
             }
             return new StringIterator(pattern, patternMap.get(pattern));
         }
 
         return new StringIterator();
     }
 
     /**
      * <p>Constructor for StringIterator.</p>
      */
     public StringIterator() {
         this(DEFAULT_PATTERN, 0);
     }
 
     /**
      * <p>Constructor for StringIterator.</p>
      *
      * @param pattern a {@link String} object.
      * @param number  a int.
      */
     public StringIterator(String pattern, int number) {
         this.pattern = pattern;
         this.number = number;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean hasNext() {
         return true;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String next() {
         number++;
         return String.format(pattern, number);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void remove() {
         // do nothing
     }
 
     public String getPattern() {
         return pattern;
     }
 
     public String getPrefix() {
         return pattern.replace(DEFAULT_PATTERN, "");
     }
 
 }