extern "C"
{
#include <os.h>
#include <nGEO.h>
#include <nGUI.h>

#include <nRGBlib.h>
}
#include "Drawing.h"
#include "Simon.h"

#define SIN45				0.707107
#define TIME_OUT			1000
#define WAIT_TIME			2000
#define DISPLAY_FLASH_TIME	300

void DrawBoard(ScreenBuffer screen);
void DrawWedge(SimonColor eColor, ScreenBuffer buffer, bool bON = true);
bool StartKeyPressed();
bool QuitKeyPressed();
bool SimonKeyPressed(SimonColor& eColor);
bool DoSlightDelay(int nMS);
void itoa(int n, char buffer[3]);

int main()
{
	bool play = true;
	ScreenBuffer screen = GetNewScreenBuffer();
	
	while(play == true)
	{
		// Draw a wellcoming message
		clearScreen(BLACK, screen);
		drawStr(0, 0  * CHAR_HEIGHT,    "             +----------+\n"
										"             |  nSimon  |\n"
										"             +----------+\n"
										"\n"
										"---------------------------------------\n"
										"Controls:\n"
										"   - Green    : Up & 8\n"
										"   - Blue     : Down & 2\n"
										"   - Red      : Right & 6\n"
										"   - Yellow   : Left & 4\n\n\n"
										"Game play: Simply match the pattern!\n\n"
										"Ctrl/Enter to Start !\n"
										"                      Or Esc to quit...\n", 1, 1, CYAN, screen);
		display(screen);

		// Wait and init rand
		while (!StartKeyPressed() && !QuitKeyPressed())
			rand();
		
		Simon simon;
		simon.Initialize();
		
		//Game loop
		while(play == true)
		{
			if( QuitKeyPressed() )
			{
				play = false;
				break;
			}
			
			DrawBoard(screen);
			display(screen);
			
			//Watch carefully
			drawStr(SCREEN_WIDTH/2 - 115/*Just looked right*/, SCREEN_HEIGHT/2-CHAR_HEIGHT/2, "Watch carefully", 2, false, RED, screen);
			display(screen);
			
			if( !DoSlightDelay(WAIT_TIME) )
			{
				play = false;
				break;
			}
			
			//Draw current sequence
			DrawBoard(screen);
			
			for(int i=0; i<simon.GetSequenceLength(); i++)
			{
				SimonColor c = simon.GetIndexColor(i);
				DrawWedge(c, screen);
				display(screen);
				sleep(DISPLAY_FLASH_TIME);
				
				if( QuitKeyPressed() )
					break;
				
				DrawWedge(c, screen, false);
				display(screen);
				sleep(DISPLAY_FLASH_TIME);
			}
			
			if( QuitKeyPressed() )
			{
				while(any_key_pressed())
					sleep(100);
				play = false;
				break;
			}
			
			//Get ready
			simon.StartSequence();
			drawStr(SCREEN_WIDTH/2 - 12*9, SCREEN_HEIGHT/2-CHAR_HEIGHT/2, "Get Ready", 3, false, RED, screen);
			display(screen);
			
			if( !DoSlightDelay(WAIT_TIME) )
			{
				play = false;
				break;
			}
			
			DrawBoard(screen);
			display(screen);

			//Go
			volatile int nTimeRemaining = TIME_OUT;
			while(true)
			{
				if( QuitKeyPressed() )
				{
					while(any_key_pressed())
						sleep(100);
					play = false;
					break;
				}
				
				SimonColor c;
				if( SimonKeyPressed(c) )
				{
					nTimeRemaining = TIME_OUT;
					DrawWedge(c, screen);
					char buf[3];
					itoa(simon.GetCurrentLocation()+1, buf);
					drawBox_(0, SCREEN_HEIGHT-CHAR_HEIGHT, 2*CHAR_WIDTH, CHAR_HEIGHT, WHITE, screen);
					drawStr(0, SCREEN_HEIGHT-CHAR_HEIGHT, (char*)&buf, 1, 1, RED, screen);
					display(screen);
					while(any_key_pressed())
						sleep(100);
					sleep(100);
					DrawWedge(c, screen, false);
					display(screen);
					
					if( !simon.Touched(c) )//Wrong press or lost or won
					{
						break;
					}
				}
				else//Didn't press anything yet
				{
					nTimeRemaining--;//Uh I really should use the clock! TODO!!
					if( nTimeRemaining <= 0 )
					{
						simon.TookTooLong();
						break;
					}
				}
			}
			
			if( simon.IsGameOver() )
			{
				if( simon.DidWin() )
				{
					clearScreen(BLACK, screen);
					drawStr(0, 0  * CHAR_HEIGHT,    "You won!!  Way to go!!\n"
													"Press Esc to quit or Ctrl/Enter\n"
													"to go back to menu\n", 1, 1, CYAN, screen);
					display(screen);
					
					while (!StartKeyPressed() && !QuitKeyPressed())
						rand();
					
					if( QuitKeyPressed() )
					{
						play = false;
					}
					while(any_key_pressed())
						sleep(100);
					simon.Initialize();
					break;
				}
				else
				{
					clearScreen(BLACK, screen);
					if( simon.DidTakeTooLong() )
					{
						drawStr(0, 0  * CHAR_HEIGHT,    "You lost! :(\n"
														"You took too long\n"
														"to press the correct button\n"
														"\n"
														"Press Ctrl/Enter to goto menu\n"
														"Press Esc to exit", 1, 1, CYAN, screen);
					}
					else
					{
						drawStr(0, 0  * CHAR_HEIGHT,    "You lost! :(\n"
														"You pressed the wrong button\n"
														"\n"
														"Press Ctrl/Enter to goto menu\n"
														"Press Esc to exit", 1, 1, CYAN, screen);
					}
					display(screen);
					
					while (!StartKeyPressed() && !QuitKeyPressed())
						rand();
					
					if( QuitKeyPressed() )
					{
						play = false;
					}
					while(any_key_pressed())
						sleep(100);
					simon.Initialize();
					break;
				}
			}
		}
	}

	free(screen);
	
	// And quit
	return 0;
}

