package
{

	/**
	 * Grabarz & Partner / Connect
	 * ----------------------------------------------
	 * @author 		Alexander.Milde@grabarzundpartner.de
	 * @created 	17.06.2009
	 *
	 */
	import flash.external.ExternalInterface;		

	public final class JsHandler
	{
		private static var instance 			: JsHandler = new JsHandler();

		private var _callBacksArray 			: Array;
		private var _callsArray 				: Array;
		private var _registerdCallIndex 		: int;
		
		private static const ERR_EI_NOT_AVAILABLE 			: String = "ExternalInterface is not available"; 
		private static const ERR_FUNC_ALREADY_REGISTERED 	: String = "Function is already registered";
		
		
		public function JsHandler() 
		{
			if( instance ) throw new Error("Singleton ;)");

			_callBacksArray = new Array();
			_callsArray = new Array();			
		}

		
		/*
		 * @param jsFunctionName Name of the Javascript function
		 * @param asFunction Actionscript function which will be called
		 */
		public static function addCallBack(jsFunctionName : String, asFunction : Function) : Boolean
		{
			if(ExternalInterface.available)
			{
				if(!instance.isCallBackRegistered(jsFunctionName))
				{
					instance.registerCallBack(jsFunctionName, asFunction);
					return true;
				}
				else
				{
					throw new Error(ERR_FUNC_ALREADY_REGISTERED + ": " + jsFunctionName);
					return false;
				}
			}
			else
			{
				throw new Error(ERR_EI_NOT_AVAILABLE);
				return false;
			}
		}

		
		/*
		 * @param jsFunctionName Name of the Javscript function
		 * @param args Params for the function
		 * @return String from Javascript
		 */
		public static function doCall(jsFunctionName : String, ... args) : String
		{
			if(ExternalInterface.available)
			{	
				countFunctionCall(jsFunctionName);
				args.unshift(jsFunctionName);
				return ExternalInterface.call.apply(instance, args);;
			}
			else
			{
				throw new Error(ERR_EI_NOT_AVAILABLE);
				return null;
			}
		}
		

		private static function countFunctionCall(jsFunctionName : String) : void
		{
			instance._registerdCallIndex = instance.callIndex(jsFunctionName);
				
			if(instance._registerdCallIndex != -1)
			{
				instance.countCall(instance._registerdCallIndex);
			}
			else
			{
				instance._callsArray.push([jsFunctionName, 1]);
			}			
		}

		private function countCall(index : int) : void
		{
			_callsArray[index][1]++;
		}

		private function callIndex(jsFunctionName : String) : int
		{
			for (var i : int = 0; i < _callsArray.length; i++) 
			{
				if(_callsArray[i][0]== jsFunctionName)
				{	
					return i;
					break;
				}	
			}
			return -1;
		}

		
		/*
		 * @return Array
		 */
		public static function allCallBacks() : Array
		{
			return instance._callBacksArray;
		}

		/*
		 * All Javascript Calls which were sent<br> 
		 * [FUNCTION_NAME][AMOUNT]
		 *  
		 * @return ARRAY
		 */
		public static function allCalls() : Array
		{
			return instance._callsArray;
		}


		private function registerCallBack(jsFunctionName : String, asFunction : Function) : void
		{
			_callBacksArray.push(jsFunctionName);
			ExternalInterface.addCallback(jsFunctionName, asFunction);
		}


		private function isCallBackRegistered(jsFunctionName : String) : Boolean
		{
			for (var i : int = 0; i < _callBacksArray.length; i++) 
			{
				if(_callBacksArray[i] == jsFunctionName)
				{
					return true;
					break;
				}				
			}
			
			return false;
		}
	}
}