/*
 *  Copyright 2012 Anyware Services
 *
 *  Licensed 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.ametys.core.util;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.Normalizer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.runtime.i18n.I18nizableText;

/**
 * A collection of String management utility methods.
 */
public final class StringUtils
{
    private static final Logger __LOGGER = LoggerFactory.getLogger(StringUtils.class);

    private static final long __DATA_SIZE_NEXT_LIMIT = 1024;
    private static final List<String> __DATA_SIZE_KEYS = List.of(
        "PLUGINS_CORE_UI_FORMAT_FILE_SIZE_NOT_ESCAPED_BYTES",
        "PLUGINS_CORE_UI_FORMAT_FILE_SIZE_NOT_ESCAPED_KB",
        "PLUGINS_CORE_UI_FORMAT_FILE_SIZE_NOT_ESCAPED_MB",
        "PLUGINS_CORE_UI_FORMAT_FILE_SIZE_NOT_ESCAPED_GB",
        "PLUGINS_CORE_UI_FORMAT_FILE_SIZE_NOT_ESCAPED_TB"
    );
    
    private static final String[] __CSV_BEGIN_CHARS = {"=", "@", "+", "-", "\r", "\t"};
    private static final char __CSV_QUOTE = '"';
    private static final String __CSV_QUOTE_STR = String.valueOf(__CSV_QUOTE);
    
    private StringUtils()
    {
        // empty private constructor
    }
    
    /**
     * Extract String values from a comma seprated list.
     * @param values the comma separated list
     * @return a collection of String or an empty collection if string is null or empty.
     */
    public static Collection<String> stringToCollection(String values)
    {
        Collection<String> result = new ArrayList<>();
        if (values != null && values.length() > 0)
        {
            // Explore the string list with a stringtokenizer with ','.
            StringTokenizer stk = new StringTokenizer(values, ",");

            while (stk.hasMoreTokens())
            {
                // Don't forget to trim
                result.add(stk.nextToken().trim());
            }
        }

        return result;
    }

    /**
     * Extract String values from a comma seprated list.
     * @param values the comma separated list
     * @return an array of String
     */
    public static String[] stringToStringArray(String values)
    {
        Collection<String> coll = stringToCollection(values);
        return coll.toArray(new String[coll.size()]);
    }
    
    /**
     * Generates a unique String key, based on System.currentTimeMillis()
     * @return a unique String value
     */
    public static String generateKey()
    {
        long value;
        
        // Find a new value
        synchronized (StringUtils.class)
        {
            value = System.currentTimeMillis();

            try
            {
                Thread.sleep(15);
            }
            catch (InterruptedException e)
            {
                // does nothing, continue
            }
        }

        // Convert it to a string using radix 36 (more compact)
        String longString = Long.toString(value, Character.MAX_RADIX);
    
        return longString;
    }
    
    /**
     * Encrypt a password by using first MD5 Hash and base64 encoding.
     * @param password The password to be encrypted.
     * @return The password encrypted or null if the MD5 is not supported
     */
    public static String md5Base64(String password)
    {
        if (password == null)
        {
            return null;
        }
        
        MessageDigest md5;
        try
        {
            md5 = MessageDigest.getInstance("MD5");
        }
        catch (NoSuchAlgorithmException e)
        {
            // This error exception not be raised since MD5 is embedded in the JDK
            __LOGGER.error("Cannot encode the password to md5Base64", e);
            return null;
        }
        
        // MD5-hash the password.
        md5.reset();
        try
        {
            md5.update(password.getBytes("UTF-8"));
        }
        catch (UnsupportedEncodingException e)
        {
            throw new IllegalStateException(e);
        }
        byte [] hash = md5.digest();
        
        // Base64-encode the result.
        try
        {
            return new String(Base64.encodeBase64(hash), "UTF-8");
        }
        catch (UnsupportedEncodingException e)
        {
            throw new IllegalStateException(e);
        }
    }
    
