package
{
	import away3d.cameras.Camera3D;
	import away3d.containers.View3D;
	import away3d.core.math.Number3D;
	import away3d.core.render.Renderer;
 
	import flash.display.BlendMode;
	import flash.events.*;
 
	import mx.collections.ArrayCollection;
	import mx.core.UIComponent;
 
	import org.flintparticles.threeD.away3d.Away3DRenderer;
 
	public class EngineManager extends UIComponent
	{
		public static const version:String = "1.0.0";
		protected static const MEASURED_MIN_WIDTH:int = 25;
		protected static const MEASURED_MIN_HEIGHT:int = 25;
		protected static const MEASURED_WIDTH:int = 100;
		protected static const MEASURED_HEIGHT:int = 100;
 
		// Away3D view
		internal var view:View3D = null;
		// Away3D camera
		internal var cam:Camera3D = null;
		// a collection of the BaseObjects
		protected var baseObjects:ArrayCollection = new ArrayCollection();
		// a collection where new BaseObjects are placed, to avoid adding items
		// to baseObjects while in the baseObjects collection while it is in a loop
		protected var newBaseObjects:ArrayCollection = new ArrayCollection();
		// a collection where removed BaseObjects are placed, to avoid removing items
		// to baseObjects while in the baseObjects collection while it is in a loop
		protected var removedBaseObjects:ArrayCollection = new ArrayCollection();
		// the last frame time
		protected var lastFrame:Date;
		// the application manager
		internal var applicationManager:ApplicationManager = null;
		// the resource manager
		protected var myResourceManager:ResourceManager = null;
		// true when we have added the Away3D controls
		protected var addedToStage:Boolean = false;
		// true if some properties have been modifed
		protected var propertiesDirty:Boolean = false;
 
		// Away3D Flint renderer
		internal var renderer:Away3DRenderer = null;
 
		public static const ParticleSystems:ArrayCollection = new ArrayCollection(["fountain", "fire"]);
		protected static const ParticleSystemsString:String = ConvertArrayCollectionToString(ParticleSystems);
 
		protected var particleSystem:String = ParticleSystems[0];
 
		[Inspectable(defaultValue=particleSystem,enumeration=particleSystemsString)]
		[Bindable]
		public function set ParticleSystem(value:String):void
		{
			particleSystem = value;
			propertyChanged();
		}
 
		public function get ParticleSystem():String
		{
			return particleSystem;
		}
 
		internal function get MyResourceManager():ResourceManager
		{
			return myResourceManager;
		}
 
		protected function propertyChanged():void
		{
			propertiesDirty = true;
			invalidateProperties();
			invalidateDisplayList();
		}
 
		public static function ConvertArrayCollectionToString(array:ArrayCollection):String
		{
			var retValue:String = "";
			var i:int = 0;
			for each (var element:String in array)
			{
				if (i != 0) retValue += ",";
				retValue += element;
				++i;
			}
 
			return retValue;
		}
 
		public function EngineManager()
		{
			super();
		}
 
		override protected function measure():void
		{
			super.measure();
 
			// set a bunch of predefined sizes
			this.measuredMinWidth = MEASURED_MIN_WIDTH;
			this.measuredMinHeight = MEASURED_MIN_HEIGHT;
			this.measuredHeight = MEASURED_HEIGHT;
			this.measuredWidth = MEASURED_WIDTH;
		}
 
		override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void
		{
			super.updateDisplayList(unscaledWidth, unscaledHeight);
 
			if (view != null)
			{
				// resize the viewport to match the new settings
				view.height = this.height;
				view.width = this.width;
			}
		}
 
		override protected function commitProperties():void
		{
			super.commitProperties();
 
			if (propertiesDirty)
			{
				propertiesDirty = false;
 
				if (addedToStage)
				{
					applicationManager.shutdown();
					myResourceManager.shutdown();
					shutdownAll();
					myResourceManager.startupResourceManager();
					applicationManager.startupApplicationManager(this);
				}
			}
		}
 
		override protected function createChildren():void
		{
			super.createChildren();
 
			addEventListener(Event.ADDED_TO_STAGE, createChildrenEx);
			addEventListener(Event.REMOVED_FROM_STAGE, shutdown);
		}
 
		protected function shutdown(event:Event):void
		{
			if (applicationManager != null)
				applicationManager.shutdown();
 
			shutdownAll();
 
			this.removeChild(view);
 
			applicationManager = null;
			addedToStage = false;
			view = null;
			cam = null;
		}
 
		protected function createChildrenEx(event:Event):void
		{
			if (!addedToStage)
			{
				cam = new Camera3D({x:0, y:0, z:-500, lookat:new Number3D(0, 0, 0)});
 
				view = new View3D({x:stage.width/2, y:stage.height/2, camera:cam});
				view.renderer = Renderer.BASIC;
				addChild(view);
				addEventListener(Event.ENTER_FRAME, onEnterFrame);
 
				// set the initial frame time
				lastFrame = new Date();
 
				// initialise the Away3D Flint renderer
				renderer = new Away3DRenderer(view.scene );
 
				// load any resources
				myResourceManager = new ResourceManager(this);
				myResourceManager.startupResourceManager();
 
				// start the application manager
				applicationManager = new ApplicationManager().startupApplicationManager(this);
 
				addedToStage = true;
			}
		}
 
		protected function onEnterFrame(event:Event):void
		{
			// Calculate the time since the last frame
			var thisFrame:Date = new Date();
			var seconds:Number = (thisFrame.getTime() - lastFrame.getTime())/1000.0;
	    	lastFrame = thisFrame;
 
	    	// sync the baseObjects collection with any BaseObjects created or removed during the
	    	// render loop
	    	removeDeletedBaseObjects();
	    	insertNewBaseObjects();
 
	    	// allow each BaseObject to update itself
	    	for each (var baseObject:BaseObject in baseObjects)
	    		baseObject.enterFrame(seconds);
 
	    	// render the scene
	    	view.render();
		}
 
		public function addBaseObject(baseObject:BaseObject):void
		{
			newBaseObjects.addItem(baseObject);
		}
 
		public function removeBaseObject(baseObject:BaseObject):void
		{
			removedBaseObjects.addItem(baseObject);
		}
 
		public function shutdownAll():void
		{
			// don't dispose objects twice
			for each (var baseObject:BaseObject in baseObjects)
			{
				var found:Boolean = false;
				for each (var removedObject:BaseObject in removedBaseObjects)
				{
					if (removedObject == baseObject)
					{
						found = true;
						break;
					}
				}
 
				if (!found)
					baseObject.shutdown();
			}
		}
 
		protected function insertNewBaseObjects():void
		{
			for each (var baseObject:BaseObject in newBaseObjects)
				baseObjects.addItem(baseObject);
 
			newBaseObjects.removeAll();
		}
 
		protected function removeDeletedBaseObjects():void
		{
			for each (var removedObject:BaseObject in removedBaseObjects)
			{
				var i:int = 0;
				for (i = 0; i < baseObjects.length; ++i)
				{
					if (baseObjects.getItemAt(i) == removedObject)
					{
						baseObjects.removeItemAt(i);
						break;
					}
				}
 
			}
 
			removedBaseObjects.removeAll();
		}
	}
}