/**
 * Author: David Lenaerts
 */
package away3d.core.managers
{
	import away3d.arcane;
	import away3d.events.Stage3DEvent;
	import away3d.materials.utils.CubeMap;

	import flash.display3D.Context3D;
	import flash.display3D.Context3DTextureFormat;
	import flash.display3D.textures.CubeTexture;

	use namespace arcane;

	public class CubeTexture3DProxy
	{
		private var _cubeMap : CubeMap;
		private var _textures : Vector.<CubeTexture>;
		private var _dirty : Vector.<Boolean>;
		private var _maxIndex : int = -1;
		private var _listensForDispose : Vector.<Boolean>;

		public function CubeTexture3DProxy()
		{
			_textures = new Vector.<CubeTexture>(8);
			_dirty = new Vector.<Boolean>(8);
			_listensForDispose = new Vector.<Boolean>(8);
		}

		public function get cubeMap() : CubeMap
		{
			return _cubeMap;
		}

		public function set cubeMap(value : CubeMap) : void
		{
			if (value == _cubeMap) return;

			if (_cubeMap) {
				if (value.size != _cubeMap.size)
					invalidateSize();
				else
					invalidateContent();
			}

			_cubeMap = value;
		}

		public function invalidateContent() : void
		{
			for (var i : int = 0; i <= _maxIndex; ++i) {
				_dirty[i] = true;
			}
		}

		private function invalidateSize() : void
		{
			var tex : CubeTexture;
			for (var i : int = 0; i <= _maxIndex; ++i) {
				tex = _textures[i];
				if (tex) {
					tex.dispose();
					_textures[i] = null;
					_dirty[i] = false;
				}
			}
		}

		public function dispose(deep : Boolean) : void
		{
			if (deep) {
				if (_cubeMap) _cubeMap.dispose();
				_cubeMap = null;
			}

			for (var i : int = 0; i <= _maxIndex; ++i)
				if (_textures[i]) _textures[i].dispose();
		}

		public function getTextureForContext(stage3DProxy : Stage3DProxy) : CubeTexture
		{
			var contextIndex : int = stage3DProxy._stage3DIndex;
			var context : Context3D = stage3DProxy._context3D;

			if (contextIndex > _maxIndex) _maxIndex = contextIndex;
			var tex : CubeTexture = _textures[contextIndex];

			if (!_listensForDispose[contextIndex]) {
				stage3DProxy.addEventListener(Stage3DEvent.CONTEXT3D_DISPOSED, onContext3DDisposed);
				_listensForDispose[contextIndex] = true;
			}

			if (!tex || _dirty[contextIndex]) {
				if (!tex) _textures[contextIndex] = tex = context.createCubeTexture(_cubeMap.size, Context3DTextureFormat.BGRA, false);
				_cubeMap.upload(_textures[contextIndex]);
				_dirty[contextIndex] = false;
			}

			return tex;
		}

		private function onContext3DDisposed(event : Stage3DEvent) : void
		{
			var stage3DProxy : Stage3DProxy = Stage3DProxy(event.target);
			var contextIndex : int = stage3DProxy._stage3DIndex;

			if (_textures[contextIndex]) {
				_textures[contextIndex].dispose();
				_textures[contextIndex] = null;
			}

			_listensForDispose[contextIndex] = false;

			stage3DProxy.removeEventListener(Stage3DEvent.CONTEXT3D_DISPOSED, onContext3DDisposed);
		}
	}
}