#include <stdio.h>
#include <stdlib.h>

#include <time.h>
#include <sys/timeb.h>

#include <SDL/SDL.h>
#include <SDL/SDL_gfxPrimitives.h>

#include "constants.h"

#include "sound.h"
#include "menu.h"
#include "help.h"
#include "game.h"
#include "terrain.h"
#include "random.h"
#include "sfcave.h"
#include "font.h"
#include "settings.h"
#include "util.h"

#include "sfcave_game.h"
#include "gates_game.h"
#include "fly_game.h"

void start( int argc, char *argv[] )
{
	SFCave *app = new SFCave( argc, argv );
	app->mainEventLoop();
	delete app;
}

#ifdef __cplusplus
extern "C"
#endif
int main(int argc, char *argv[])
{
	start( argc, argv );
	return 0;
}


SFCave :: SFCave( int argc, char *argv[] )
{
    setupOK = false;

	// Load settings
	string diff = loadSetting( "GameDifficulty", "Easy" );
	string game = loadSetting( "GameType", "SFCave" );
	musicPath = loadSetting( "MusicPath", SOUND_PATH );
	musicType = loadSetting( "MusicType", "mod,ogg" );
	bool soundOn = loadBoolSetting( "SoundOn", true );
	bool musicOn = loadBoolSetting( "MusicOn", true );
	if ( musicPath[musicPath.size()-1] != '/' )
	   musicPath += "/";
	printf( "musicPath %s\n", musicPath.c_str() );

    // Init main SDL Library
	initSDL( argc, argv );

	// Init font handler
	if ( !FontHandler::init() )
	{
	   printf( "Unable to initialise fonts!\n" );
	   return;
	}

	// Init SoundHandler
	if ( !SoundHandler :: init() )
		printf("Unable to open audio!\n");

	SoundHandler :: setSoundsOn( soundOn );
	SoundHandler :: setMusicOn( musicOn );

	currentGame = Game::createGame( this, WIDTH, HEIGHT, game, diff );
	if ( !currentGame )
		currentGame = new SFCaveGame( this, WIDTH, HEIGHT, 0 );
	currentGame->setSeed(-1);

	// Create menu
	menu = new Menu( this );

	// Create help screen
	help = new Help( this );

	maxFPS = 50;
	showFps = false;
	
	setupOK = true;
}

SFCave :: ~SFCave()
{
	if ( currentGame )
		delete currentGame;

	if ( menu )
		delete menu;

	if ( help )
		delete help;

	SDL_FreeSurface( screen );
	FontHandler::cleanUp();
	SoundHandler :: cleanUp();

	SDL_Quit();
}


void SFCave :: initSDL( int argc, char *argv[] )
{
	const SDL_VideoInfo *info;
	Uint8  video_bpp;
	Uint32 videoflags;

	// Initialize SDL
	if ( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0 ) {
		fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
		exit(1);
	}

	video_bpp = 16;

	if ( !SDL_VideoModeOK(WIDTH, HEIGHT, video_bpp, SDL_DOUBLEBUF) )
		printf( "No double buffering\n" );

	videoflags = SDL_HWSURFACE | SDL_SRCALPHA;
	while ( argc > 1 )
	{
		--argc;
		if ( strcmp(argv[argc-1], "-bpp") == 0 )
		{
			video_bpp = atoi(argv[argc]);
			--argc;
		}
		else if ( strcmp(argv[argc], "-hw") == 0 )
		{
			videoflags |= SDL_HWSURFACE;
		}
		else if ( strcmp(argv[argc], "-warp") == 0 )
		{
			videoflags |= SDL_HWPALETTE;
		}
		else if ( strcmp(argv[argc], "-fullscreen") == 0 )
		{
			videoflags |= SDL_FULLSCREEN;
		}
		else if ( strcmp(argv[argc], "-h") == 0 )
		{
			fprintf(stderr,
			"Usage: %s [-bpp N] [-warp] [-hw] [-fullscreen]\n",
								argv[0]);
			exit(1);
		}
	}

	// Set 240x320 video mode
	if ( (screen = SDL_SetVideoMode( WIDTH,HEIGHT,video_bpp,videoflags )) == NULL )
	{
		printf( "Couldn't set %ix%i video mode: %s\n",WIDTH,HEIGHT,SDL_GetError() );
		exit(2);
	}

	// Use alpha blending
	//SDL_SetAlpha(screen, SDL_RLEACCEL, 0);

	// Set title for window
	SDL_WM_SetCaption("SFCave","SFCave");
}

