package com.joangarnet.js
{
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IEventDispatcher;
	import flash.external.ExternalInterface;
	import flash.utils.Proxy;
	import flash.utils.flash_proxy;
	import flash.utils.ByteArray;
	import org.phprpc.util.Base64;
	
	
	/*
	 * Original class: Joan Garnet http://www.joangarnet.com/blog/?p=437
	 * Patched by Pedro Casaubon 
	 * This patch add Base64 encoding/decoding to the Injected Code
	 */
	
	dynamic final public class JavaScript extends Proxy implements IEventDispatcher
	{
		private var eventDispatcher:EventDispatcher;
		
		/* 
		 * scope for calling the Javascript methods and properties. Defaults to DOM's window object.
		 */
		public static const WINDOW:String = "";
		public static const DOCUMENT:String = "document";
		private var scope:String;

		/*
		 * javascript toolkit to do some internal tasks
		 */
		private const JSProxyTools:XML = 
			<script type="text/javascript">
				<![CDATA[
					// BASE 64 CODING / DECODING Classes
					var Base64 = (function() {
					  function encode_base64(data) {
					    var out = "", c1, c2, c3, e1, e2, e3, e4;
					    for (var i = 0; i < data.length; ) {
					       c1 = data.charCodeAt(i++);
					       c2 = data.charCodeAt(i++);
					       c3 = data.charCodeAt(i++);
					       e1 = c1 >> 2;
					       e2 = ((c1 & 3) << 4) + (c2 >> 4);
					       e3 = ((c2 & 15) << 2) + (c3 >> 6);
					       e4 = c3 & 63;
					       if (isNaN(c2))
					         e3 = e4 = 64;
					       else if (isNaN(c3))
					         e4 = 64;
					       out += tab.charAt(e1) + tab.charAt(e2) + tab.charAt(e3) + tab.charAt(e4);
					    }
					    return out;
					  }
					
					  function decode_base64(data) {
					    var out = "", c1, c2, c3, e1, e2, e3, e4;
					    for (var i = 0; i < data.length; ) {
					      e1 = tab.indexOf(data.charAt(i++));
					      e2 = tab.indexOf(data.charAt(i++));
					      e3 = tab.indexOf(data.charAt(i++));
					      e4 = tab.indexOf(data.charAt(i++));
					      c1 = (e1 << 2) + (e2 >> 4);
					      c2 = ((e2 & 15) << 4) + (e3 >> 2);
					      c3 = ((e3 & 3) << 6) + e4;
					      out += String.fromCharCode(c1);
					      if (e3 != 64)
					        out += String.fromCharCode(c2);
					      if (e4 != 64)
					        out += String.fromCharCode(c3);
					    }
					    return out;
					  }
					
					  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
					  return { encode:encode_base64, decode:decode_base64 };
					})();
				
					var com = ( com!=undefined ? com : {} );
					var com_joangarnet = ( com.joangarnet!=undefined ? com.joangarnet : com.joangarnet={} );
					if( com.joangarnet.JSProxy == undefined )
					{
						/* 
						 * JSProxy.js 
						 * utility class to proxy javascript actions from ActionScript
						 * @author Joan Garnet (http://www.joangarnet.com/blog)
						 */
						com.joangarnet.JSProxy = function(movieID)
						{
							this.movieID = movieID;// we need this id in order to be able to call "document[this.movieID].jsLoadedHandler();"
							this.inlineCode = [];
							/* 
							 * @public
							 */
							this.getProperty = function(prop){
								var scopeFragment = this.resolveScope(prop);
								return scopeFragment.path[scopeFragment.prop];
							}
							this.setProperty = function(prop,value){
								var scopeFragment = this.resolveScope(prop);
								scopeFragment.path[scopeFragment.prop] = value;
							}
							this.loadScript = function(src){
								var head = document.getElementsByTagName('head')[0];
								var script = document.createElement('script');
								script.type = 'text/javascript';
								script.parentScope = this;
								script.onload = function() {
									this.parentScope.scriptOnLoadHandler();
								}
								script.onreadystatechange = function() {//ie
									if (this.readyState == 'complete') {
										this.parentScope.scriptOnLoadHandler();
									}
								}
								script.src = src;
								head.appendChild(script);
							}
							
							/*
							 * This method decode and compiles the Base64 string containing the code 
							 * @author Pedro Casaubon (http://www.xperiments.es/blog)
							 */
							this.compileCode = function( str )
							{
							 	var myFucn = new Function(Base64.decode(str));
							 	myFucn();								
							}							
							/* 
							 * @private 
							 */
							this.resolveScope = function(prop){
								var scopeChain = prop.split(".");
								var scope = window;
								for( var i=0; i<scopeChain.length-1; i++ ){
									scope = scope[scopeChain[i]];
								}
								return {path:scope,prop:scopeChain[i]};
							}
							this.scriptOnLoadHandler = function(){
								var isIE = navigator.appName.indexOf("Microsoft") != -1;
								var movie = (isIE) ? window[this.movieID] : document[this.movieID];
								try{
									movie.jsLoadedHandler();
								}catch(err){
									alert("Error: " + err.message );
								}
							}
						}
						/* 
						 * @public static
						 */
						// instances hash
						com.joangarnet.JSProxy.instances = {};
						com.joangarnet.JSProxy.getInstanceByID = function(movieName){
							var instance = com.joangarnet.JSProxy.instances[movieName];
							return instance!=undefined ? instance : (com.joangarnet.JSProxy.instances[movieName] = new com.joangarnet.JSProxy(movieName));
						}
						// facade
						com.joangarnet.JSProxy.facade = function( movieName, methodName, params_arr ) {
							var instance = com.joangarnet.JSProxy.getInstanceByID(movieName);
							var method = instance[methodName];
							if(method==undefined){throw new Error("Attempt to call an undefined method: JSProxy."+methodName);}
							return method.apply( instance, params_arr );
						}
					}
				]]>
			</script>;
		/*
		 * end javascript toolkit
		 */
		
		private var movieID:String;
		
		public function JavaScript(movieID:String,url:String=null)
		{
			this.movieID = movieID;
			if( !ExternalInterface.available ){
				throw new Error("ExternalInterface not available"); 
			}
			eventDispatcher = new EventDispatcher(this);
			ExternalInterface.marshallExceptions = true;
			
			// compile internal toolkit
			try{
				ExternalInterface.call( "eval", JSProxyTools.toString() );
			}catch(err:Error){
				throw new Error( "com.joangarnet.js.JavaScript::constructor()\ngetStackTrace() "+ err.getStackTrace() );
			}
			
			// handle the loaded script callback
			ExternalInterface.addCallback( "jsLoadedHandler", jsLoaded );
			
			if(url)this.url = url;
		}

		private function callToolkit( methodName:String, params_arr:Array ):*
		{
			var res:*;
			try{
				res = ExternalInterface.call( "com.joangarnet.JSProxy.facade", movieID, methodName, params_arr );
			}catch(err:Error){
				throw new Error( "com.joangarnet.js.JavaScript::callToolkit()\ngetStackTrace() "+ err.getStackTrace() );
			}
			return res;
		}
		
		private function set url( url:String ):void
		{
			callToolkit( "loadScript", [url] );
		}

		public function set js( jsCode:String ):void
		{
			compile( jsCode );
		}
		
		public function getScope( scope:String=WINDOW ):JavaScript
		{
			this.scope = scope.replace( /^(window\.?)(.*)/i, "$2" );
			return this;
		}

		private function jsLoaded():void
		{
			trace("jsLoaded!");
			dispatchEvent( new Event(Event.COMPLETE) );
		}

		/*
		 * Modified method to support Base64 encoding
		 * @author Pedro Casaubon (http://www.xperiments.es/blog)
		 */
		private function compile( jsCode:String ):void
		{
			// javascript compilation
			try{
					var ba:ByteArray = new ByteArray();
					ba.writeUTFBytes( jsCode );
					ba.position = 0;
					var baseCode:String = Base64.encode( ba );
					callToolkit( "compileCode", [baseCode] );

			}catch(err:Error){
				throw new Error( "com.joangarnet.js.JavaScript::compile() javascript compilation error\ngetStackTrace() "+ err.getStackTrace() );
			}
			dispatchEvent( new Event(Event.COMPLETE) );
		}
		
		private function buildPath( objectMember:String ):String
		{
			return (scope.length>0 ? scope+"."+objectMember : objectMember);
		}

		/*
		 * Proxy implementation
		 */
		override flash_proxy function callProperty(methodName:*, ... args):* 
		{
			var res:*;
			var functionCall:String = buildPath((methodName as QName).localName);
			try{
				args = args!=null ? args : []; 
				args.unshift( functionCall );
				res = ExternalInterface.call.apply(null, args);
			}catch(err:Error){
				throw new Error( "com.joangarnet.js.JavaScript::"+functionCall+"()\ngetStackTrace() "+ err.getStackTrace() );
			}
			return res;
		}
		override flash_proxy function getProperty(name:*):* 
		{
			return callToolkit( "getProperty", [buildPath((name as QName).localName)] );
		}
		override flash_proxy function setProperty(name:*, value:*):void 
		{
			callToolkit( "setProperty", [buildPath((name as QName).localName), value] );
		}

		/*
		 * IEventDispatcher implementation
		 */
		public function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean=false):void
		{
			eventDispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);
		}
		
		public function removeEventListener(type:String, listener:Function, useCapture:Boolean=false):void
		{
			eventDispatcher.removeEventListener(type, listener, useCapture);
		}
		
		public function dispatchEvent(event:Event):Boolean
		{
			return eventDispatcher.dispatchEvent(event);
		}
		
		public function hasEventListener(type:String):Boolean
		{
			return eventDispatcher.hasEventListener(type);
		}
		
		public function willTrigger(type:String):Boolean
		{
			return eventDispatcher.willTrigger(type);
		}
	}
}