package
{
	import flash.utils.*;
	import flash.display.*;
	import flash.system.LoaderContext;
	import flash.events.*;
	import by.blooddy.crypto.*;
	import flash.system.SecurityDomain;

	public class GraphicExportDef
	{
		public const TYPE_SPRITES = 1;
		public const TYPE_SKELETAL = 2;
		
		private var _exportType:int = 1;
		public function get exportType():int { return _exportType; }
		
		private var _className:String = null;
		public function get className():String { return _className; }
		
		private var _name:String = null;
		public function get name():String { return _name; }
		
		private var _valid:Boolean = false;
		public function get valid():Boolean { return _valid; }
		
		private var _padding:int = 0;
		public function get padding():int { return _padding; }
		
		private var _scale:Number = 0;
		public function get scale():Number { return _scale; }
		
		private var input:ByteArray;
		private var inputLoader:Loader = null;		
		
		private var parentJob:Job = null;
		
		private var callback = null;
		
		private var index:int = 0;
		
		public function GraphicExportDef(parentJob:Job, details, index:int)
		{
			this.parentJob = parentJob;
			this.index = index;
			if (!details.hasOwnProperty("type") ||
				!details.hasOwnProperty("name") ||
				!details.hasOwnProperty("input") ||
				!details.hasOwnProperty("class_name"))
			{
				Fail("graphic export is missing a required class_name, name, type, or input");
				return;
			}
			_exportType = parseInt(details.type);
			_name = "" + details.name;
			_className = "" + details.class_name;
			input = Base64.decode("" + details.input);
			_padding = details.hasOwnProperty("padding") ? parseInt(details.padding) : 0;
			_scale = details.hasOwnProperty("scale") ? parseFloat(details.scale) : 1;
			_valid = true;
		}
		
		public function Fail(err:String)
		{
			parentJob.FailMessage("(" + index + ")" + err);
			_valid = false;
			if (callback != null) callback();
		}
		
		public function Go(callback)
		{
			this.callback = callback;
			
			inputLoader = new Loader();
			inputLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, LoaderComplete);
			inputLoader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, LoaderError);
			var context:LoaderContext = new LoaderContext();
			context.allowCodeImport = true;
			inputLoader.loadBytes(input, context);
		}
		
		private var frames:IFramesSource = null;
		
		private function LoaderComplete(e)
		{
			try
			{
				var classDef = e.target.applicationDomain.getDefinition(className);
				if (classDef == null)
				{
					Fail("didn't contain a definition for " + className);
					return;
				}
				
				var clip = new classDef();
				if (!(clip is MovieClip))
				{
					Fail(className + " wasn't a movieclip");
				}
				
				Utils.RecursivelyStop(clip);
				
				frames = null;
				
				switch (exportType)
				{
					case TYPE_SPRITES:
						frames = new AnimatedSpriteGenerator(clip, this);
					break;
					case TYPE_SKELETAL:
						frames = new AnimatedSkeletonGenerator(clip, this);
					break;
				}
				
				if (frames == null)
				{
					Fail("invalid export type: " + exportType);
					return;
				}
				
				frames.Go(FramesDone);
				
			} catch (e)
			{
				Exporter.Instance.Print(e.getStackTrace());
			}
		}
		
		private function FramesDone(success)
		{
			if (!success)
			{
				Fail("couldn't get source frames");
				return;
			}
			Done();
		}
		
		private function LoaderError(e)
		{
			Fail("couldn't load input: " + e.toString());
		}
		public function Done()
		{			
			this.callback();
		}
		
		public function GetFrames():Array
		{
			return frames.GetFrames();
		}
		
		public function GetData()
		{
			return frames.GetData();
		}
	}
}