/**
 * @author lamshell
 */

import flash.filters.*;
import flash.display.*;
import flash.geom.*;
import com.lamshell.Colorize;
import com.lamshell.KeyHandler;
import com.lamshell.IntervalManager;

class Main {

	public var sourceSignal : String = "video";

	public var active_cam : Camera;

	private var imageStr : String;
	
	public var textToLoad : String = "text.txt";

	public var videoImage : MovieClip;

	private var videoReflection : MovieClip;

	public  var rootRef : MovieClip;

	public  var baseRef : MovieClip;

	private var basePlane : MovieClip;

	public var textHolder : MovieClip;

	private var videoMap : BitmapData;

	private var w : Number;

	private var h : Number;

	private var left_x : Number;

	private var blur : Boolean;

	private var bf : BlurFilter;
	
	//-------------------------//

	private var cameraZ : Number;

	private var cameraX : Number;

	private var cameraY : Number;

	public var D : Number;

	private var offSet_z : Number;

	private var middle_x : Number;

	private var middle_y : Number;

	private var bmpPattern : BitmapData;

	private var tilingFactor : Number = 2;

	private var blockSize : Number = 10;

	private var tileSize : Number = 10;

	private var planeHeight : Number;

	private var horizontalBands : Number;

	private var baseWidth : Number;

	private var matrix : Matrix;
	
	//-------------------------//

	private var q : Number;

	private var qq : Number;

	private var done : Boolean = false;

	
//----------------------------------------------------------//

	public function Main(ref : MovieClip) {
		baseRef = ref;
		rootRef = ref;
		cleanUp();
		//----------------------------------------------------------//
		var k : KeyHandler = KeyHandler.getInstance(this);
		k.KeyCommands.push({KeyLetter:"`".charCodeAt(0), action:SourceSignal, classRef:this});
		var enter:EnterNewTextSource =  new EnterNewTextSource(this);
		//----------------------------------------------------------//
		cameraZ  = 100;
		cameraX  = 400;
		cameraY  = 2;
		D  = 900;
		offSet_z  = 300;
		middle_x  = 160;
		middle_y  = 100;
		//----------------------------------------------------------//
		initialize();
	}
	
	public function initialize() : Void {
		w = Stage.width;
		h = Stage.height/2;
		cleanUp();
		var im : IntervalManager = IntervalManager.getInstance();
		videoMap  = new BitmapData(w, h, true, 0);
		videoReflection  = rootRef.createEmptyMovieClip("vidreflection_mc", rootRef.getNextHighestDepth());
		//----------------------------------------------------------//
		if (sourceSignal == "video") {
			w = 480;
			videoImage = rootRef.attachMovie("vidHolder", "vid_mc", rootRef.getNextHighestDepth());
			// centering issues with flash video - offsetting the video
			// image by 60px in main movie then pulling back here ....
			left_x = Stage.width / 2 - w /2;
			rootRef._x = Stage.width / 2 - w /2 - left_x/2;
			active_cam  = Camera.get();
			videoImage.video.attachVideo(active_cam);
			blur  = true;
			videoMap  = new BitmapData(w, h, true, 0);
			
			} else {
		//----------------------------------------------------------//
			imageStr = "dots";
			//imageStr = "img";
			blur = false;
			rootRef.createEmptyMovieClip("vid_mc", rootRef.getNextHighestDepth());
			rootRef.vid_mc.createEmptyMovieClip("holder", 0);
		//----------------------------------------------------------//
			videoImage  = rootRef.vid_mc.holder.createEmptyMovieClip("img", 0);
			textHolder = videoImage.createEmptyMovieClip("textHolder", 200);
			getNewText();
			left_x = Stage.width / 2 - w / 2;
			rootRef._x = left_x;
			videoReflection._x = left_x;
		//----------------------------------------------------------//
		}
		var Mask : MovieClip = rootRef.attachMovie("mask","mask",rootRef.getNextHighestDepth());
		Mask._width = w;
		Mask._height = h;
		videoImage.setMask(Mask);
		//----------------------------------------------------------//
		videoReflection._y = h;
		videoReflection._alpha = 80;
		rootRef.vid_mc._visible = true;
		//----------------------------------------------------------//
		rootRef.attachMovie("grad", "grad", 800);
		bmpPattern  = new BitmapData(rootRef.grad._width, rootRef.grad._height);
		//bmpPattern = BitmapData.loadBitmap("dogBit2");
		bmpPattern.draw(rootRef.grad);
		rootRef.grad._visible = false;
		bmpPattern.perlinNoise(0, 12, 1, Math.random(), true, true, null, true, new Point(0, 2));
		//----------------------------------------------------------//
		planeHeight  = Stage.height / 2;
		horizontalBands  = planeHeight / blockSize;
		baseWidth  = Stage.width;
		matrix  = new Matrix();
		basePlane  = rootRef.createEmptyMovieClip("basePlain", rootRef.getNextHighestDepth());
		if (blur) {
			bf = new BlurFilter(3, 3, 3);
		} else {
			bf = new BlurFilter(1.2, 1.2, 1);			
		}
		//----------------------------------------------------------//
		if(sourceSignal == "video") {
			initializeReflection();
		}
	}
	
//----------------------------------------------------------//

	public function SourceSignal(arg : Object) : Void {
		sourceSignal = (sourceSignal == "image") ? "video" : "image";
		initialize();
}

//----------------------------------------------------------//