void DrawBoard(ScreenBuffer screen)
{
	clearScreen(WHITE, screen);
	drawCircle_(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, SCREEN_HEIGHT/2/*Radius*/, BLACK, screen);
	/*DrawWedge(Green, screen, false);
	DrawWedge(Red, screen, false);
	DrawWedge(Blue, screen, false);
	DrawWedge(Yellow, screen, false);*/
}

void DrawWedge(SimonColor eColor, ScreenBuffer buffer, bool bON /*= true*/)
{
	int nCenterX = SCREEN_WIDTH/2, nCenterY = SCREEN_HEIGHT/2;
	int nSmallAmountFromCenter = 3, nSmallAmountFromCircle = 2;
	int nSideDistances = SCREEN_HEIGHT/2 - nSmallAmountFromCenter - nSmallAmountFromCircle;
	
	switch(eColor)
	{
		default:
			//assert(false);
		case Green:
	//Top
	DrawFilledTriangle(nCenterX, nCenterY-nSmallAmountFromCenter, //Close to center
					nCenterX-nSideDistances*SIN45, nCenterY-nSmallAmountFromCenter-nSideDistances*SIN45, //Left
					nCenterX+nSideDistances*SIN45, nCenterY-nSmallAmountFromCenter-nSideDistances*SIN45, //Right
					bON ? GREEN : WHITE, buffer);
	/*if( !bON )
		drawTriangle_(nCenterX, nCenterY-nSmallAmountFromCenter, //Close to center
					nCenterX-nSideDistances*SIN45, nCenterY-nSmallAmountFromCenter-nSideDistances*SIN45, //Left
					nCenterX+nSideDistances*SIN45, nCenterY-nSmallAmountFromCenter-nSideDistances*SIN45, //Right
					GREEN, buffer);*/
		break;
	
		case Red:
	//Right
	DrawFilledTriangle(nCenterX+nSmallAmountFromCenter, nCenterY, //Close to center
					nCenterX+nSmallAmountFromCenter+nSideDistances*SIN45, nCenterY-nSideDistances*SIN45, //Top
					nCenterX+nSmallAmountFromCenter+nSideDistances*SIN45, nCenterY+nSideDistances*SIN45, //Bottom
					bON ? RED : WHITE, buffer);
	
	/*if( !bON )
		drawTriangle_(nCenterX+nSmallAmountFromCenter, nCenterY, //Close to center
					nCenterX+nSmallAmountFromCenter+nSideDistances*SIN45, nCenterY-nSideDistances*SIN45, //Top
					nCenterX+nSmallAmountFromCenter+nSideDistances*SIN45, nCenterY+nSideDistances*SIN45, //Bottom
					RED, buffer);*/
		break;
	
		case Yellow:
	//Bottom
	DrawFilledTriangle(nCenterX, nCenterY+nSmallAmountFromCenter, //Close to center
					nCenterX-nSideDistances*SIN45, nCenterY+nSmallAmountFromCenter+nSideDistances*SIN45, //Left
					nCenterX+nSideDistances*SIN45, nCenterY+nSmallAmountFromCenter+nSideDistances*SIN45, //Right
					bON ? YELLOW : WHITE, buffer);
		
	/*if( !bON )
		drawTriangle_(nCenterX, nCenterY+nSmallAmountFromCenter, //Close to center
					nCenterX-nSideDistances*SIN45, nCenterY+nSmallAmountFromCenter+nSideDistances*SIN45, //Left
					nCenterX+nSideDistances*SIN45, nCenterY+nSmallAmountFromCenter+nSideDistances*SIN45, //Right
					YELLOW, buffer);*/
		break;
	
		case Blue:
	//Left
	DrawFilledTriangle(nCenterX-nSmallAmountFromCenter, nCenterY, //Close to center
					nCenterX-nSmallAmountFromCenter-nSideDistances*SIN45, nCenterY-nSideDistances*SIN45, //Top
					nCenterX-nSmallAmountFromCenter-nSideDistances*SIN45, nCenterY+nSideDistances*SIN45, //Bottom,
					bON ? BLUE : WHITE, buffer);
		
	/*if( !bON )
		drawTriangle_(nCenterX-nSmallAmountFromCenter, nCenterY, //Close to center
					nCenterX-nSmallAmountFromCenter-nSideDistances*SIN45, nCenterY-nSideDistances*SIN45, //Top
					nCenterX-nSmallAmountFromCenter-nSideDistances*SIN45, nCenterY+nSideDistances*SIN45, //Bottom,
					BLUE, buffer);*/
		break;
	}
}

