/*****
	Javascript number parser.

	Author: S. Hendriks
	
	Introduction:
		In javascript it is only possible to parse a number from text when the number is formatted correctly. ie 100.00
		Whenever you use a non-english (continental) delimiter, you should transform your number into a parsable number
		and then transform it back. 
		
		This javascript file delivers handy methods for you to parse numbers back and forth between the continental
		and non-continental locale's. This means you can use one method for parsing numbers, regardless if the number
		has a different delimiter because you're using different locales.
		
		Currently this file supports dots and comma's as decimal delimiters. It is referred as dutch (using comma as 
		decimal delimiter)	 or continental (using dot as decimal delimiter).
		
	Methods:
		getElementById(id)
		getTextFromId(id) (get element by id, and return its value or innerhtml)
		parseNumber(id) -- get text of id, then use parseNumberText(text)
		parseNumberText(text)
		localeType(text)
		parseNumberToString(nr, delimiter, thousanddelimiter)
		calcAndReturnPrice(numberId, increase)
		
	Additional information:
	calcAndReturnPrice();
		Use this method to increase a given number with the amount given by "increase".
		Ie, numberId = "sum", and increase is the actual number. When "sum" is 100,00 and increase is 20.
		It will result into "120,00". Note that it takes into account that "sum" has a decimal of "," and therefor
		knows it should return "120,00" with comma. When the sum has a dot instead of a comma as decimal, it
		will return "120.00".
	
*****/

/**
	Get element by id
**/
function getElementById(id) {
	try {
		return returnObjById(id);
	} catch (err) {
		alert(err);
	}
}

function getTextFromId(id) {
	var el = getElementById(id);
	var text = el.innerHTML;
	if (text == null || text == "") {
		text = el.value;
	}
	
	return text;
}

function parseNumberText(text) {
	try {
		// figure out locale
		var locale = localeType(text);
		
		if (locale == "dutch") {
			delimiter = ",";
		} else {
			delimiter = ".";
		}
		
		// set up valid characters (with the delimiter we figured out)
		var validChars = "0123456789" + delimiter;
		
		var nr = "";
		for (var i = 0; i < text.length; i++) {
			var letter = text.charAt(i);
			if (validChars.indexOf(letter) > -1) {
				if (letter == delimiter) {
					nr = nr + "."; // here we always add a dot, so javascript can parse it
				} else {
					nr = nr + letter;
				}
			}
		}
		
		var parsed = nr * 1;
		return parsed;
	} catch (err) {
		alert("parseNumberText: " + err);
	}
}


/**
	This method will parse a number into a valid javascript number
	It will skip everything but the given delimiter. (so the delimiters
	for thousands, and so forth are also ignored).
**/
function parseNumber(id) {
	try {
		var text = getTextFromId(id);
		return parseNumberText(text);
	} catch (err) {
		alert("parseNumber: " + err);
	}
}

/**
	Determine locale of price. This is done by checking the last found delimiter which
	could be a . or a ,.
	
	When no delimiter found, it will return 'dutch'
	
	Returns: String
**/
function localeType(text) {
	var lastDelimiter = ',';
	
	for (var i = 0; i < text.length; i++) {
		var letter = text.charAt(i);
		if (letter == ',' || letter == '.') {
			lastDelimiter = letter;
		}
	}
	
	if (lastDelimiter == '.') {
		return "continental";
	}  else if (lastDelimiter == ',') {
		return "dutch";
	}
	
	return "dutch";
}

/**
	Parse a number into a string.

	nr must be without any thousand-delimiters! (given by parseNumber());
	
	Returns string.
**/
function parseNumberToString(nr, delimiter, thousanddelimiter) {
	try {
		var numberString = "" + nr;
		// knowing the delimiter, split in 2.
		var splitted = numberString.split('.'); // the number is a javascript number, which has always a dot as delimiter.
		
		// part left to delimiter (the actual number)
		var left = splitted[0];
		
		var newLeft = "";
		// now walk from RIGHT to left, and every 3 digits, place a 'thousand delimiter'
		var amount = 0;
		for (var j = (left.length - 1); j >= 0; j--) {
			var letter = left.charAt(j);
			if (amount > 2) {
				newLeft = newLeft + thousanddelimiter;
				newLeft = newLeft + letter;
				amount = 0;
			} else {
				newLeft = newLeft + letter;
			}
			amount++;
		}

		// now reverse it again to make it look right
		newLeft = newLeft.reverse();
		
		// part right to delimiter (amount of cents)
		var right = "00";
		if (splitted[1]) {
			right = splitted[1];
		}
		
		if (right.length > 2) { // snip longer than 2 decimals
			right = right.substring(0,2); 
		}
		
		// eventually concat the left and right part again with the given delimiter.
		var newNumberString = newLeft + delimiter + right;
		return newNumberString;		
	} catch (err) {
		alert("parseNumberToString: " + err);
	}
}

/**
	Reverse for string , as it is not supported by javascript built-in
**/
String.prototype.reverse = function(){
	splitext = this.split("");
	revertext = splitext.reverse();
	reversed = revertext.join("");
	return reversed;
}

/**
	This method returns a correct formatted (locale specific) number. 
	It will retrieve the locale data from the originalNumber text, then return
	the newNumber formatted according to that locale.
	
	The newNumber must be a javascript float (or number)!
**/
function getNewNumber(originalNumber, newNumber) {
	try {
		var text = originalNumber;	// this could be xx.xx.xx,yy - figure out the original delimiter and such
		
		// figure out locale / original delimiters
		var locale = localeType(text);
		
		var delimiter, thousanddelimiter;				
		if (locale == "dutch") {
			delimiter = ",";
			thousanddelimiter = ".";
		} else {
			delimiter = ".";
			thousanddelimiter = ",";
		}
		
		// now construct a new string with the original delimiters.
		return parseNumberToString(newNumber, delimiter, thousanddelimiter);
	} catch (err) {
		alert("getNewNumber: " + err);
	}
}

/**
	
**/
function calcAndReturnPrice(numberId, increaseWith) {
	try {
		var nr = parseNumber(numberId);		// this delivers something like xxxxxx.yy
		var text = getTextFromId(numberId);	// this could be xx.xx.xx,yy - figure out the original delimiter and such
		nr = nr + increaseWith;
		
		return getNewNumber(text, nr);
	} catch (err) {
		alert("calcAndReturnPrice: " + err);
	}
}