/*
	Copyright (c) 2004-2006, The Dojo Foundation
	All Rights Reserved.

	Licensed under the Academic Free License version 2.1 or above OR the
	modified BSD license. For more information on Dojo licensing, see:

		http://dojotoolkit.org/community/licensing.shtml
*/

dojo.provide("dojo.uuid.Uuid");
dojo.require("dojo.lang.*");

// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------
/**
 * The Uuid class offers methods for inspecting existing UUIDs.
 *
 * Examples:
 * <pre>
 *   var uuid;
 *   uuid = new dojo.uuid.Uuid("3b12f1df-5232-4804-897e-917bf397618a");
 *   uuid = new dojo.uuid.Uuid(); // "00000000-0000-0000-0000-000000000000"
 *   uuid = new dojo.uuid.Uuid(dojo.uuid.RandomGenerator);
 *   uuid = new dojo.uuid.Uuid(dojo.uuid.TimeBasedGenerator);
 *
 *   dojo.uuid.Uuid.setGenerator(dojo.uuid.RandomGenerator);
 *   uuid = new dojo.uuid.Uuid();
 *   dojo.lang.assert(!uuid.isEqual(dojo.uuid.Uuid.NIL_UUID));
 * </pre>
 *
 * @scope	public instance constructor
 * @param	uuidString	A 36-character string that conforms to the UUID spec.
 * @param	generator	A UUID generator, such as dojo.uuid.TimeBasedGenerator.
 */
dojo.uuid.Uuid = function(input) {
	this._uuidString = dojo.uuid.Uuid.NIL_UUID;
	if (input) {
		if (dojo.lang.isString(input)) {
			this._uuidString = input.toLowerCase();
			dojo.lang.assert(this.isValid());
		} else {
			if (dojo.lang.isObject(input) && input.generate) {
				var generator = input;
				this._uuidString = generator.generate();
				dojo.lang.assert(this.isValid());
			} else {
				// we got passed something other than a string
				dojo.lang.assert(false, "The dojo.uuid.Uuid() constructor must be initializated with a UUID string.");
			}
		}
	} else {
		var ourGenerator = dojo.uuid.Uuid.getGenerator();
		if (ourGenerator) {
			this._uuidString = ourGenerator.generate();
			dojo.lang.assert(this.isValid());
		}
	}
};

// -------------------------------------------------------------------
// Public constants
// -------------------------------------------------------------------
dojo.uuid.Uuid.NIL_UUID = "00000000-0000-0000-0000-000000000000";
dojo.uuid.Uuid.Version = {
	UNKNOWN: 0,
	TIME_BASED: 1,
	DCE_SECURITY: 2,
	NAME_BASED_MD5: 3,
	RANDOM: 4,
	NAME_BASED_SHA1: 5 };
dojo.uuid.Uuid.Variant = {
	NCS: "0",
	DCE: "10",
	MICROSOFT: "110",
	UNKNOWN: "111" };
dojo.uuid.Uuid.HEX_RADIX = 16;

// -------------------------------------------------------------------
// Public class methods
// -------------------------------------------------------------------
/**
 * Given two UUIDs to compare, this method returns 0, 1, or -1.
 * This method is designed to be used by sorting routines, like
 * the JavaScript built-in Array sort() method.
 * This implementation is intended to match the sample
 * implementation in IETF RFC 4122:
 * http://www.ietf.org/rfc/rfc4122.txt
 *
 * Example:
 * <pre>
 *   var generator = dojo.uuid.TimeBasedGenerator;
 *   var a = new dojo.uuid.Uuid(generator);
 *   var b = new dojo.uuid.Uuid(generator);
 *   var c = new dojo.uuid.Uuid(generator);
 *   var array = new Array(a, b, c);
 *   array.sort(dojo.uuid.Uuid.compare);
 * </pre>
 *
 * @param	uuidOne	A dojo.uuid.Uuid instance, or a string representing a UUID.
 * @param	uuidTwo	A dojo.uuid.Uuid instance, or a string representing a UUID.
 * @return   Returns either 0, 1, or -1.
 */
dojo.uuid.Uuid.compare = function(uuidOne, uuidTwo) {
	var uuidStringOne = uuidOne.toString();
	var uuidStringTwo = uuidTwo.toString();
	if (uuidStringOne > uuidStringTwo) return 1;
	if (uuidStringOne < uuidStringTwo) return -1;
	return 0;
};

