package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Shape;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.geom.ColorTransform;
	import flash.geom.Matrix;
	import flash.geom.Rectangle;
	import flash.media.Microphone;
	import flash.media.Sound;
	import flash.media.SoundMixer;
	import flash.utils.ByteArray;
 
	[SWF( backgroundColor='0', frameRate='35', height='400', width='400')]
 
	public class Main extends Sprite
	{
 
		private var mic: Microphone;
		private var sound: Sound;
		private var bytes: ByteArray;
 
		private var output: BitmapData;
		private var peaks: BitmapData;
		private var displace: Matrix;
		private var rect: Rectangle;
		private var gradient: Array;
		private var darken: ColorTransform;
 
        [Embed(source="song.mp3")]
        public var soundClass:Class;
 
		public function Main()
		{
			sound = new soundClass as Sound;
			stage.addEventListener(MouseEvent.CLICK,onStageClicked);
 
			bytes = new ByteArray();
 
			output = new BitmapData( stage.stageWidth, stage.stageHeight, true, 0 );
			peaks = new BitmapData( stage.stageWidth, stage.stageHeight, true, 0 );
 
			displace = new Matrix();
			displace.tx = 2;
			displace.ty = -1;
 
			darken = new ColorTransform( 1, 1, 1, 1, -2, -2, -2, 0 );
 
			rect = new Rectangle( 0, 0, 1, 0 );
 
			addChild( new Bitmap( output ) );
			addChild( new Bitmap( peaks ) );
 
			stage.addEventListener( Event.ENTER_FRAME, onEnterFrame );
 
			graphics.beginFill( 0 );
			graphics.drawRect( 0, 0, stage.stageWidth, stage.stageHeight );
			graphics.endFill();
 
			gradient = createRainbowGradientArray();
		}
 
		private function onStageClicked( event:MouseEvent ): void
		{
			sound.play();
			stage.removeEventListener(MouseEvent.CLICK,onStageClicked);
		}
 
		private function onEnterFrame( event: Event ): void
		{
			peaks.fillRect( peaks.rect, 0 );
 
			SoundMixer.computeSpectrum( bytes, true, 0 );
 
			var value: Number;
			var height: Number;
 
			var smooth: Number;
 
			for( var i: int = 0 ; i < 256 ; i++ )
			{
				value = bytes.readFloat();
 
				if( i == 0 ) smooth = value;
				else smooth += ( value - smooth ) / 8;
 
				height = 2 + smooth * 0xf0;
 
				rect.x = 8 + i;
				rect.y = 320 + ( i >> 2 ) - height;
				rect.height = height;
 
				peaks.setPixel32( rect.x, rect.y, 0xffffffff );
 
				output.fillRect( rect, 0xff000000 | gradient[i] );
			}
 
			output.draw( output, displace, darken, null, null, true );
		}
 
		private function createRainbowGradientArray(): Array
		{
			var gradient: Array = new Array();
 
			var shape: Shape = new Shape();
			var bmp: BitmapData = new BitmapData( 256, 1, false, 0 );
 
			var colors: Array = [ 0, 0xff0000, 0xffff00, 0x00ff00, 0x00ffff ];
			var alphas: Array = [ 100, 100, 100, 100, 100 ];
			var ratios: Array = [ 0, 16, 128, 192, 255 ];
 
			var matrix: Matrix = new Matrix();
 
			matrix.createGradientBox( 256, 1, 0, 0, 0 );
 
			shape.graphics.beginGradientFill( 'linear', colors, alphas, ratios, matrix );
			shape.graphics.drawRect( 0, 0, 256, 1 );
			shape.graphics.endFill();
 
			bmp.draw( shape );
 
			for( var i: int = 0 ; i < 256 ; i++ )
			{
				gradient[i] = bmp.getPixel( i, 0 );
			}
 
			return gradient;
		}
	}
}

function setupGame():void {
	tbDoneText.text = "";
	addGameBoard();
	drawBoxes();
}
 
function newGame(evt:MouseEvent):void {
	removeGameBoard();
	setupGame();
}
 
// add a listener for the "New Game" button
btnNewGame.addEventListener(MouseEvent.CLICK,newGame);
 
var boxHeight:int = 40;
var boxWidth:int = 40;
var boxXSpace:int = 10;
var boxYSpace:int = 10;
 
function addGameBoard():void {
	// create a board to display all of the square buttons on
	var gb:Sprite = new Sprite();
	gb.graphics.beginFill(0xFFFFFF);
 
	// since the entire grid is at most 6x6, make enough room
	gb.graphics.drawRect(0,0,6*boxWidth+7*boxXSpace,6*boxHeight+7*boxYSpace);
	gb.graphics.endFill();
 
	gb.name = "gameBoard"
	gb.x = 20;
	gb.y = 20;
 
	this.addChild(gb);
}
 