    /**
     * Normalize string. Pass to lower case and remove Unicode accents and diacritics
     * @param value the value to normalize
     * @return the normalized value
     */
    public static String normalizeStringValue(String value)
    {
        return Normalizer.normalize(value.toLowerCase(), Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", "");
    }
    
    /**
     * Transform a size to a readable size for data (bytes, KB, MB, etc.).
     * @param size The size to transform
     * @return An internationalized text with the size and the unit.
     */
    public static I18nizableText toReadableDataSize(Long size)
    {
        if (size == 1L)
        {
            return _createReadatableDataSize(size, "PLUGINS_CORE_UI_FORMAT_FILE_SIZE_NOT_ESCAPED_BYTE");
        }
        return _toReadableDataSize(size, __DATA_SIZE_KEYS.iterator());
    }
    
    private static I18nizableText _toReadableDataSize(Long size, Iterator<String> keys)
    {
        String key = keys.next();
        if (!keys.hasNext() || size < __DATA_SIZE_NEXT_LIMIT)
        {
            return _createReadatableDataSize(size, key);
        }
        return _toReadableDataSize(size / __DATA_SIZE_NEXT_LIMIT, keys);
    }
    
    private static I18nizableText _createReadatableDataSize(Long size, String key)
    {
        return new I18nizableText("plugin.core-ui", key, List.of(size.toString()));
    }
    
    /**
     * Returns a escaped {@code String} value for a CSV cell enclosed in double quotes.
     *
     * <p>Any double quote characters in the value are escaped with another double quote.</p>
     * <p>If cell value contains a formula (ex: =SOMME(A0:A10)) it could be evaluated by CVS editor.<br>
     * Use {@link #sanitizeCsv(String)} to avoid formula evaluation</p>
     * 
     * <pre>
     * null                          => ""
     * =1+2                          => "=1+2"
     * =1+2'" ;,=1+2                 => "=1+2'"" ;,=1+2"
     * L'orem ipsut; sit amet, dolor => "L'orem ipsut; sit amet, dolor"
     * =cmd|' /c Calc.exe'!'A1'      => "=cmd|' /c Calc.exe'!'A1'"
     * </pre>
     *
     * @param value the String value for CSV column. Can be null.
     * @return the escaped value
     */
    public static String escapeCsv(String value)
    {
        StringBuilder sb = new StringBuilder();
        
        sb.append(__CSV_QUOTE);
        
        if (org.apache.commons.lang3.StringUtils.isNotEmpty(value))
        {
            sb.append(Strings.CS.replace(value, __CSV_QUOTE_STR, __CSV_QUOTE_STR + __CSV_QUOTE_STR));
        }
        
        sb.append(__CSV_QUOTE);
        
        return sb.toString();
    }
    
    /**
     * Returns a sanitized {@code String} value for a CSV column enclosed in double quotes.
     *
     * <p>Any double quote characters in the value are escaped with another double quote.</p>
     * 
     * <p>If the value starts with '=', '+', '-', '@', newline or TAB, is prepend with a single quote.</p>
     * 
     * <pre>
     * null                          => ""
     * =1+2";=1+2                    => "'=1+2"";=1+2"
     * =1+2'" ;,=1+2                 => "'=1+2'"" ;,=1+2"
     * L'orem ipsut; sit amet, dolor => "L'orem ipsut; sit amet, dolor"
     * =cmd|' /c Calc.exe'!'A1'      => "'=cmd|' /c Calc.exe'!'A1'"
     * </pre>
     *
     * @param value the untrusted String value for CSV column. Can be null.
     * @return the escaped and trusted value
     */
    public static String sanitizeCsv(String value)
    {
        StringBuilder sb = new StringBuilder();
        
        sb.append(__CSV_QUOTE);
        
        if (org.apache.commons.lang3.StringUtils.isNotEmpty(value))
        {
            if (Strings.CS.startsWithAny(value, __CSV_BEGIN_CHARS))
            {
                sb.append("'");
            }
            sb.append(Strings.CS.replace(value, __CSV_QUOTE_STR, __CSV_QUOTE_STR + __CSV_QUOTE_STR));
        }
        
        sb.append(__CSV_QUOTE);
        
        return sb.toString();
    }
    
    /**
     * Returns a sanitized {@code String} value for a XLS-HTML column (no double quotes enclosing).
     *
     * <p>If the value starts with '=', '+', '-', '@', newline or TAB, is prepend with a single quote.</p>
     * 
     * <pre>
     * null                          => StringUtils.EMPTY
     * =1+2";=1+2                    => '=1+2";=1+2
     * =1+2'" ;,=1+2                 => '=1+2'" ;,=1+2
     * L'orem ipsut; sit amet, dolor => L'orem ipsut; sit amet, dolor
     * =cmd|' /c Calc.exe'!'A1'      => '=cmd|' /c Calc.exe'!'A1
     * </pre>
     *
     * @param value the untrusted String value for HTML-XLS column. Can be null.
     * @return the trusted value
     */
    public static String sanitizeXlsHtml(String value)
    {
        if (org.apache.commons.lang3.StringUtils.isNotEmpty(value) && Strings.CS.startsWithAny(value, __CSV_BEGIN_CHARS))
        {
            return "'" + value;
        }
        
        return org.apache.commons.lang3.StringUtils.defaultString(value);
    }
    
    /**
     * Escape HTML special characters in a string.
     * @param value the value to escape
     * @return the escaped value
     */
    public static String escapeHTML(String value)
    {
        return Strings.CS.replace(Strings.CS.replace(Strings.CS.replace(Strings.CS.replace(value, "&", "&amp;"), "<", "&lt;"), "\"", "&quot;"), "'", "&#39;");
    }
    
    /**
     * Compares two strings ignoring case and accents and honoring natural numbers ordering.
     */
    public static class AlphanumComparator implements Comparator<String>
    {
        public int compare(String s1, String s2)
        {
            // Lowercase and replace accented characters with their non-accented equivalents
            String normalizedS1 = Normalizer.normalize(s1.toLowerCase(), Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", "").trim();
            String normalizedS2 = Normalizer.normalize(s2.toLowerCase(), Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", "").trim();
            
            int s1Index = 0;
            int s2Index = 0;
            
            while (s1Index < normalizedS1.length() && s2Index < normalizedS2.length())
            {
                char s1Char = normalizedS1.charAt(s1Index);
                char s2Char = normalizedS2.charAt(s2Index);

                if (Character.isDigit(s1Char) && Character.isDigit(s2Char))
                {
                    int s1Start = s1Index;
                    int s2Start = s2Index;

                    while (s1Index < normalizedS1.length() && Character.isDigit(normalizedS1.charAt(s1Index)))
                    {
                        s1Index++;
                    }
                    while (s2Index < normalizedS2.length() && Character.isDigit(normalizedS2.charAt(s2Index)))
                    {
                        s2Index++;
                    }

                    try
                    {
                        Long num1 = Long.parseLong(normalizedS1.substring(s1Start, s1Index));
                        Long num2 = Long.parseLong(normalizedS2.substring(s2Start, s2Index));
                        
                        if (!num1.equals(num2))
                        {
                            return num1.compareTo(num2);
                        }
                    }
                    catch (NumberFormatException e)
                    {
                        // Unable to parse as long (file name exceed Long.MAX_VALUE ?), compare inputs as String
                        return normalizedS1.compareTo(normalizedS2);
                    }
                }
                else
                {
                    if (s1Char != s2Char)
                    {
                        return s1Char - s2Char;
                    }
                    s1Index++;
                    s2Index++;
                }
            }
            return normalizedS1.length() - normalizedS2.length();
        }
    }
}