/**
* SWFLoader
* 
* Instead of having to <code>[embed]</code> the desired .swf like other classes do,
* you can now load as many .swfs as you want dynamically when you need them
* and create instances of those symbols you defined an AS-linkage for.
* 
* Also it's not required to know the definition names, they get extracted
* from the .swf and put in an array you have access to by the
* <code>definition</code>-property.
* 
* Remember to enable Linkage and give a Class-name in the Flash IDE library for 
* every symbol you want to use here.
*
*  
* Original use of this class is to load runtime-defined .swfs and use them as libraries
* for a tileset-map-editor which is kinda non-existent at this moment :)
*
* 
* 
* -----------
* NOTE: maybe only up to 256 definitions allowed - needs further testing 
*
* 
* @author kris
* @version 0.666
*/

package de.kris.utils {
	
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.DisplayObject;
	import flash.display.Loader;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.errors.EOFError;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IOErrorEvent;
	import flash.events.ProgressEvent;
	import flash.media.Sound;
	import flash.net.URLLoader;
	import flash.net.URLLoaderDataFormat;
	import flash.net.URLRequest;
	import flash.system.LoaderContext;
	import flash.text.Font;
	import flash.utils.ByteArray;
	
	/**
	 * Loads a .swf-file, provides the definition-names and creates instances of the defined classes.
	 */
	public class SWFLoader extends EventDispatcher
	{
		private var l:Loader;
		private var ul:URLLoader;
		private var ba:ByteArray;
		
		private var classesNames:Array;
		private var debug:Boolean;
		
		private var ready:Boolean=false;
		
		
		/**
		 * Creates an SWFLoader-instance.
		 * 
		 * @param	url URL to the .swf file.
		 * @param	debug Debug-traces on/off.
		 */
		public function SWFLoader(url:String, debug:Boolean=false):void
		{
			super();
			this.debug = debug;
			
			dtrace("------------------------------------------------");
			
			ul = new URLLoader();
			ul.dataFormat = URLLoaderDataFormat.BINARY;
			ul.addEventListener(Event.COMPLETE, onULComplete);
			ul.addEventListener(IOErrorEvent.IO_ERROR, onIOError);
			ul.addEventListener(ProgressEvent.PROGRESS, onULProgress);
			ul.load(new URLRequest(url));

		}
		
		
		/**
		 * An array of strings, which represent the definition names you are allowed to instantiate.
		 */
		public function get definitions():Array
		{
			return ready?classesNames:null;
		}
		
				
		/**
		 * Returns the class.
		 * 
		 * @param	className
		 * @return 	The class definition itself. (useful for fonts or other shizzle)
		 */
		public function getDefinition(className:String):Class
		{
			return (classesNames.indexOf(className)!=-1)?(l.contentLoaderInfo.applicationDomain.getDefinition(className) as Class):null;
		}
		
		
		/**
		 * If existing and extending Sprite, an instance of the class is created and returned as Sprite. (You can cast it to a more special type (like MovieClip) after calling the function!)
		 * 
		 * @param	className The name of the class you want to instantiate, if the name is not in the definitions-array. Otherwise null!
		 * @return	The instance
		 */
		public function getSprite(className:String):Sprite
		{
			return getValidatedClassIfReady(className, "flash.display::Sprite") as Sprite;
			//return (classesNames.indexOf(className)!=-1)?DisplayObject(new (l.contentLoaderInfo.applicationDomain.getDefinition(className) as Class)()):null;
		}
		
				
		/**
		 * [ Deprecated function. Kept because of old implementations in older projects of mine.. :D ]
		 * 
		 * If existing and extending Sprite, an instance of the class is created and returned as Sprite. (You can cast it to a more special type (like MovieClip) after calling the function!)
		 * 
		 * @param	className The name of the class you want to instantiate, if the name is not in the definitions-array. Otherwise null!
		 * @return	The instance
		 */
		public function getInstance(className:String):Sprite
		{
			return getSprite(className);
		}
		
				
		/**
		 * Creates an instance of the class represented by the index in the definitions-array. Useful for random instances.
		 * 
		 * @param	id Index of class in the definitions-array.
		 * @return The instance...
		 */
		public function getSpriteByID(id:uint):Sprite
		{
			return (ready && classesNames && id<classesNames.length)?getSprite(classesNames[id]):null;
		}
		
		
		/**
		 * Creates an instance of BitmapData and returns it.
		 * 
		 * @param	className
		 * @return
		 */
		public function getBitmapData(className:String):BitmapData
		{
			return getValidatedClassIfReady(className, "", [0, 0]) as BitmapData;
			//return (classesNames.indexOf(className)!=-1)?new(l.contentLoaderInfo.applicationDomain.getDefinition(className) as Class)(0,0):null;
		}
		
		/**
		 * Creates an instance of Bitmap (using getBitmapData()) and returns it.
		 * @param	className
		 * @return
		 */
		public function getBitmap(className:String):Bitmap
		{
			return new Bitmap(getBitmapData(className));
		}

		
		/**
		 * Registers the font, returns the string. 
		 * 
		 * Example:
		 * myTextField.defaultTextFormat = new TextFormat(mySWFLoader.getFont("myFont"));
		 * 
		 * @param	className
		 * @return	If successful, the font's string. Otherwise an empty string.
		 */
		public function getFont(className:String):String
		{
			if (classesNames.indexOf(className) != -1)
			{
				var tmp:Class = getDefinition(className);
				Font.registerFont(tmp);
				
				return new tmp().fontName;
			}

			dtrace("some font related error occured.")
			return "";
		}
		
		
		public function getSound(className:String):Sound
		{
			return getValidatedClassIfReady(className, "") as Sound;
		}
		
		
		
		/**
		 * 
		 * @param	className
		 * @param	neededSuperClass
		 * @return
		 */
		private function getValidatedClassIfReady(className:String, neededSuperClass:String, args:Array=null):Object
		{
			if (ready)
			{
				var isExtended:Boolean = false;
				var result:Object = null;
				
				if (!args)
					args = [];
				
				if (classesNames.indexOf(className) != -1 && l.contentLoaderInfo.applicationDomain.hasDefinition(className))
				{
					var c:Object = l.contentLoaderInfo.applicationDomain.getDefinition(className);
					var xml:XML = flash.utils.describeType(c);
					//trace(xml);
					
					for each(var bla:* in xml.factory.extendsClass)
					{
						if (String(bla.@type).indexOf(neededSuperClass) != -1)
						{
							dtrace(bla.@type);
							isExtended = true;
							break;
						}
					}
				
					if (isExtended)
					{
						var constructorParamCount:int = xml.factory.constructor.parameter.length();
						
						switch(xml.factory.constructor.parameter.length())
						{
							case 0:
								result = new c();
							break;
							
							//sound
							case 1:
								result = new c(0);
							break;
							
							//bitmap
							case 2:
								result = new c(0, 0);
							break;
						}
					}
					else
						dtrace("given class does not extend " + neededSuperClass + ": " + className);
					
				}
				else
				{
					dtrace("no definition found: " + className);
				}
				
				return result;
			}
			else
			{
				dtrace("not possible to create anything - there were errors!");
				return null;
			}
		}
		
		private function _constructor():void
		{ }

		private function dtrace(msg:Object):void
		{
			if(debug==true)
				trace("[SWFLoader] " + msg.toString());
				
		}
		
		private function onIOError(ioe:IOErrorEvent):void
		{
			dtrace("error loading swf:");	
			dtrace(ioe.text);
			dtrace("------------------------------------------------");
		}
		
		private function onULProgress(e:ProgressEvent):void 
		{
			dispatchEvent(e.clone());
		}
		
		private function onULComplete(e:Event):void
		{
			var tmp:ByteArray = new ByteArray();
			ba = new ByteArray();
			
			tmp.writeObject(ul.data);
			tmp.position = tmp.length - ul.bytesLoaded;
			tmp.readBytes(ba);
			
			ba.position = 0;
			
			switch(ba.readUTFBytes(3))
			{
				case "CWS":
					dtrace("compressed movie loaded.");
					decompressSWF();
				break;
				
				case "FWS":
					dtrace("uncompressed movie loaded.");
				break;
				
				default:
					dtrace("not a valid swf!");
					dtrace("------------------------------------------------");
			}
			
			if (readClasses())
			{	
				l = new Loader();
				l.contentLoaderInfo.addEventListener(Event.COMPLETE, onLComplete);
				l.loadBytes(ba);
			}
			else
				dtrace("------------------------------------------------");
		}
		
		private function onLComplete(e:Event):void
		{
			l.contentLoaderInfo.removeEventListener(Event.COMPLETE, onLComplete);
			
			dtrace("ready to instantiate.");
			dtrace("------------------------------------------------");
			ready = true;
			
			ul = null;
			
			dispatchEvent(new Event(Event.COMPLETE));
		}
		
		private function decompressSWF():void
		{
			dtrace("decompressing...");
			//uncompressed bytearray
			var uba:ByteArray = new ByteArray();
			//temp bytearray
			var tmp:ByteArray = new ByteArray();
			
			//put first 8 uncompressed bytes in uba
			ba.position = ba.length - ul.bytesLoaded;
			ba.readBytes(tmp, 0, 8);
			uba.writeBytes(tmp);
			
			//set first 3 bytes to FWS for uncompressed
			uba.position=0;
			uba.writeUTFBytes("FWS");
			
			//read compressed bytes into tmp and uncompress
			ba.readBytes(tmp, 0, 0);
			tmp.uncompress();
			
			//put uncompressed bytes after 8byte-header
			uba.position = 8;
			uba.writeBytes(tmp);
			
			//et voila
			dtrace("complete! before: " + ba.length + "B, after: " + uba.length + "B");
			ba = uba;
			uba = null;
			
			
		}
		
		private function readClasses():Boolean
		{
			dtrace("");
			dtrace("reading classes..");
			
			//searching for dictionary-tag
			var dictOffset:uint = 0;
			var classesNum:uint = 0;
			
			ba.position = 8;
			
			try
			{
				while(ba.bytesAvailable && dictOffset==0)
				{
					if (ba.readUnsignedByte() == 0)
						if (ba.readUnsignedByte() == 0)
							if (ba.readUnsignedByte() == 0)
								if (ba.readUnsignedByte() == 63)
									if (ba.readUnsignedByte() == 19)
					
					dictOffset = ba.position;
				}

				//read number of available definitions
				ba.position+=4;
				classesNum = ba.readUnsignedByte();
				dtrace( classesNum + " definition(s) found:");
				
				
				//getting definition-names
				classesNames = new Array();
				ba.position+=1;
				var tmpName:String;
				var tmpID:uint;
				var char:uint;
				
				while(classesNum>0)
				{
					tmpID = ba.readUnsignedByte();
					ba.position++;
					
					tmpName = "";
					char = 0;
					while((char = ba.readUnsignedByte())!=0)
					{
						tmpName += String.fromCharCode(char);
					}
	//					trace(tmpID + " - " + tmpName);
					
					classesNames.push(tmpName);
					
					classesNum--;
				}
			}
			catch ( e:EOFError )
			{
				dtrace(e);
				dtrace("no symbols in library found or some unkown error");
				return false;
			}
			
			classesNames.sort();
			
			tmpName = "";
			for (var i:int = 0; i < classesNames.length; i++ )
				tmpName += i + ") " + classesNames[i] + ", ";
			dtrace(tmpName.slice(0,tmpName.length-2));
			
			return true;
		}
		
		public function unload():void
		{
			ba = null;
			l = null;
			ul = null;
		}
		

	
	}
	
}