package {
	import flash.display.*;
	import flash.events.*;
	import flash.media.Sound;
	import flash.net.URLRequest;
	import flash.utils.*;
	import flash.geom.*;
	
	import mx.core.UIComponent;
	import mx.effects.*;
	import mx.events.*
	import mx.core.IFactory;
	import mx.core.IDataRenderer;
	
	import flash.geom.Matrix;

	[Event("changing")]	
	[Event("change")]	

	public class Carousel extends UIComponent {

	/*--------------------------------------------------------------------------
	//  variables
	//------------------------------------------------------------------------*/
		// settable
		private var _dataProvider:Array = [];
		private var _itemRenderer:IFactory;
		private var _arc:Number = Math.PI;
		private var _maxArc:Number = 0;
		private var _maxScaleFactor:Number = 1.2;
		private var _minScaleFactor:Number = .3;
		private var _minAlpha:Number = .2;
		private var _decceleration:Number;
		private var _userDecceleration:Number = DEFAULT_DECCELERATION;
		private var _tileDisplayMode:String = "poster";
		private var _pinPosition:Number;
		private var _maxMajorRadius:Number = 900;
		private var _maxMinorRadius:Number = 120;
		private var _tiltAngle:Number;
		private var _fadeToMaxArc:Boolean = true;
		// calculated
		private var _itemList:Array = [];
		private var _maxItemHeight:Number;
		private var _maxItemWidth:Number;
		private var _majorRadius:Number;
		private var _minorRadius:Number;
		private var _origin:Point;
		// details stored for mouse tracking
		private var _trackOffset:Number;
		private var _trackTarget:Number;		
		private var _trackStartAngle:Number;
		private var _pinStartAngle:Number;
		private var _velocity:Number;

		private static const DEFAULT_DECCELERATION:Number = .01;
		private var _spinState:int = SPIN_STATE_NONE;
		private var trackTimer:Timer;
		
		private var _spokes:Sprite;


	/*--------------------------------------------------------------------------
	//  constants
	//------------------------------------------------------------------------*/

		
		
		private static const SPIN_STATE_NONE:int = 0;
		private static const SPIN_STATE_SNAP_TO_CLOSEST:int = 1;
		private static const SPIN_STATE_TRACK_MOUSE:int = 2;
		private static const SPIN_STATE_SPIN_TO_ZERO:int = 3;
		private static const SPIN_STATE_SLOW_DOWN:int = 4;
		
		

	/*--------------------------------------------------------------------------
	//  properties
	//------------------------------------------------------------------------*/

		public var pinIndex:Number = 0;

		/**
		 */
		public function set decceleration(value:Number):void
		{
			_userDecceleration = value;			
		}
		
		public function set maxArc(value:Number):void
		{
			_maxArc = value;
			invalidateDisplayList();
		}
		public function get maxArc():Number {return _maxArc;}

		public function set arc(value:Number):void
		{
			_arc = value;
			invalidateDisplayList();
		}
		public function get arc():Number {return _arc;}


		public function set tiltAngle(value:Number):void
		{
			_tiltAngle = value;
			invalidateDisplayList();
		}
		public function get tiltAngle():Number {return _tiltAngle;}
		
		public function get decceleration():Number { return _userDecceleration; }

		/**
		 */
		public function set maxScaleFactor(value:Number):void
		{
			_maxScaleFactor = value;
			invalidateDisplayList();			
		}
		public function get maxScaleFactor():Number { return _maxScaleFactor; }

		/**
		 */
		public function set tileDisplayMode(value:String):void
		{
			_tileDisplayMode = value;
			invalidateDisplayList();
		}
		public function get tileDisplayMode():String { return _tileDisplayMode; }
		

		/**
		 */
		public function set dataProvider(value:Array):void {
			_dataProvider = value;	
			removeImages();
			loadImages();
		}	
		public function get dataProvider():Array { return _dataProvider; }
	
		public function set pinPosition(value:Number):void
		{
			setPinPosition(value,true);
		}

		private function setPinPosition(value:Number,invalidate:Boolean):void
		{
			while(value < -1)
				value += 2;

			while(value > 1)
				value -= 2;

			_pinPosition = value;
			if(invalidate)
				invalidateDisplayList();
		}
		public function get pinPosition():Number { return _pinPosition; }

	/*--------------------------------------------------------------------------
	//  methods
	//------------------------------------------------------------------------*/
		/**
		 */
		public function Carousel()
		{		
			_itemRenderer = new ClassFactory(BitmapTile);
			_dataProvider = [];
			trackTimer = new Timer(50);					
			trackTimer.addEventListener(TimerEvent.TIMER,updateTimer);
			
			addEventListener(MouseEvent.MOUSE_DOWN,beginTrack);
			
			_spokes = new Sprite();
		}

		private function updateTimer(e:Event):void 
		{
			invalidateDisplayList();	
		}

	
		
		private function removeImages():void
		{
			for(var i:int = 0; i < _itemList.length;i++) {
				this.removeChild(_itemList[i].tile);	
			}
			_itemList = [];
			invalidateDisplayList();
			
		}
		private function loadImages():void
		{
			for(var i:int =0;i<_dataProvider.length;i++)
			{
				var item:Object = _dataProvider[i];
				
				var tile:UIComponent = _itemRenderer.newInstance();
				if(tile is IDataRenderer)
					IDataRenderer(tile).data = item;
					
				var imgData:ItemData = new ItemData();
				imgData.tile = tile;
				imgData.item = item;
			
				_itemList[i] = imgData;
				addChild(tile);
			}
			invalidateDisplayList();						
		}
				
		private function set spinState(value:int):void
		{
			if(value == _spinState)
				return;
			_spinState = value;
			switch(_spinState)
			{
				case SPIN_STATE_NONE:
					trackTimer.stop();
					break;
				case SPIN_STATE_SLOW_DOWN:
					_decceleration = (_velocity > 0)? -_userDecceleration:_userDecceleration;
					if(!trackTimer.running)
					{	
						trackTimer.reset();
						trackTimer.start();
					}
					break;				
				default:
					if(!trackTimer.running)
					{	
						trackTimer.reset();
						trackTimer.start();
					}
					break;
			}
		}
		
		

		private function updateSpin():Boolean
		{
			var sendChangeMessage:Boolean = false;	
			switch(_spinState)
			{
				case SPIN_STATE_TRACK_MOUSE:
					_trackTarget = _pinStartAngle + (calcAngle(mouseX,mouseY,_trackOffset) - _trackStartAngle);
						
					if(Math.abs(pinPosition-  _trackTarget) < .01)
					{
						_velocity = 0;
						_trackTarget = pinPosition;
						setPinPosition(pinPosition,false);												
					}
					else
					{
						_velocity = (_trackTarget-pinPosition)/3;
						setPinPosition(pinPosition + _velocity,false);												
					}
					break;
				case SPIN_STATE_SPIN_TO_ZERO:
					if(Math.abs(_pinPosition ) < _userDecceleration)
					{						
						setPinPosition(0,false);												
						spinState = SPIN_STATE_NONE;
					}
					else
						setPinPosition(_pinPosition *4/5,false);												
					break;
				case SPIN_STATE_NONE:
					break;
				case SPIN_STATE_SLOW_DOWN:
					if(Math.abs(_velocity) <= Math.abs(_decceleration))
					{
						setPinPosition(_pinPosition + _velocity,false);
						sendChangeMessage = true;	
						spinState = SPIN_STATE_NONE;
					}
					else
					{
						setPinPosition(_pinPosition + _velocity,false);
						_velocity += _decceleration;
					}
					break;					
				case SPIN_STATE_SNAP_TO_CLOSEST:
					break;				
			}
			return sendChangeMessage;
		}

		override protected function measure():void
		{
			
			_maxItemHeight = 0;
			_maxItemWidth = 0;
			
			for(var i:int = 0;i<_itemList.length;i++)
			{
				var item:UIComponent = _itemList[i].tile;
				_maxItemHeight = Math.max(item.measuredHeight/item.scaleY,_maxItemHeight);
				_maxItemWidth = Math.max(item.measuredWidth/item.scaleX,_maxItemWidth);
			}
			
//			if(_arc > Math.PI)
//				measuredHeight = _maxMinorRadius*(1+Math.sin((_arc-Math.PI)/2) + maxItemHeight/2 * _maxScaleFactor + maxItemHeight/2 * _minScaleFactor;			
//			measuredWidth = _maxMajorRadius*2 + maxItemWidth/2 + maxItemWidth/2;
		}

		private function calcDimensions():void
		{
			// now calculate the maximum possible vertical radius given the current total arc
			var maxTotalArc:Number = Math.max(_arc,_maxArc);

			var hPositionInArc:Number = Math.min(1,(Math.PI/2)/(maxTotalArc/2));
			var hScale:Number = _maxScaleFactor + hPositionInArc * (_minScaleFactor - _maxScaleFactor);