package  
{
	/**
	 *	Demo for Belousov-Zhabotinsky- cellular automata
	 * Petri Leskinen, 1st July 2009
	 *	in Espoo, Finland
	 */
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.filters.ColorMatrixFilter;
	
	import flash.geom.Matrix;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	import flash.net.FileReference;
	import flash.errors.IOError;
	
	import flash.utils.ByteArray;
	import flash.text.TextField;
	
	import fl.controls.Button;
	import fl.controls.ColorPicker;
	import fl.controls.Slider;

	import org.gif.encoder.GIFEncoder;
	
	import  BelousovZhabotinskyCA;
	
	
	
	public class BelousovZhabotinskyDemo extends Sprite
	{
		protected var 
			w:int = 128,
			h:int = 128,
			automaton:BelousovZhabotinskyCA,
			
			color0:uint = 0x990000,
			color1:uint = 0xFFFFCC,
			leftMargin:int = 120,
			canvas:Sprite,
			canvasWidth:int,
			canvasHeight:int,
			zoom:Number = 1.0,
			paused:Boolean = false;
		
		
		
		public function BelousovZhabotinskyDemo()
		{
			 
			//	init cellular automaton, and do 100 loops
			automaton = new BelousovZhabotinskyCA(w, h);
			automaton.grow(100);
			
			//	canvas on the stage
			canvas= new Sprite();
			addChild(canvas);
			canvas.x = leftMargin;
			canvasWidth = stage.stageWidth-leftMargin;
			canvasHeight = stage.stageHeight;
			
			//	activate the controls
			automaton.color0 = colorPicker0.selectedColor= color0;
			colorPicker0.addEventListener(Event.CHANGE, changed);
			
			automaton.color1 = colorPicker1.selectedColor= color1;
			colorPicker1.addEventListener(Event.CHANGE, changed1);
			
			sliderK1.addEventListener(Event.CHANGE, changedK1);
			sliderK2.addEventListener(Event.CHANGE, changedK2);
			sliderG.addEventListener(Event.CHANGE, changedG);
			
			sliderK1.value = automaton.k1;
			sliderK2.value = automaton.k2;
			sliderG.value = automaton.g;
			
			sliderZoom.addEventListener(Event.CHANGE, changedZoom);
			sliderZoom.value = zoom;
			
			checkPaused.addEventListener(Event.CHANGE, changePause);
			restartButton.addEventListener(MouseEvent.CLICK, restart);
			saveButton.addEventListener(MouseEvent.CLICK, buttonSave);
			
			changeSizeButton.addEventListener(MouseEvent.CLICK, sizeChanged);
			
			canvas.addEventListener(MouseEvent.CLICK, mouseClick);
			
			pixeleroLink.htmlText="<a target=\"pixelero\" alt=\"blog\" href=\"http://pixelero.wordpress.com\">Pixelero</a>";
			
			startAnimation();
			
		}
		
		private function enterFrame(e:Event = null):void {
			
			automaton.grow();
			
			canvas.graphics.clear();
			//	for the tiling automaton is drawn on the canvas as a bitmapfill
			canvas.graphics.beginBitmapFill(automaton, new Matrix(zoom,0,0,zoom));
			
			canvasWidth = stage.stageWidth-leftMargin;
			canvasHeight = stage.stageHeight;
			
			
			if (checkTiled.selected) {
				canvas.graphics.drawRect(0,0,canvasWidth,canvasHeight);
			} else {
				var xp:int =(canvasWidth - automaton.width)>>1,
				yp:int =(canvasHeight - automaton.height)>>1;
				canvas.graphics.drawRect(xp,yp,
								automaton.width,
								automaton.height);
			}
			
			
		}
		
		//	replace old automaton by a new one with same parameters
		private function sizeChanged(event:MouseEvent=null):void {
			var newautomaton:BelousovZhabotinskyCA = 
				new BelousovZhabotinskyCA(
							int(stepperX.value), 
							int(stepperY.value),
							automaton.k1,
							automaton.k2,
							automaton.g );
			
			for (var mtrx:Matrix= new Matrix();mtrx.ty<newautomaton.height;mtrx.ty+=automaton.height) {
				for (mtrx.tx=0;mtrx.tx<newautomaton.width;mtrx.tx+=automaton.width) {
					newautomaton.draw(automaton, mtrx);
				}
			}
			newautomaton.updateCells();
			
			newautomaton.color0 = automaton.color0;
			newautomaton.color1 = automaton.color1;
			
			automaton = newautomaton;
			changedautomaton();
			
		}
		
		
		//	ready to save as a gif
		private function buttonSave(event:MouseEvent):void {
			stopAnimation();
			saveGif();
		}
		
		
		private function saveGif():void {
			
			/*	GIFEncoder, 
			* refer to http://code.google.com/p/as3gif/wiki/How_to_use
			*/
			var encoder:GIFEncoder = new GIFEncoder();
                        
			encoder.setRepeat(0);                   
			encoder.setDelay(200);
			
			encoder.start();                      
			
			//	by the values automaton.k1, k2 and g
			//	it is hard to define the lenght of one apparent cycle,
			//	so we'll sample one non-zero pixel ...
			var px:int=automaton.width>>1, 
				py:int=automaton.height>>1,
				pxl:uint = automaton.getCellAt(px,py),
				pxl2:uint;
			while (pxl==0) {
				px=automaton.width*Math.random(); 
				py=automaton.height*Math.random();
				pxl = automaton.getCellAt(px,py);
			}
			
			//	... and compare the new values 
			//	- first increasing, back to zero, then increasing again - to sample
		   	
			do {
		  		automaton.grow(); 
				encoder.addFrame(automaton);
			} while ((pxl2= automaton.getCellAt(px,py))>pxl)
			
			while ((pxl2= automaton.getCellAt(px,py))<pxl)  {
		  		automaton.grow();
		   		encoder.addFrame(automaton);
		   	}  
			
            encoder.finish(); 
			
			//	write the gif to a file
			var bytes:ByteArray = encoder.stream; 
			
			try {
				var fileSave:FileReference = new FileReference();
				fileSave.addEventListener(Event.COMPLETE, startAnimation);
				fileSave.addEventListener(Event.CANCEL, startAnimation);
				fileSave.save(bytes, "BelousovZhabotinskySample.gif");
			}
			catch (error:IOError)
			{
				trace(error+","+error.message);
				fileSave.removeEventListener(Event.COMPLETE, startAnimation);
				startAnimation();
			}
			
		}
		
		private function stopAnimation(e:Event=null):void {
			removeEventListener(Event.ENTER_FRAME, enterFrame);
			waitText.x = leftMargin + 0.5*(stage.stageWidth - waitText.width);
			waitText.y = 0.5*(stage.stageHeight - waitText.height);
			waitText.visible= true;
		}
		
		private function startAnimation(e:Event=null):void {
			addEventListener(Event.ENTER_FRAME, enterFrame);
			waitText.visible= false;
		}
		
		//	changing color0
		private function changed(e:Event):void {
			automaton.color0 = 
			color0 =e.currentTarget.selectedColor;
			//	setFilter();
		}
		
		//	changing color1
		private function changed1(e:Event):void {
			automaton.color1 = 
			color1 =e.currentTarget.selectedColor;
			// setFilter();
		}
		
		//	change parameters
		private function changedautomaton(e:Event=null):void {
			automaton.k1 =int(sliderK1.value);
			automaton.k2 =int(sliderK2.value);
			automaton.g =int(sliderG.value);
		}
		
		//	change automaton.k1
		private function changedK1(e:Event):void {
			automaton.k1 =e.currentTarget.value;
			parametersText.text ="K1 = "+automaton.k1;
		}
		
		//	change automaton.k2
		private function changedK2(e:Event):void {
			automaton.k2 =e.currentTarget.value;
			parametersText.text ="K2 = "+automaton.k2;
		}
		
		//	change automaton.g
		private function changedG(e:Event):void {
			automaton.g =e.currentTarget.value;
			parametersText.text ="G = "+automaton.g;
		}
		
		private function changePause(e:Event):void {
			if (paused = !paused) {
				removeEventListener(Event.ENTER_FRAME, enterFrame);
			} else {
				addEventListener(Event.ENTER_FRAME, enterFrame);
			}
		}
		
		private function changedZoom(e:Event):void {
			zoom=e.currentTarget.value;
		}
		
		//	new start: fills the cells with noise
		private function restart(e:MouseEvent):void {
			automaton.init();
		}
		
		
		private function mouseClick(e:MouseEvent):void {
			sliderK2.value= automaton.k2 = 2 + int(10 * e.target.mouseX / automaton.width );
			sliderG.value= automaton.g = int(automaton.q / automaton.k2) +30 * (e.target.mouseY / automaton.height - 0.5);
		}
		
		
	}
	
}