void SFCave :: mainEventLoop()
{
    if ( !setupOK )
        return;
        
	// Wait for a keystroke
	finish = false;
	state = 0;
	state = STATE_CRASHED;
	changeState( STATE_MENU );

	FPS = 0;
	actualFPS = 0;
	time1 = 0;

	limitFPS = true;
	while ( !finish )
	{
		// calc FPS
		calcFPS();

    	SDL_FillRect( screen, 0, 0 );

		handleGameState( );

   		SDL_Flip( screen );

		if ( limitFPS )
			FPSDelay();
		else
			SDL_Delay( 5 );

		handleEvents();
	}
}


void SFCave :: handleGameState()
{
	switch( state )
	{
		case STATE_MENU:
			SDL_FillRect( screen, 0, 0 );
			menu->draw( screen );
			break;
		case STATE_HELP:
			SDL_FillRect( screen, 0, 0 );
			help->update();
			help->draw( screen );
			break;
		case STATE_NEWGAME:
			currentGame->setReplay( false );
			currentGame->init();
			changeState( STATE_PLAYING );
			break;

		case STATE_REPLAY:
			currentGame->setReplay( true );
			currentGame->init();
			changeState( STATE_PLAYING );
			break;

		case STATE_PLAYING:
		case STATE_CRASHING:
		case STATE_CRASHED:
			currentGame->update( state );
			currentGame->draw( screen );
			break;

		case STATE_QUIT:
			finish = true;
			break;
	}
}

void SFCave :: handleEvents()
{
	SDL_Event event;

	// Check for events
	while ( SDL_PollEvent(&event) )
	{
		switch (event.type)
		{
			case SDL_KEYDOWN:
			case SDL_KEYUP:
			{
				// Escape keypress quits the app
				if ( event.key.keysym.sym == SDLK_ESCAPE )
				{
					finish = true;
					break;
				}

				if ( state == STATE_MENU )
				{
					int rc = menu->handleKeys( event.key );
					if ( rc != -1 )
						handleMenuSelect( rc );
				}
				else if ( state == STATE_HELP )
				{
					help->handleKeys( event.key );
				}
				else if ( state == STATE_CRASHED )
				{
					if ( event.type == SDL_KEYDOWN )
					{
						if ( event.key.keysym.sym == SDLK_UP ||
							event.key.keysym.sym == SDLK_DOWN ||
							event.key.keysym.sym == SDLK_SPACE )
							changeState( STATE_NEWGAME );
						else if ( event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == 0 )
						{
							changeState( STATE_MENU );
							menu->resetToTopMenu();
						}
						else if ( event.key.keysym.sym == SDLK_r )
						{
							changeState( STATE_REPLAY );
						}
						else if ( event.key.keysym.sym == SDLK_s )
						{
							SoundHandler :: playSound( SND_EXPLOSION );
						}
					}
				}
				else
				{
					switch ( event.key.keysym.sym )
					{
						case SDLK_f:
							if ( event.type == SDL_KEYDOWN )
								showFps = !showFps;
							break;
						case SDLK_l:
							if ( event.type == SDL_KEYDOWN )
								limitFPS = !limitFPS;
							break;

						default:
							currentGame->handleKeys( event.key );
							break;
					}
				}

				break;
			}

			case SDL_QUIT:
				finish = true;
				break;
			default:
				break;
		}
	}
}