	public function cleanUp() : Void {
		var im : IntervalManager = IntervalManager.getInstance();
		baseRef["baseHolder"].removeMovieClip();
		rootRef = baseRef.createEmptyMovieClip("baseHolder", 0);
		videoImage.removeMovieClip();
		videoMap.dispose();
		bmpPattern.dispose();
		im.clearAllIntervals();	
	}
	
//----------------------------------------------------------//

	public function initializeReflection() : Void {
		var im : IntervalManager = IntervalManager.getInstance();
		im.clearIntervals("videoReflectionUpdate");
		drawSimpleReflection();
		q  = setInterval(this, "run", 31);
		im.RegisterInterval("videoReflectionUpdate",q);
	}


//----------------------------------------------------------//

	public function getNewText() : Void {
		trace("new code");
		clearInterval(qq);
		done = true;
		var TI : TextImport = new TextImport(this);
		TI.loadText(textToLoad,TextMaker);
		
	
	}
	
//----------------------------------------------------------//

	private function makeDots() : Void {
		// 141 = 49 + 49 + 33
		for (var i : Number = 0; i<108; i++) {
			var d : MovieClip = videoImage.attachMovie("dot","d"+i, i);
			var p : Object = PhiFunctions.PhiCalcl(i);
			var incr : Number = 26;
			d._x = p.point.x * incr + w/2;
			d._y = p.point.y * incr + h;
			var scalePoint : Number = 2 * 49 / p.diameter;
			d._xscale = d._yscale = 1200/scalePoint;
		}
	}
	
//----------------------------------------------------------//

	public function TextMaker(txt : String, ref : Object) : Void {
		var count : Number = 0;
		var textLayers : Number = 31;
		var textBlocks : Number = Math.ceil(txt.length/textLayers);
		var radiusIncrement : Number = 8;
		var pixelDimensionOfLetter : Number = 6;

		for (var i : Number = 2;i<textLayers;i++) {
			var temp : MovieClip = ref.textHolder.createEmptyMovieClip("n"+i,i);
			var PTI : PrepareTextImage = new PrepareTextImage();
			var circ : Number = Math.round(Math.PI * i *radiusIncrement / pixelDimensionOfLetter);
			PTI.displayText = txt.substr(count,circ);
			PTI.unitClipMarkHolder = temp;
			PTI.setText(i*radiusIncrement);
			temp._x = ref.w/2 -40;
			temp._y = ref.h;
			temp._xscale = 110;
			temp._yscale = 120;
			count +=circ;
		}
		if(!ref.done){
			//ref.qq  = setInterval(ref, "getNewText", 2000);
		}
		ref.makeDots();
		Colorize.ColorizeObjects (ref.textHolder);
		ref.initializeReflection();
	}
//----------------------------------------------------------//

	private function drawSimpleReflection() : Void {
		videoMap.dispose();
		videoMap  = new BitmapData(w, h, true, 0);
		var m : Matrix = new Matrix(1, 0, 0, 1, 0, 0);
		m.scale(1, -1);
		m.translate(0, h - 10);
		videoMap.draw(videoImage, m, new ColorTransform(), "normal", new Rectangle(0, 0, w, h));
		videoReflection.attachBitmap(videoMap, 1);
}
//----------------------------------------------------------//

	public function run() : Void {
		_root.debug_txt.text = cameraY;
		cameraZ -= 1;
		if (cameraZ < -500)
		cameraZ=0;
		doPattern();
}
//----------------------------------------------------------//

	public function returnPerspectiveRatio(D : Number, z : Number) : Number {
		var perspective_ratio : Number = z / (D + z);
		return perspective_ratio;
}
//----------------------------------------------------------//

	function doPattern() : Void {
		if(sourceSignal == "video"){
			drawSimpleReflection();
		}
		videoReflection.filters = null;
		var fA : Array = new Array(videoReflection.filters);
		var bmpTemp : BitmapData = new BitmapData(w, h);
		var yStart : Number = 0;

		for (var i : Number = 0; i < horizontalBands; i++) {
			var mult : Number = i - .5;
			var bHeight : Number = (mult * mult) * blockSize / 5;
			var band : MovieClip = basePlane.createEmptyMovieClip("b" + i, i);
			band._y = yStart;
			yStart += bHeight;
			band._visible = false;
			// add - cameraY  to move horizon, otherwise fixed horizon;
			var pr : Number = returnPerspectiveRatio(D, i);
			var matrix : Matrix = new Matrix();
			//matrix.rotate(Math.PI/2);
			var tilingScale : Number = pr * tilingFactor * (middle_y - cameraY);
			matrix.translate(middle_x - cameraX, -cameraZ);
			matrix.scale(tilingScale, tilingScale);
			matrix.translate(middle_x, blockSize * i / pr);
			var repeat : Boolean = true;
			var smoothing : Boolean = true;
			if (pr > .001) {
				band.beginBitmapFill(bmpPattern, matrix, repeat, smoothing);
			}
			band.moveTo(0, 0);
			band.lineTo(0, bHeight);
			band.lineTo(baseWidth, bHeight);
			band.lineTo(baseWidth, 0);
			band.lineTo(0, 0);
			band.endFill();

			var tm : Matrix = new Matrix();
			tm.translate(0, yStart / 2);
			bmpTemp.draw(band, tm);
	}
		//bmpTemp.merge(videoMap, new Rectangle(), pt2, 127, 127, 127);
		var dMap : DisplacementMapFilter = new DisplacementMapFilter(bmpTemp, new Point(0, 0), null, 1, 100, 100, "color", 10);
		fA.push(dMap);
		fA.push(bf);
		if (blur) {
		
		}
		videoReflection.filters = fA;
}
	
}