/*
 * 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 flex.messaging.util;

import java.util.Random;
import java.util.UUID;

public class UUIDUtils
{
    private static Random _weakRand = new Random();
	
    /**
     * The spec indicates that our time value should be based on 100 nano
     * second increments but our time granularity is in milliseconds.
     * The spec also says we can approximate the time by doing an increment
     * when we dole out new ids in the same millisecond.  We can fit 10,000
     * 100 nanos into a single millisecond.
     */
    private static final int MAX_IDS_PER_MILLI = 10000;
	
    /**
     *  Any given time-of-day value can only be used once; remember the last used
     *  value so we don't reuse them.
     *  <p>NOTE: this algorithm assumes the clock will not be turned back.
     */
    private static long lastUsedTOD = 0;
    /** Counter to use when we need more than one id in the same millisecond. */
    private static int numIdsThisMilli = 0;
	
    /**  Hex digits, used for padding UUID strings with random characters. */
    private static final String alphaNum = "0123456789ABCDEF";
	
    /** 4 bits per hex character. */
    private static final int BITS_PER_DIGIT = 4;
	
    private static final int BITS_PER_INT = 32;
    private static final int BITS_PER_LONG = 64;
    private static final int DIGITS_PER_INT = BITS_PER_INT / BITS_PER_DIGIT;
    private static final int DIGITS_PER_LONG = BITS_PER_LONG / BITS_PER_DIGIT;
	
    /**
     *  @private
     */
    private static char[] UPPER_DIGITS = new char[] {
	'0', '1', '2', '3', '4', '5', '6', '7',
	'8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
    };
	
    /**
     * Private constructor to prevent instances from being created.
     */
    private UUIDUtils()
    {
    }
	
    /**
     *
     * Use the createUUID function when you need a unique string that you will
     * use as a persistent identifier in a distributed environment. To a very
     * high degree of certainty, this function returns a unique value; no other
     * invocation on the same or any other system should return the same value.
     *
     * @return a Universally Unique Identifier (UUID)
     * Proper Format: `XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
     * where `X' stands for a hexadecimal digit (0-9 or A-F).
     */
    public static String createUUID()
    {
		return createUUID(false);
	}
	
    public static String createUUID(boolean secure) throws Error
    {
        Random rand = _weakRand;
		if (secure)
			throw new Error("Secure UUIDs not implemented");
		
        StringBuffer s = new StringBuffer(36);
		
        appendHexString(uniqueTOD(), false, 11, s);
		
        //  Just use random padding characters, but ensure that the high bit
        //  is set to eliminate chances of collision with an IEEE 802 address.
        s.append(  alphaNum.charAt( rand.nextInt(16) | 8 ) );
		
        //  Add random padding characters.
        appendRandomHexChars(32 - s.length(), rand, s);
		
        //insert dashes in proper position. so the format matches CF
        s.insert(8,"-");
        s.insert(13,"-");
        s.insert(18,"-");
        s.insert(23,"-");
		
        return s.toString();
    }

    /**
     * Converts a 128-bit UID encoded as a byte[] to a String representation.
     * The format matches that generated by createUID. If a suitable byte[]
     * is not provided, null is returned.
     *
     * @param ba byte[] 16 bytes in length representing a 128-bit UID.
     *
     * @return String representation of the UID, or null if an invalid
     * byte[] is provided.
     */
    public static String fromByteArray(byte[] ba)
    {
        if (ba == null || ba.length != 16)
            return null;

        StringBuffer result = new StringBuffer(36);
        for (int i = 0; i < 16; i++)
        {
            if (i == 4 || i == 6 || i == 8 || i == 10)
                result.append('-');

            result.append(UPPER_DIGITS[(ba[i] & 0xF0) >>> 4]);
            result.append(UPPER_DIGITS[(ba[i] & 0x0F)]);
        }
        return result.toString();
    }

	
    /**
     * A utility method to check whether a String value represents a
     * correctly formatted UID value. UID values are expected to be
     * in the format generated by createUID(), implying that only
     * capitalized A-F characters in addition to 0-9 digits are
     * supported.
     *
     * @param uid The value to test whether it is formatted as a UID.
     *
     * @return Returns true if the value is formatted as a UID.
     */
    public static boolean isUID(String uid)
    {
        if (uid == null || uid.length() != 36)
            return false;

        char[] chars = uid.toCharArray();
        for (int i = 0; i < 36; i++)
        {
            char c = chars[i];

            // Check for correctly placed hyphens
            if (i == 8 || i == 13 || i == 18 || i == 23)
            {
                if (c != '-')
                    return false;
            }
            // We allow capital alpha-numeric hex digits only
            else if (c < 48 || c > 70 || (c > 57 && c < 65))
            {
                return false;
            }
        }

        return true;
    }

    /**
     * Converts a UID formatted String to a byte[]. The UID must be in the
     * format generated by createUID, otherwise null is returned.
     *
     * @param uid String representing a 128-bit UID.
     *
     * @return byte[] 16 bytes in length representing the 128-bits of the
     * UID or null if the uid could not be converted.
     */
    public static byte[] toByteArray(String uid)
    {
        if (!isUID(uid))
            return null;

        byte[] result = new byte[16];
        char[] chars = uid.toCharArray();
        int r = 0;

        for (int i = 0; i < chars.length; i++)
        {
            if (chars[i] == '-')
                continue;
            int h1 = Character.digit(chars[i], 16);
            i++;
            int h2 = Character.digit(chars[i], 16);
            result[r++] = (byte)(((h1 << 4) | h2) & 0xFF);
        }
        return result;
    }

    private static void appendRandomHexChars(int n, Random rand, StringBuffer result)
    {
        int digitsPerInt = DIGITS_PER_INT;
        while (n > 0)
        {
            int digitsToUse = Math.min(n, digitsPerInt);
            n -= digitsToUse;
            appendHexString(rand.nextInt(), true, digitsToUse, result);
        }
    }

    private static void appendHexString
        (long value, boolean prependZeroes, int nLeastSignificantDigits,
         StringBuffer result)
    {
        int bitsPerDigit = BITS_PER_DIGIT;

        long mask = (1L << bitsPerDigit) - 1;

        if (nLeastSignificantDigits < DIGITS_PER_LONG)
        {
            // Clear the bits that we don't care about.
            value &= (1L << (bitsPerDigit * nLeastSignificantDigits)) - 1;
        }

        // Reorder the sequence so that the first set of bits will become the
        // last set of bits.
        int i = 0;
        long reorderedValue = 0;
        if (value == 0)
        {
            // One zero is dumped.
            i++;
        }
        else
        {
            do
            {
                reorderedValue = (reorderedValue << bitsPerDigit) | (value & mask);
                value >>>= bitsPerDigit;
                i++;
            } while (value != 0);
        }

        if (prependZeroes)
        {
            for (int j = nLeastSignificantDigits - i; j > 0; j--)
            {
                result.append('0');
            }
        }


        // Dump the reordered sequence, with the most significant character
        // first.
        for (; i > 0; i--)
        {
            result.append(alphaNum.charAt((int) (reorderedValue & mask)));
            reorderedValue >>>= bitsPerDigit;
        }
    }

    private static String createInsecureUUID()
    {
        StringBuffer s = new StringBuffer(36);

        appendHexString(uniqueTOD(), false, 11, s);

        //  Just use random padding characters, but ensure that the high bit
        //  is set to eliminate chances of collision with an IEEE 802 address.
        s.append(  alphaNum.charAt( _weakRand.nextInt(16) | 8 ) );

        //  Add random padding characters.
        appendRandomHexChars(32 - s.length(), _weakRand, s);

        //insert dashes in proper position. so the format matches CF
        s.insert(8,"-");
        s.insert(13,"-");
        s.insert(18,"-");
        s.insert(23,"-");

        return s.toString();
    }

    /**
     *  @return a time value, unique for calls to this method loaded by the same classloader.
     */
    private static synchronized long uniqueTOD()
    {
        long currentTOD = System.currentTimeMillis();

        // Clock was set back... do not hang in this case waiting to catch up.
        // Instead, rely on the random number part to differentiate the ids.
        if (currentTOD < lastUsedTOD)
            lastUsedTOD = currentTOD;

        if (currentTOD == lastUsedTOD)
        {
            numIdsThisMilli++;
            /*
             * Fall back to the old technique of sleeping if we allocate
             * too many ids in one time interval.
             */
            if (numIdsThisMilli >= MAX_IDS_PER_MILLI)
            {
                while ( currentTOD == lastUsedTOD )
                {
                    try { Thread.sleep(1); } catch ( Exception interrupt ) { /* swallow, wake up */ }
                    currentTOD = System.currentTimeMillis();
                }
                lastUsedTOD = currentTOD;
                numIdsThisMilli = 0;
            }
        }
        else
        {
            //  We have a new TOD, reset the counter
            lastUsedTOD = currentTOD;
            numIdsThisMilli = 0;
        }

        return lastUsedTOD * MAX_IDS_PER_MILLI + (long)numIdsThisMilli;
    }
}