package com.common.util
{
	
	import mx.formatters.Formatter;
	import mx.formatters.SwitchSymbolFormatter;
	
	public class NumberFormatter extends Formatter
	{
		public function NumberFormatter()
		{
			super();
		}
		
		private static const VALID_PATTERN_CHARS:String = "#,0.%"; // ACCEPTABLE chars.
		public var formatString:String = "";
		private var currencySymbol:String = "";
		private var endedWithPercentage:Boolean = false;
		
		private function generateFormatted(value:String,format:String):String
		{
			var result:String="";
			var	resultDecimal:String="";
				
			var	valueSeparator:int  = value.indexOf(".");
			var formatSeparator:int = format.indexOf(".");
				
				
				// we format after decimal first.
				if(valueSeparator!=-1 && formatSeparator!=-1)
				{
					var afterDecimalValue:String  = value.substring(0,valueSeparator);
					var afterDecimalFormat:String = format.substring(0,formatSeparator);
					
					
					afterDecimalValue  = afterDecimalValue.split("").reverse().join("");
					afterDecimalFormat = afterDecimalFormat.split("").reverse().join("");
					
					for(var formatIdx:int=0;formatIdx<afterDecimalFormat.length;formatIdx++)
					{
						var currentValue:String =" ";
						var currentFormat:String = afterDecimalFormat.charAt(formatIdx);
						if(afterDecimalValue.length>formatIdx)
						{	
							currentValue = afterDecimalValue.charAt(formatIdx);
						}else
						{
							currentValue = " ";
						}
						
						if(currentFormat=="#" && !currentValue==" ")
						{
							resultDecimal=resultDecimal+""+currentValue;
						}else if(currentFormat=="0" && currentValue==" ")
						{
							resultDecimal=resultDecimal+"0";
						}
						
					}
				}
				
				
				var beforeDecimalValue:String =""; 
				var beforeDecimalFormat:String="";
				
				//Format Before decimal point.
				if(valueSeparator==-1)
				{
					beforeDecimalValue=value;
				}else
				{
					beforeDecimalValue  = value.substring(valueSeparator+1,value.length);
				}
				
				if(formatSeparator==-1)
				{
					beforeDecimalFormat = format;
				}else
				{
					beforeDecimalFormat = format.substring(formatSeparator+1,format.length);
				}
				
				
				if(beforeDecimalFormat.length>beforeDecimalValue.length)
				{
					// calculateHowManySpace have to add();
					var needToAddSpace:int = beforeDecimalFormat.length- beforeDecimalValue.length;
					for(var i:int=0;i<needToAddSpace;i++)
					{
						beforeDecimalValue+=" ";
					}
					
				}
				
				for(var curIdx:int=0;curIdx<beforeDecimalValue.length;curIdx++)
				{
					var curBeforeValue:String = beforeDecimalValue.charAt(curIdx);
					var currentBeforeFormat:String = " ";
					
					if(beforeDecimalFormat.length>curIdx)
					{	
						currentBeforeFormat = beforeDecimalFormat.charAt(curIdx);
					}else
					{
						currentBeforeFormat = " ";
					}
					
					if(currentBeforeFormat=="#"||currentBeforeFormat==" ")
					{
						if(curBeforeValue!=" ")
						{	
							result=result+""+curBeforeValue;
						}
					}else if(currentBeforeFormat=="0")
					{
						result = result+"0";
					}else if(currentBeforeFormat==",")
					{
						result = result +",";
						if(curBeforeValue!=" ")
						{
							result = result+curBeforeValue;
						}
					}
				}
				
				if(result && result.length>0)
				{
					result = result.split("").reverse().join("");
					
					while(result.charAt(0)==",")
					{
						result= result.substring(1,result.length);
					}	
				}
				
				if(resultDecimal!=null && resultDecimal.length>0)
					result = result+"."+resultDecimal;
				
				
				return result;
			
		}
		
		
		
		// Override format().
		override public function format(value:Object):String 
		{
			var isNegative:Boolean=false;
			var inputInString:String=String(value);
			currencySymbol="";
			if(!formatString|| formatString=="")
			{
				return inputInString;
			}
			endedWithPercentage = false;
			if (error)
			error = null;
				
			// If value is null, or empty String just return "" 
			// but treat it as an error for consistency.
			// Users will ignore it anyway.
			if (!value || (value is String && value == ""))   
			{
				error = "0 Length String";
				return "";
			}
				
			// -- value --              
			// 1. Validate value - must be a nonzero length string.
			if (!value || String(value).length == 0 || isNaN(Number(value)))
			{
				error = "Invalid object type passed to formatter";
				return "";
			}else
			{
				//valid, check the negative sign.
				if(inputInString.charAt(0)=="-"&&inputInString.length>1)
				{
					inputInString = inputInString.substring(1,inputInString.length);
					isNegative = true;
				}
			}
				
			// 2. If the value is valid, format the string.
			var fStrLen:int = 0;
			var letter:String;
			var n:int;
			var i:int;
			var v:int;
			var pureFormatString:String; //pattern without percentage and currency symbol.
			
			// Make sure the formatString is valid.
			n = formatString.length;
			pureFormatString=formatString;
			
			//gettingCurrencySymbol
			var startZero:int = pureFormatString.indexOf("0");
			var startSharp:int = pureFormatString.indexOf("#");
			var startDigit:int = 0;
			
			if(startZero==-1 && startSharp!=-1)
			{
				startDigit = startSharp;
			}else if(startSharp==-1 && startZero!=-1)
			{
				startDigit = startZero;
			}else
			{
				if(startZero<startSharp)
				{
					startDigit = startZero;
				}else
				{
					startDigit = startSharp;
				}	
			}
			
			//if the pattern is not started with any number, it means that the number is started with currency Symbol
			if(startDigit!=0)
			{
				currencySymbol = pureFormatString.substr(0,startDigit);
				pureFormatString = pureFormatString.substr(startDigit,pureFormatString.length - startDigit);
			}
			
			for (i = 0; i < n; i++)
			{
				letter = formatString.charAt(i);
				if (letter == "#")
				{
					fStrLen++;
				}
				else if (VALID_PATTERN_CHARS.indexOf(letter) == -1)
				{
					if(i>=startDigit)
					{	
						//the pattern has characters that not allowed, after the currency symbol.
						error = "You can only use the following symbols in the formatString: # , .";
						return "";
					}	
				}
				
				if(i==n-1 && formatString.charAt(i)=="%")
				{
					//if pattern is ended with percentage, remove the percentage first.
					endedWithPercentage = true;
					pureFormatString = formatString.substr(0,formatString.length-1);
				}			
			}
			
			var fStr:Array = pureFormatString.split("").reverse();
			var returnString:String = "";
			var vStr:String = inputInString.split("").reverse().join("");
			
			returnString = generateFormatted(vStr,fStr.join(""));
			var realResult:String = returnString;
			
			if(endedWithPercentage)
			{
				realResult+="%";
			}
			
			if(currencySymbol)
			{
				realResult = currencySymbol+realResult;	
			}
			
			if(isNegative)
			{
				realResult = "-"+realResult;
			}
			trace("error:"+error+"inputString"+value+"formatString"+formatString);
			return realResult;
		}
	 }
	
	
	
	
	
	
	
}