package com.oxylusflash.book
{
	import com.as3dmod.*;
	import com.as3dmod.modifiers.*;
	import com.as3dmod.plugins.pv3d.*;
	import flash.display.*;
	import flash.events.*;
	import org.papervision3d.materials.utils.*;
	import org.papervision3d.objects.*;
	import org.papervision3d.objects.primitives.*;
	import org.papervision3d.view.layer.ViewportLayer;
	
	public class BookPage3D extends DisplayObject3D
	{
		// 3D page is a cube (it has to have 2 faces)
		protected var page3D:Cube;
		
		// Modifiers stack.
		protected var modStack:ModifierStack;
		
		// Bend modifier.
		protected var bendMod:Bend = new Bend(0, 0.2);
		
		// Properties.
		protected var _bendRotation:Number = 0;
		protected var _bendForce:Number = 0;
		protected var _bendAngle:Number = 0;
		protected var _isHard:Boolean = false;
		
		// Constants.
		protected static const MAX_BEND_ANGLE:Number = 8 * Global.DEG2RAD;
		protected static const MAX_BEND_FORCE:Number = 1;
		protected static const MAX_BEND_ROTATION:Number = 180;
		protected static const FLIP_LIMIT:Number = 0.3;
		protected static const HARD_FLIP_LIMIT:Number = -0.05;
		
		// Materials.
		private var pageMat:MaterialsList;
		public var backMat:PageMaterial;
		public var frontMat:PageMaterial;
		
		// Side, page index, page flipped check
		protected var _side:int = 0;
		protected var _index:int;
		protected var _flipped:Boolean = false;
		
		//public var layer:ViewportLayer;
		
		/**
		 * Create new 3D book page.
		 * @param	frontBmp	Bitmap data for front.
		 * @param	backBmp		Bitmap data for the back.
		 * @param	idx			Page index.
		 */
		public function BookPage3D(frontBmp:BitmapData, backBmp:BitmapData, idx:int):void
		{
			
			Global.theBook.pagesHolder.addEventListener(BookPagesHolder.POSITION_CHANGE, pagesHolder_positionChangeHandler, false, 0, true);
			bendMod.switchAxes = Global.bendSwitchAxes;
			
			// Create materials.
			frontMat = new PageMaterial(frontBmp);
			backMat = new PageMaterial(backBmp);
			
			pageMat = new MaterialsList();
			pageMat.addMaterial(frontMat, "front");
			pageMat.addMaterial(backMat, "back");
			
			var pw:Number = Global.xmlBookPage.width * Global.theBook.pagesHolder.scaleX;
			var ph:Number = Global.xmlBookPage.height * Global.theBook.pagesHolder.scaleY;
			
			// Create 3D page as cube
			page3D = this.addChild(new Cube(pageMat, pw, 0, ph, Global.xmlPage3D.segments, 1, 1, Cube.FRONT + Cube.BACK, Cube.TOP + Cube.BOTTOM + Cube.LEFT + Cube.RIGHT)) as Cube;
			//page3D.useOwnContainer = true;
			page3D.useClipping = true;
			
			//layer = this.createViewportLayer(Global.theBook.viewport, false);
			
			// Init modifier
			modStack = new ModifierStack(new LibraryPv3d, page3D);
			modStack.addModifier(bendMod);
			
			_index = idx;
			if (Global.xmlFlipBook.hardCovers)
			{
				_isHard = idx < 2 || idx >= Global.theBook.numPages - 2;
			}
		}
		
		/**
		 * Position change handler.
		 * @param	e
		 */
		private function pagesHolder_positionChangeHandler(e:Event):void
		{
			this.x = Global.theBook.pagesHolder.holderX * Global.theBook.pagesHolder.scaleX;
			Global.theBook.render3DScene(this);
		}
		
		/**
		 * Get limited value.
		 * @param	value	Value to limit.
		 * @return	Limited value.
		 */
		private function limitedValue(value:Number):Number
		{
			return value < -1 ? -1 : (value > 1 ? 1 : value);//Math.max(-1, Math.min(1, value));
		}
		
		/**
		 * Bend force.
		 */
		public function get bendForce():Number { return _bendForce; }
		public function set bendForce(value:Number):void
		{
			value = _isHard ? 0 : limitedValue(value);
			if (_bendForce != value)
			{
				_bendForce = value;
				updateBendForce();
			}
		}
		
		/**
		 * Bend angle.
		 */
		public function get bendAngle():Number { return _bendAngle; }
		public function set bendAngle(value:Number):void
		{
			value = _isHard ? 0 : limitedValue(value);
			if (_bendAngle != value)
			{
				_bendAngle = value;
				updateBendAngle();
			}
		}
		
		/**
		 * Bend rotation.
		 */
		public function get bendRotation():Number { return _bendRotation; }
		public function set bendRotation(value:Number):void
		{
			value = limitedValue(value);
			if (_bendRotation != value)
			{
				_bendRotation = value;
				updateBendRotation();
			}
		}
		
		// Page side (left or right)
		public function get side():int { return _side; }
		
		// Page index.
		public function get index():int { return _index; }
		
		// Page is flipped or not.
		public function get flipped():Boolean { return _flipped; }
		
		// Page is hard (cannot be bent) or not.
		public function get isHard():Boolean { return _isHard; }
		
		// Functions used for overwritting.
		protected function updateBendForce():void { }
		protected function updateBendAngle():void { }
		protected function updateBendRotation():void { }
		
		// Apply modifiers.
		public function applyBendParams():void
		{
			if (modStack) modStack.apply();
		}
		
		// Kill 3D page.
		public function die():void
		{
			Global.theBook.pagesHolder.removeEventListener(BookPagesHolder.POSITION_CHANGE, pagesHolder_positionChangeHandler);
			page3D.destroy();
			page3D = null;
			pageMat = null;
			frontMat.destroy();
			backMat.destroy();
			modStack.clear();
			modStack = null;
			bendMod = null;
		}
	}
}