/**
 * Sets the default generator, which will be used by the
 * "new dojo.uuid.Uuid()" constructor if no parameters
 * are passed in.
 *
 * @param	generator	A UUID generator, such as dojo.uuid.TimeBasedGenerator.
 * @return   Returns true or false. True if this UUID is equal to the otherUuid.
 */
dojo.uuid.Uuid.setGenerator = function(generator) {
	dojo.lang.assert(!generator || (dojo.lang.isObject(generator) && generator.generate));
	dojo.uuid.Uuid._ourGenerator = generator;
};

/**
 * Returns the default generator.  See setGenerator().
 *
 * @return   A UUID generator, such as dojo.uuid.TimeBasedGenerator.
 */
dojo.uuid.Uuid.getGenerator = function(generator) {
	return dojo.uuid.Uuid._ourGenerator;
};

// -------------------------------------------------------------------
// Public instance methods
// -------------------------------------------------------------------
/**
 * Returns a 36-character string representing the UUID, such
 * as "3b12f1df-5232-4804-897e-917bf397618a".
 *
 * Examples:
 * <pre>
 *   var uuid = new dojo.uuid.Uuid(dojo.uuid.TimeBasedGenerator);
 *   var s;
 *   s = uuid.toString();       //  eb529fec-6498-11d7-b236-000629ba5445
 *   s = uuid.toString('{}');   // {eb529fec-6498-11d7-b236-000629ba5445}
 *   s = uuid.toString('()');   // (eb529fec-6498-11d7-b236-000629ba5445)
 *   s = uuid.toString('""');   // "eb529fec-6498-11d7-b236-000629ba5445"
 *   s = uuid.toString("''");   // 'eb529fec-6498-11d7-b236-000629ba5445'
 *   s = uuid.toString('!-');   //  eb529fec649811d7b236000629ba5445
 *   s = uuid.toString('urn');  //  urn:uuid:eb529fec-6498-11d7-b236-000629ba5445
 * </pre>
 *
 * @param	uuidOne	A dojo.uuid.Uuid instance, or a string representing a UUID.
 * @return   Returns a standard 36-character UUID string, or something similar.
 */
dojo.uuid.Uuid.prototype.toString = function(format) {
	if (format) {
		switch (format) {
			case '{}':
				return '{' + this._uuidString + '}';
				break;
			case '()':
				return '(' + this._uuidString + ')';
				break;
			case '""':
				return '"' + this._uuidString + '"';
				break;
			case "''":
				return "'" + this._uuidString + "'";
				break;
			case 'urn':
				return 'urn:uuid:' + this._uuidString;
				break;
			case '!-':
				return this._uuidString.split('-').join('');
				break;
			default:
				// we got passed something other than what we expected
				dojo.lang.assert(false, "The toString() method of dojo.uuid.Uuid was passed a bogus format.");
		}
	} else {
		return this._uuidString;
	}
};

/**
 * Compares this UUID to another UUID, and returns 0, 1, or -1.
 * This implementation is intended to match the sample
 * implementation in IETF RFC 4122:
 * http://www.ietf.org/rfc/rfc4122.txt
 *
 * @param	otherUuid	A dojo.uuid.Uuid instance, or a string representing a UUID.
 * @return   Returns either 0, 1, or -1.
 */
dojo.uuid.Uuid.prototype.compare = function(otherUuid) {
	return dojo.uuid.Uuid.compare(this, otherUuid);
};

/**
 * Returns true if this UUID is equal to the otherUuid, or
 * false otherwise.
 *
 * @param	otherUuid	A dojo.uuid.Uuid instance, or a string representing a UUID.
 * @return   Returns true or false. True if this UUID is equal to the otherUuid.
 */
dojo.uuid.Uuid.prototype.isEqual = function(otherUuid) {
	return (this.compare(otherUuid) == 0);
};

/**
 * Returns true if the UUID was initialized with a valid value.
 *
 * @return   True if the UUID is valid, or false if it is not.
 */
dojo.uuid.Uuid.prototype.isValid = function() {
	try {
		dojo.lang.assertType(this._uuidString, String);
		dojo.lang.assert(this._uuidString.length == 36);
		dojo.lang.assert(this._uuidString == this._uuidString.toLowerCase());
		var arrayOfParts = this._uuidString.split("-");
		dojo.lang.assert(arrayOfParts.length == 5);
		dojo.lang.assert(arrayOfParts[0].length == 8);
		dojo.lang.assert(arrayOfParts[1].length == 4);
		dojo.lang.assert(arrayOfParts[2].length == 4);
		dojo.lang.assert(arrayOfParts[3].length == 4);
		dojo.lang.assert(arrayOfParts[4].length == 12);
		for (var i in arrayOfParts) {
			var part = arrayOfParts[i];
			var integer = parseInt(part, dojo.uuid.Uuid.HEX_RADIX);
			dojo.lang.assert(isFinite(integer));
		}
		return true;
	} catch (e) {
		return false;
	}
};

