package {
	
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.geom.Point;
	
	import mx.effects.easing.*;
	
	[SWF(width="1000", height="1000", frameRate="30", backgroundColor="#000000")]
	public class SparkTable extends Sprite{
		
		private var tweenFunction:Function;
		
		
		private var canvas:Sprite;
		private var target:Sprite;
		
		private var color:uint;
		private var prevPoint:Point;
		private var q:Array;
		
		private var prevDifPoint:Point;
		
		private var count:Number;
		private var maxCount:Number = 100;
		private var steps:int = 10;
		private var distance:int = 500;
		private var duration:int = 50;
		
		private var speedScaleFactor:Number = 10;
		
		
		public function SparkTable(){
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			
			queue(Sine.easeOut,0xff0000);
			queue(Sine.easeIn,0x00ff00);
			queue(Sine.easeInOut,0x0000ff);
			
			/* queue(Quadratic.easeOut,0x990000);
			queue(Cubic.easeOut,0xCC0000);
			queue(Quintic.easeOut,0xFF0000);
			queue(Linear.easeOut,0xFFFFFF);
			
			queue(Exponential.easeOut,0xFF8000);
			queue(Circular.easeOut,0xFFFF00); */
			
			//queue(Bounce.easeOut,0xFF00FF);
			//queue(Elastic.easeOut,0x00FF00);
			//queue(Back.easeOut,0x0033FF);
			
			//queue(Back.easeIn,0x00ff00);
			
			//queue(sample,0xFFFFFF); 
			
			runNext();
		}
		
		/**
	     *  Test your own functions with this <code>sample()</code> method 
	     *
	     *  @param t Specifies time.
	     *
	     *  @param b Specifies the initial position of a component.
	     *
	     *  @param c Specifies the total change in position of the component.
	     *
	     *  @param d Specifies the duration of the effect, in milliseconds.
	     *
	     *  @return Number corresponding to the position of the component.
	     */  
		private function sample(t:Number, b:Number, c:Number, d:Number):Number {
			//return (((t/d)))  		*(c-b) + b;
			//return Quintic.easeOut(t,b,c,d)*0.5+Linear.easeOut(t,b,c,d)*0.5;
			//return Bounce.easeOut(t,b,c,d)*0.7+Sine.easeIn(t,b,c,d)*0.3;
			//return Back.easeInOut(t,b,c,d)*0.5+Back.easeIn(t,b,c,d)*0.5;
			//return Back.easeIn(t,b,c,d)*(t/d)+Back.easeOut(t,b,c,d)*(1-t/d);
			//return Math.sin(t/d*Math.PI/2)*(c-b)+b;
			return (t/d+Math.random()*(1-t/d))*(c-b)+b;
		}
		
		private function queue(f:Function,color:uint=0xFFFFFF):void {
			if (q == null) { q = []; }
			q.push({f:f,color:color});
		}
		
		private function runNext():void {
			if (q.length == 0) {
				canvas.removeChild(target); 
				return; 
			}
			var obj:Object = q.shift();
			run(obj.f,obj.color);
		}
		
		private function run(f:Function,color:uint=0xFFFFFF):void {
			tweenFunction = f;
			count = 0;
			maxCount = duration;
			addEventListener(Event.ENTER_FRAME,tick);
			this.color = color;
			prevPoint = new Point();
			prevDifPoint = new Point();
			if (canvas == null) {
				setup();
			}
		}
		
		private function tick(evt:Event):void {
			target.y = tweenFunction(count,0,distance,duration);
			
			if(count >0){
				var dif:Number = -1*Math.abs(prevPoint.y - target.y);
				canvas.graphics.lineStyle(1,color&0x555555,0.5);
				canvas.graphics.beginFill(color&0x555555,1);
				if(count >1){
					canvas.graphics.moveTo(prevDifPoint.x,prevDifPoint.y);
					canvas.graphics.lineTo(count*steps,distance+(dif*speedScaleFactor));
				}
				prevDifPoint.x = count*steps;
				prevDifPoint.y = distance+(dif*speedScaleFactor);
				canvas.graphics.drawCircle(prevDifPoint.x, prevDifPoint.y, 2);
			}
			
			canvas.graphics.moveTo(prevPoint.x,prevPoint.y);
			prevPoint.y = target.y;
			prevPoint.x = count*steps;
			canvas.graphics.lineStyle(1,color,0.5);
			canvas.graphics.lineTo(prevPoint.x,prevPoint.y);
			canvas.graphics.beginFill(color,1);
			canvas.graphics.drawCircle(count*steps, target.y , 1.5);
			
			count++;
			if (count > maxCount) {
				removeEventListener(Event.ENTER_FRAME,tick);
				runNext();
			}
			
			
			
		}
		
		private function setup():void {
			canvas = new Sprite();
			
			canvas.graphics.lineStyle(1, 0x444444);
			canvas.graphics.moveTo(0, -steps);
			canvas.graphics.lineTo(0, distance*2);
			canvas.graphics.moveTo(0, distance);
			canvas.graphics.lineTo(maxCount*steps+steps, distance);
			
			canvas.graphics.lineStyle(1, 0x111111);
			for (var i:int = 1; i< maxCount+1; i++){
				canvas.graphics.moveTo(i*steps, 0);
				canvas.graphics.lineTo(i*steps, distance);
			} 
			canvas.graphics.moveTo(0, 0);
			//canvas.graphics.lineTo(maxCount*steps, distance);
			
			addChild(canvas);
			canvas.x = 50;
			canvas.y = 10;
			
			target = new Sprite();
			canvas.addChild(target);
			target.graphics.beginFill(0xFFFF00,1);
			target.graphics.drawRect(-2,-20,4,15);
			target.graphics.drawRect(-2,maxCount*steps,4,15);
			target.graphics.beginFill(0xFFFFFF,0.2);
			target.graphics.drawRect(-1,-5,2,maxCount*steps+5);
			target.rotation = -90; 
		}

	}
}