/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  package org.apache.myfaces.tobago.internal.util;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Locale;
  import java.util.StringTokenizer;
  
  public final class StringUtils {
  
    private StringUtils() {
      // to prevent instantiation
    }
  
    public static int[] getIndices(final String list) {
      if (list == null) {
        return new int[0];
      }
      final List<String> indexList = new ArrayList<>();
      final StringTokenizer st = new StringTokenizer(list.trim(), ",");
      while (st.hasMoreTokens()) {
        final String token = st.nextToken().trim();
        final int idx = token.indexOf('-');
        if (idx == -1) {
          indexList.add(token);
        } else {
          final int start = Integer.parseInt(token.substring(0, idx).trim());
          final int end = Integer.parseInt(token.substring(idx + 1).trim());
          if (start < end) {
            for (int i = start; i < end + 1; i++) {
              indexList.add(Integer.toString(i));
            }
          } else {
            for (int i = start; i > end - 1; i--) {
              indexList.add(Integer.toString(i));
            }
          }
        }
      }
  
      final int[] indices = new int[indexList.size()];
      for (int i = 0; i < indices.length; i++) {
        indices[i] = Integer.parseInt(indexList.get(i));
      }
      return indices;
    }
  
    public static String constantToLowerCamelCase(final String constant) {
      final StringBuilder builder = new StringBuilder(constantToUpperCamelCase(constant));
      if (builder.length() > 0) {
        builder.setCharAt(0, Character.toLowerCase(builder.charAt(0)));
      }
      return builder.toString();
    }
  
    public static String constantToUpperCamelCase(final String constant) {
      final StringBuilder builder = new StringBuilder(constant.length());
      final char[] chars = constant.toCharArray();
      for (int i = 0; i < chars.length; i++) {
        if (i == 0) {
          builder.append(chars[i]);
        } else if (chars[i] == '_') {
          builder.append(chars[++i]);
        } else {
          builder.append(((Character) chars[i]).toString().toLowerCase(Locale.ENGLISH));
        }
      }
      return builder.toString();
    }
  
    public static String firstToUpperCase(final String string) {
      return string.substring(0, 1).toUpperCase(Locale.ENGLISH) + string.substring(1);
    }
  
    /**
     * Is the same string, by ignoring differences that are only whitespaces.
     * (null and "" are not equal)
     */
    @SuppressWarnings("StringEquality")
    public static boolean equalsIgnoreCaseAndWhitespace(final String type1, final String type2) {
  
     // StringEquality
     if (type1 == type2) {
       return true;
     }
 
     if (type1 == null || type2 == null) {
       return false;
     }
 
     final char[] chars1 = type1.toCharArray();
     final char[] chars2 = type2.toCharArray();
     final int length1 = chars1.length;
     final int length = chars2.length;
 
     int i = 0;
     int j = 0;
 
     while (i < length1 && j < length) {
       if (chars1[i] == chars2[j] || Character.toUpperCase(chars1[i]) == Character.toUpperCase(chars2[j])) {
         i++;
         j++;
         // okay
       } else if (Character.isWhitespace(chars1[i])) {
         i++;
         // okay, ignore space
       } else if (Character.isWhitespace(chars2[j])) {
         j++;
         // try again
       } else {
         return false;
       }
     }
 
     while (i < length1) {
       if (Character.isWhitespace(chars1[i])) {
         i++;
         // okay, ignore space
       } else {
         return false;
       }
     }
 
     while (j < length) {
       if (Character.isWhitespace(chars2[j])) {
         j++;
         // okay, ignore space
       } else {
         return false;
       }
     }
 
     return true;
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static boolean endsWith(final String string, final String suffix) {
     if (string == null || suffix == null) {
       return string == null && suffix == null;
     }
     if (suffix.length() > string.length()) {
       return false;
     }
     final int strOffset = string.length() - suffix.length();
     return string.regionMatches(false, strOffset, suffix, 0, suffix.length());
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static String[] split(final String string, final char separator) {
     // Performance tuned for 2.0 (JDK1.4)
 
     if (string == null) {
       return null;
     }
     final int len = string.length();
     if (len == 0) {
       return ArrayUtils.EMPTY_STRING_ARRAY;
     }
     final List<String> list = new ArrayList<>();
     int i = 0;
     int start = 0;
     boolean match = false;
     while (i < len) {
       if (string.charAt(i) == separator) {
         if (match) {
           list.add(string.substring(start, i));
           match = false;
         }
         start = ++i;
         continue;
       }
       match = true;
       i++;
     }
     if (match) {
       list.add(string.substring(start, i));
     }
     return list.toArray(new String[0]);
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static String[] split(final String string, final String separator) {
     final int max = -1;
     // Performance tuned for 2.0 (JDK1.4)
     // Direct code is quicker than StringTokenizer.
     // Also, StringTokenizer uses isSpace() not isWhitespace()
 
     if (string == null) {
       return null;
     }
     final int len = string.length();
     if (len == 0) {
       return ArrayUtils.EMPTY_STRING_ARRAY;
     }
     final List<String> list = new ArrayList<>();
     int sizePlus1 = 1;
     int i = 0;
     int start = 0;
     boolean match = false;
     if (separator == null) {
       // Null separator means use whitespace
       while (i < len) {
         if (Character.isWhitespace(string.charAt(i))) {
           if (match) {
             if (sizePlus1++ == max) {
               i = len;
             }
             list.add(string.substring(start, i));
             match = false;
           }
           start = ++i;
           continue;
         }
         match = true;
         i++;
       }
     } else if (separator.length() == 1) {
       // Optimise 1 character case
       final char sep = separator.charAt(0);
       while (i < len) {
         if (string.charAt(i) == sep) {
           if (match) {
             if (sizePlus1++ == max) {
               i = len;
             }
             list.add(string.substring(start, i));
             match = false;
           }
           start = ++i;
           continue;
         }
         match = true;
         i++;
       }
     } else {
       // standard case
       while (i < len) {
         if (separator.indexOf(string.charAt(i)) >= 0) {
           if (match) {
             if (sizePlus1++ == max) {
               i = len;
             }
             list.add(string.substring(start, i));
             match = false;
           }
           start = ++i;
           continue;
         }
         match = true;
         i++;
       }
     }
     if (match) {
       list.add(string.substring(start, i));
     }
     return list.toArray(new String[0]);
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static boolean isEmpty(final String value) {
     return value == null || value.length() == 0;
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static boolean isNotEmpty(final String value) {
     return !isEmpty(value);
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static boolean isBlank(final String string) {
     if (string == null) {
       return true;
     }
     final int strLen = string.length();
     if (strLen == 0) {
       return true;
     }
     for (int i = 0; i < strLen; i++) {
       if (!Character.isWhitespace(string.charAt(i))) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static boolean isNotBlank(final String str) {
     return !isBlank(str);
   }
 
   /**
    * Returns a string with asterisks of the same length to hide confidential passwords from log files etc.
    */
   public static String toConfidentialString(final String string, final boolean confidential) {
     if (string == null) {
       return "<null>";
     } else if (confidential) {
       final int repeat = string.length();
       final StringBuilder builder = new StringBuilder(repeat + 15);
       for (int i = 0; i < repeat; i++) {
         builder.append('*');
       }
       builder.append(" (confidential)");
       return builder.toString();
     } else {
       return string;
     }
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static String join(final List<String> list, final char separator) {
     final int size = list.size();
     if (size <= 0) {
       return "";
     }
 
     final int bufSize = size * list.get(0).length() + 1;
     final StringBuilder builder = new StringBuilder(bufSize);
 
     for (int i = 0; i < size; i++) {
       if (i > 0) {
         builder.append(separator);
       }
       final String string = list.get(i);
       if (string != null) {
         builder.append(string);
       }
     }
     return builder.toString();
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static String defaultString(final String string) {
     return string == null ? "" : string;
   }
 
   /**
    * Basically taken from commons-lang
    */
   public static boolean notEquals(final String a, final String b) {
     return a == null ? b != null : !a.equals(b);
   }
 
   /**
    * Checks if the String starts like a url, e.g. http: or xyz:
    */
   public static boolean isUrl(final String link) {
     if (link == null) {
       return false;
     }
     final int colon = link.indexOf(':');
     if (colon < 1) {
       return false;
     }
     for (int i = 0; i < colon; i++) {
       if (!Character.isLetter(link.charAt(i))) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * <p>
    * Checks if the String contains any character in the given set of characters.
    * </p>
    *
    * <p>
    * A <code>null</code> String will return <code>false</code>. A <code>null</code> search string will return
    * <code>false</code>.
    * </p>
    *
    * <pre>
    * StringUtils.containsAny(null, *)            = false
    * StringUtils.containsAny("", *)              = false
    * StringUtils.containsAny(*, null)            = false
    * StringUtils.containsAny(*, "")              = false
    * StringUtils.containsAny("zzabyycdxx", "za") = true
    * StringUtils.containsAny("zzabyycdxx", "by") = true
    * StringUtils.containsAny("aba","z")          = false
    * </pre>
    *
    * @param str the String to check, may be null
    * @param searchChars the chars to search for, may be null
    * @return the <code>true</code> if any of the chars are found, <code>false</code> if no match or null input
    *
    * Basically taken from commons-lang
    */
   public static boolean containsAny(final String str, final String searchChars) {
     if (searchChars == null) {
       return false;
     }
     final char[] searchChars1 = searchChars.toCharArray();
     if (isEmpty(str) || searchChars1.length == 0) {
       return false;
     }
     final int csLength = str.length();
     final int searchLength = searchChars1.length;
     final int csLast = csLength - 1;
     final int searchLast = searchLength - 1;
     for (int i = 0; i < csLength; i++) {
       final char ch = str.charAt(i);
       for (int j = 0; j < searchLength; j++) {
         if (searchChars1[j] == ch) {
           if (isHighSurrogate(ch)) {
             if (j == searchLast) {
               // missing low surrogate, fine, like String.indexOf(String)
               return true;
             }
             if (i < csLast && searchChars1[j + 1] == str.charAt(i + 1)) {
               return true;
             }
           } else {
             // ch is in the Basic Multilingual Plane
             return true;
           }
         }
       }
     }
     return false;
   }
 
   /**
    * Indicates whether {@code ch} is a high- (or leading-) surrogate code unit
    * that is used for representing supplementary characters in UTF-16
    * encoding.
    *
    * @param ch the character to test.
    * @return {@code true} if {@code ch} is a high-surrogate code unit;
    *         {@code false} otherwise.
    */
   private static boolean isHighSurrogate(final char ch) {
     return '\uD800' <= ch && '\uDBFF' >= ch;
   }
 
 }