/**
 * Returns a variant code that indicates what type of UUID this is.
 * For example:
 * <pre>
 *   var uuid = new dojo.uuid.Uuid("3b12f1df-5232-4804-897e-917bf397618a");
 *   var variant = uuid.getVariant();
 *   dojo.lang.assert(variant == dojo.uuid.Uuid.Variant.DCE);
 * </pre>
 *
 * @return   Returns one of the enumarted dojo.uuid.Uuid.Variant values.
 */
dojo.uuid.Uuid.prototype.getVariant = function() {
	// "3b12f1df-5232-4804-897e-917bf397618a"
	//                     ^
	//                     |
	//         (variant "10__" == DCE)
	var variantCharacter = this._uuidString.charAt(19);
	var variantNumber = parseInt(variantCharacter, dojo.uuid.Uuid.HEX_RADIX);
	dojo.lang.assert((variantNumber >= 0) && (variantNumber <= 16));

	if (!dojo.uuid.Uuid._ourVariantLookupTable) {
		var Variant = dojo.uuid.Uuid.Variant;
		var lookupTable = [];

		lookupTable[0x0] = Variant.NCS;       // 0000
		lookupTable[0x1] = Variant.NCS;       // 0001
		lookupTable[0x2] = Variant.NCS;       // 0010
		lookupTable[0x3] = Variant.NCS;       // 0011

		lookupTable[0x4] = Variant.NCS;       // 0100
		lookupTable[0x5] = Variant.NCS;       // 0101
		lookupTable[0x6] = Variant.NCS;       // 0110
		lookupTable[0x7] = Variant.NCS;       // 0111

		lookupTable[0x8] = Variant.DCE;       // 1000
		lookupTable[0x9] = Variant.DCE;       // 1001
		lookupTable[0xA] = Variant.DCE;       // 1010
		lookupTable[0xB] = Variant.DCE;       // 1011

		lookupTable[0xC] = Variant.MICROSOFT; // 1100
		lookupTable[0xD] = Variant.MICROSOFT; // 1101
		lookupTable[0xE] = Variant.UNKNOWN;   // 1110
		lookupTable[0xF] = Variant.UNKNOWN;   // 1111

		dojo.uuid.Uuid._ourVariantLookupTable = lookupTable;
	}

	return dojo.uuid.Uuid._ourVariantLookupTable[variantNumber];
};

/**
 * Returns a version number that indicates what type of UUID this is.
 * For example:
 * <pre>
 *   var uuid = new dojo.uuid.Uuid("b4308fb0-86cd-11da-a72b-0800200c9a66");
 *   var version = uuid.getVersion();
 *   dojo.lang.assert(version == dojo.uuid.Uuid.Version.TIME_BASED);
 * </pre>
 *
 * @return   Returns one of the enumerated dojo.uuid.Uuid.Version values.
 * @throws   Throws an Error if this is not a DCE Variant UUID.
 */
dojo.uuid.Uuid.prototype.getVersion = function() {
	if (!this._versionNumber) {
		var errorMessage = "Called getVersion() on a dojo.uuid.Uuid that was not a DCE Variant UUID.";
		dojo.lang.assert(this.getVariant() == dojo.uuid.Uuid.Variant.DCE, errorMessage);

		// "b4308fb0-86cd-11da-a72b-0800200c9a66"
		//                ^
		//                |
		//       (version 1 == TIME_BASED)
		var versionCharacter = this._uuidString.charAt(14);
		this._versionNumber = parseInt(versionCharacter, dojo.uuid.Uuid.HEX_RADIX);
	}
	return this._versionNumber;
};

/**
 * If this is a version 1 UUID (a time-based UUID), this method returns a
 * 12-character string with the "node" or "pseudonode" portion of the UUID,
 * which is the rightmost 12 characters.
 * Throws an Error if this is not a version 1 UUID.
 *
 * @return   Returns a 12-character string, which will look something like "917bf397618a".
 * @throws   Throws an Error if this is not a version 1 UUID.
 */
dojo.uuid.Uuid.prototype.getNode = function() {
	if (!this._nodeString) {
		var errorMessage = "Called getNode() on a dojo.uuid.Uuid that was not a TIME_BASED UUID.";
		dojo.lang.assert(this.getVersion() == dojo.uuid.Uuid.Version.TIME_BASED, errorMessage);

		var arrayOfStrings = this._uuidString.split('-');
		this._nodeString = arrayOfStrings[4];
	}
	return this._nodeString;
};