void SFCave :: changeState( int s )
{
	if ( state != s )
		currentGame->stateChanged( state, s );

    if ( state == STATE_MENU && s == STATE_HELP )
        help->init();
    if ( state == STATE_CRASHED && s == STATE_MENU )
	{
		SoundHandler :: stopMusic( true );

		string musicFile = chooseRandomFile( musicPath, musicType );
    	SoundHandler :: setMusicVolume( 128 );
		SoundHandler :: playMusic( musicFile );
	}
    else if ( state == STATE_MENU && (s == STATE_NEWGAME || s == STATE_REPLAY) )
    {
		SoundHandler :: stopMusic( );

        // Start the in game music
        string musicFile = INGAME_MUSIC;
    	SoundHandler :: playMusic( musicFile );
    	SoundHandler :: setMusicVolume( 25 );
    }

	state = s;
}


void SFCave :: handleMenuSelect( int menuId )
{
	switch( menuId )
	{
		case MENU_STARTGAME:
			changeState( STATE_NEWGAME );
			break;

		case MENU_HELP:
            changeState( STATE_HELP );
			break;

		case MENU_QUIT:
			changeState( STATE_QUIT );
			break;

		case MENU_PLAY_REPLAY:
			if ( currentGame->isReplayAvailable() )
				changeState( STATE_REPLAY );
			else
				setMenuStatusText( "No replay available yet" );
			break;

		case MENU_LOAD_REPLAY:
		{
    		string replayFile = getHomeDir() + "/" + currentGame->getGameName() + ".replay";

			currentGame->loadReplay( replayFile );

			break;
		}

		case MENU_SAVE_REPLAY:
		{

			if ( currentGame->isReplayAvailable() )
			{
				string replayFile = getHomeDir() + "/" + currentGame->getGameName() + ".replay";

				currentGame->saveReplay( replayFile );
			}
			else
				setMenuStatusText( "No replay available yet" );

			break;
		}
		case MENU_CLEAR_SCORES:
			break;

		case MENU_GAME_SFCAVE:
			if ( currentGame->getGameName() != "SFCave" )
			{
				int diff = currentGame->getDifficulty();
				delete currentGame;
				currentGame = new SFCaveGame( this, WIDTH, HEIGHT, 0 );
				currentGame->setDifficulty( diff );

				saveSetting( "GameType", "SFCave" );
			}
			break;

		case MENU_GAME_GATES:
			if ( currentGame->getGameName() != "Gates" )
			{
				int diff = currentGame->getDifficulty();
				delete currentGame;
				currentGame = new GatesGame( this, WIDTH, HEIGHT, 0 );
				currentGame->setDifficulty( diff );

				saveSetting( "GameType", "Gates" );
			}
			break;
			break;

		case MENU_GAME_FLY:
			if ( currentGame->getGameName() != "Fly" )
			{
				int diff = currentGame->getDifficulty();
				delete currentGame;
				currentGame = new FlyGame( this, WIDTH, HEIGHT, 0 );
				currentGame->setDifficulty( diff );

				saveSetting( "GameType", "Fly" );
			}
			break;

		case MENU_DIFFICULTY_EASY:
			currentGame->setDifficulty( MENU_DIFFICULTY_EASY );
			saveSetting( "GameDifficulty", "Easy" );
			break;

		case MENU_DIFFICULTY_NORMAL:
			currentGame->setDifficulty( MENU_DIFFICULTY_NORMAL );
			saveSetting( "GameDifficulty", "Medium" );
			break;

		case MENU_DIFFICULTY_HARD:
			currentGame->setDifficulty( MENU_DIFFICULTY_HARD );
			saveSetting( "GameDifficulty", "Hard" );
			break;

		case MENU_DIFFICULTY_CUSTOM:
			currentGame->setDifficulty( MENU_DIFFICULTY_CUSTOM );
			saveSetting( "GameDifficulty", "Custom" );
			break;

		case MENU_SOUND_ON:
			SoundHandler :: setSoundsOn( true );
			saveSetting( "SoundOn", "true" );
			break;

		case MENU_SOUND_OFF:
			SoundHandler :: setSoundsOn( false );
			saveSetting( "SoundOn", "false" );
			break;

		case MENU_MUSIC_ON:
			SoundHandler :: setMusicOn( true );
			saveSetting( "MusicOn", "true" );
			break;

		case MENU_MUSIC_OFF:
			SoundHandler :: setMusicOn( false );
			saveSetting( "MusicOn", "false" );
			break;

        case MENU_CUSTOM_THRUST:
            customPlayerMenuVal = PLAYER_THRUST;
            origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal );
			setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) );
            break;
        case MENU_CUSTOM_GRAVITY:
            customPlayerMenuVal = PLAYER_GRAVITY;
            origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal );
			setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) );
            break;
        case MENU_CUSTOM_MAXSPEEDUP:
            customPlayerMenuVal = PLAYER_MAX_SPEED_UP;
            origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal );
			setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) );
            break;
        case MENU_CUSTOM_MAXSPEEDDOWN:
            customPlayerMenuVal = PLAYER_MAX_SPEED_DOWN;
            origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal );
			setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) );
            break;
        case MENU_CUSTOM_INCREASE:
            currentGame->getPlayer()->incValue( customPlayerMenuVal );
			setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) );
            break;
        case MENU_CUSTOM_DECREASE:
            currentGame->getPlayer()->decValue( customPlayerMenuVal );
			setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) );
            break;
        case MENU_CUSTOM_SAVE:
        {
            // save settings
            string key = currentGame->getGameName() + "_custom_player_" + currentGame->getPlayer()->getValueTypeString( customPlayerMenuVal );
   			saveSetting( key, currentGame->getPlayer()->getValue( customPlayerMenuVal ) );

            break;
        }
        case MENU_CUSTOM_CANCEL:
            currentGame->getPlayer()->setValue( customPlayerMenuVal, origValue );
            break;

		default:
			break;
	}
}