function removeGameBoard():void {
 
	// remove the game board and all of the squares on it
	var gb:Sprite=Sprite(this.getChildByName("gameBoard"));
	var thisClip:Sprite;
 
	while(gb.numChildren>0){
		thisClip=Sprite(gb.getChildAt(0));
		thisClip.graphics.clear();
		gb.removeChild(thisClip);
	}
	gb.graphics.clear();
	this.removeChild(gb);
}
 
var onColor = 0xFF3333;
var offColor = 0x333333;
var numberOfRows:int;
var numberOfColumns:int;
var states:Array;
 
function drawBoxes():void {
	// create the squares on the game board
	var gb:Sprite = Sprite(this.getChildByName("gameBoard"));
	var square:Sprite;
 
	// create 3 to 6 rows and 3 to 6 columns
	numberOfRows = Math.floor(Math.random()*4+3);
	numberOfColumns = Math.floor(Math.random()*4+3);
 
	//create the states array, which has the same number of
	//"rows" and "columns" as our grid of squares
	states = new Array(numberOfRows);
 
	for (var i:int = 0; i < numberOfRows; i++) {
	// i = row number
 
		states[i] = new Array(numberOfColumns);
 
		for (var j:int = 0; j < numberOfColumns; j++) {
		// j = column number
 
			// create a square, which is by default 'off'
			square = new Sprite();
			square.graphics.lineStyle(2, 0x000000);
			square.graphics.beginFill(offColor);
			square.graphics.drawRect(0,0,boxWidth,boxHeight);
			square.graphics.endFill();
			states[i][j] = false;
			gb.addChild(square);
 
			// position the square in the correct location
			square.x = (j+1)*boxXSpace + j*boxWidth;
			square.y = (i+1)*boxYSpace + i*boxHeight;
			square.name = "square" + String(i) + String(j);
 
			// add a dynamically created listener for this square
			square.addEventListener(MouseEvent.CLICK,createListener(i,j));
		}
	}
	randomizeGameBoard();
}
 
function createListener(a:int, b:int):Function {
	// dynamically create a listener for the square in position (a,b)
	// that switches the box at (a,b) and the adjacent boxes, and
	// then checks to see if you are done
	var foo:Function = function (evt:MouseEvent):void {
		switchAt(a,b);
		if (checkDone()) {
			tbDoneText.text = "Good job!";
		}
	}
	return foo;
}
 
function invertState(row:int, col:int):void {
	// lookup the square located at (row, col)
	var gb:Sprite = Sprite(this.getChildByName("gameBoard"));
	var thisClip:Sprite = Sprite(gb.getChildByName(("square" + row) + col));
 
	// if the square is off, turn it on, and vice versa
 
	if (states[row][col]) {
		thisClip.graphics.beginFill(offColor);
		thisClip.graphics.drawRect(0,0,boxWidth,boxHeight);
		thisClip.graphics.endFill();
	}
	else {
		thisClip.graphics.beginFill(onColor);
		thisClip.graphics.drawRect(0,0,boxWidth,boxHeight);
		thisClip.graphics.endFill();
	}
	// reverse the state of the square
	states[row][col] = !states[row][col];
}
 
function switchAt(row:int, col:int):void {
	// switch the square that was clicked on
	invertState(row,col);
 
	// switch the squares adjacent to the clicked square
	if (row > 0) {
		invertState(row-1,col);
	}
	if (row < numberOfRows - 1) {
		invertState(row+1,col);
	}
	if (col > 0) {
		invertState(row,col-1);
	}
	if (col < numberOfColumns - 1) {
		invertState(row,col+1);
	}
}
 
function checkDone():Boolean {
	// check to see if all the lights are off
	var bool:Boolean = true;
	var i,j:int;
 
	for (i = 0; i < numberOfRows; i++) {
		for (j = 0; j < numberOfColumns; j++) {
			bool = bool && !states[i][j];
		}
	}
	return(bool);
}
 
function randomizeGameBoard():void {
	// randomly click the game board a random number of times
	// this ensures the game is solvable
	var r:int = Math.floor(Math.random()*5+5);
	var row:int, col:int, i:int;
 
	for (i = 0; i < r; i++) {
		row = Math.floor(Math.random() * numberOfRows);
		col = Math.floor(Math.random() * numberOfColumns);
		switchAt(row,col);
	}
}
 
setupGame();