/*
 *  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.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.commons.codec.binary.Base64;
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 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()));
    }
}