void SFCave :: setMenuStatusText( string statusText )
{
	menu->setStatusText( statusText );
}


void SFCave :: saveSetting( string key, string val )
{
	Settings cfg( "sfcave-sdl" );
	cfg.writeSetting( key, val );
}

void SFCave :: saveSetting( string key, int val )
{
	Settings cfg( "sfcave-sdl" );
	cfg.writeSetting( key, val );
}

void SFCave :: saveSetting( string key, long val )
{
	Settings cfg( "sfcave-sdl" );
	cfg.writeSetting( key, val );
}

void SFCave :: saveSetting( string key, double val )
{
	Settings cfg( "sfcave-sdl" );
	cfg.writeSetting( key, val );
}

string SFCave :: loadSetting( string key, string defaultVal )
{
	string val;
	Settings cfg( "sfcave-sdl" );
	cfg.readSetting( key, val );

	if ( val == "" )
		val = defaultVal;

	return val;
}

bool SFCave :: loadBoolSetting( string key, bool defaultVal )
{
	bool val = defaultVal;
	Settings cfg( "sfcave-sdl" );
	cfg.readSetting( key, val );

	return val;
}

int SFCave :: loadIntSetting( string key, int defaultVal )
{
	int val = defaultVal;
	Settings cfg( "sfcave-sdl" );
	cfg.readSetting( key, val );

	return val;
}

double SFCave :: loadDoubleSetting( string key, double defaultVal )
{
	double val = defaultVal;
	Settings cfg( "sfcave-sdl" );
	cfg.readSetting( key, val );

	return val;
}


void SFCave :: calcFPS()
{
	struct timeb tp;
	ftime( &tp );
	start =(tp.time%10000)*10000 + tp.millitm;
	if ( start - time1 >= 1000 )
	{
		actualFPS = FPS;
		FPS = 0;
		time1 = start;
	}
	else
		FPS ++;
}

void SFCave :: FPSDelay()
{
	struct timeb tp;
	// Slow down polling - limit to x FPS
	ftime( &tp );
	end = abs((tp.time%10000)*10000 + tp.millitm);
	if ( end-start < (1000/maxFPS) )
	{
		if ( (1000/maxFPS)-(end-start) > 500 )
		{
			// Should never happen but in case it does sleep for 5 seconds
			printf( "WARNING WILL ROBINSON! delay = %ld - start %ld, end %ld\n", (1000/maxFPS)-(end-start), start, end );
			SDL_Delay( 5 );
		}
		else
			SDL_Delay((1000/maxFPS)-(end-start) );
	}
}