bool StartKeyPressed()
{
   return isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_ENTER);
}

bool QuitKeyPressed()
{
   return isKeyPressed(KEY_NSPIRE_ESC) || isKeyPressed(KEY_NSPIRE_Q) || isKeyPressed(KEY_NSPIRE_HOME);
}

bool SimonKeyPressed(SimonColor& eColor)
{
	if( isKeyPressed(KEY_NSPIRE_8) || isKeyPressed(KEY_NSPIRE_UP) )
	{
		eColor = Green;
		return true;
	}
	else if( isKeyPressed(KEY_NSPIRE_6) || isKeyPressed(KEY_NSPIRE_RIGHT) )
	{
		eColor = Red;
		return true;
	}
	else if( isKeyPressed(KEY_NSPIRE_2) || isKeyPressed(KEY_NSPIRE_DOWN) )
	{
		eColor = Yellow;
		return true;
	}
	else if( isKeyPressed(KEY_NSPIRE_4) || isKeyPressed(KEY_NSPIRE_LEFT) )
	{
		eColor = Blue;
		return true;
	}
	
	return false;
}

bool DoSlightDelay(int nMS)
{
	for(int i=0; i<nMS; i+=300)
	{
		sleep(300);
		if( QuitKeyPressed() )
		{
			while(any_key_pressed())
				sleep(100);
			return false;
		}
	}
	return true;
}

void itoa(int n, char buffer[3])
{
	int nTens = n/10;
	int nRemainder = n%10;
	if( nTens > 0 )
	{
		buffer[0] = '0' + nTens;
		buffer[1] = '0' + nRemainder;
		buffer[2] = '\0';
	}
	else
	{
		buffer[0] = '0' + nRemainder;
		buffer[1] = '\0';
	}
}