/**
 * If this is a version 1 UUID (a time-based UUID), this method returns
 * the timestamp value encoded in the UUID.  The caller can ask for the
 * timestamp to be returned either as a JavaScript Date object or as a
 * 15-character string of hex digits.
 * Throws an Error if this is not a version 1 UUID.
 *
 * Examples:
 * <pre>
 *   var uuid = new dojo.uuid.Uuid("b4308fb0-86cd-11da-a72b-0800200c9a66");
 *   var date, string, hexString;
 *   date   = uuid.getTimestamp();         // returns a JavaScript Date
 *   date   = uuid.getTimestamp(Date);     //
 *   string = uuid.getTimestamp(String);   // "Mon, 16 Jan 2006 20:21:41 GMT"
 *   hexString = uuid.getTimestamp("hex"); // "1da86cdb4308fb0"
 * </pre>
 *
 * @return   Returns the timestamp value as a JavaScript Date object or a 15-character string of hex digits.
 * @throws   Throws an Error if this is not a version 1 UUID.
 */
dojo.uuid.Uuid.prototype.getTimestamp = function(returnType) {
	var errorMessage = "Called getTimestamp() on a dojo.uuid.Uuid that was not a TIME_BASED UUID.";
	dojo.lang.assert(this.getVersion() == dojo.uuid.Uuid.Version.TIME_BASED, errorMessage);

	if (!returnType) {returnType = null};
	switch (returnType) {
		case "string":
		case String:
			return this.getTimestamp(Date).toUTCString();
			break;
		case "hex":
			// Return a 15-character string of hex digits containing the
			// timestamp for this UUID, with the high-order bits first.
			if (!this._timestampAsHexString) {
				var arrayOfStrings = this._uuidString.split('-');
				var hexTimeLow = arrayOfStrings[0];
				var hexTimeMid = arrayOfStrings[1];
				var hexTimeHigh = arrayOfStrings[2];

				// Chop off the leading "1" character, which is the UUID
				// version number for time-based UUIDs.
				hexTimeHigh = hexTimeHigh.slice(1);

				this._timestampAsHexString = hexTimeHigh + hexTimeMid + hexTimeLow;
				dojo.lang.assert(this._timestampAsHexString.length == 15);
			}
			return this._timestampAsHexString;
			break;
		case null: // no returnType was specified, so default to Date
		case "date":
		case Date:
			// Return a JavaScript Date object.
			if (!this._timestampAsDate) {
				var GREGORIAN_CHANGE_OFFSET_IN_HOURS = 3394248;

				var arrayOfParts = this._uuidString.split('-');
				var timeLow = parseInt(arrayOfParts[0], dojo.uuid.Uuid.HEX_RADIX);
				var timeMid = parseInt(arrayOfParts[1], dojo.uuid.Uuid.HEX_RADIX);
				var timeHigh = parseInt(arrayOfParts[2], dojo.uuid.Uuid.HEX_RADIX);
				var hundredNanosecondIntervalsSince1582 = timeHigh & 0x0FFF;
				hundredNanosecondIntervalsSince1582 <<= 16;
				hundredNanosecondIntervalsSince1582 += timeMid;
				// What we really want to do next is shift left 32 bits, but the
				// result will be too big to fit in an int, so we'll multiply by 2^32,
				// and the result will be a floating point approximation.
				hundredNanosecondIntervalsSince1582 *= 0x100000000;
				hundredNanosecondIntervalsSince1582 += timeLow;
				var millisecondsSince1582 = hundredNanosecondIntervalsSince1582 / 10000;

				// Again, this will be a floating point approximation.
				// We can make things exact later if we need to.
				var secondsPerHour = 60 * 60;
				var hoursBetween1582and1970 = GREGORIAN_CHANGE_OFFSET_IN_HOURS;
				var secondsBetween1582and1970 = hoursBetween1582and1970 * secondsPerHour;
				var millisecondsBetween1582and1970 = secondsBetween1582and1970 * 1000;
				var millisecondsSince1970 = millisecondsSince1582 - millisecondsBetween1582and1970;

				this._timestampAsDate = new Date(millisecondsSince1970);
			}
			return this._timestampAsDate;
			break;
		default:
			// we got passed something other than a valid returnType
			dojo.lang.assert(false, "The getTimestamp() method dojo.uuid.Uuid was passed a bogus returnType: " + returnType);
			break;
	}
};
