#include "const.h"
#include "utils.h"
#include "director.h"
#include <iostream>
#include <string>

// Constructor
Director::Director(std::string path)
{

	// Crea el objeto que controla los ficheros de recursos
	mAsset = new Asset(path.substr(0, path.find_last_of("\\/")) + "../");
	
	// Establece la lista de ficheros
	Uint8 section = PROG_SECTION_LOGO;
	if (!setFileList())
	{// Si falta algún fichero no inicies el programa
		section = PROG_SECTION_QUIT;
	}

	// Crea el objeto de idioma
	mLang = new Lang(mAsset);

	// Crea el puntero a la estructura y carga el fichero de configuración
	mOptions = new options_t;
	loadConfigFile();

	// Crea los objetos
	mInput = new Input(mAsset->get("controllerdb.txt"));

	// Inicializa SDL
	initSDL();

	// Crea el objeto para dibujar en pantalla (Requiere initSDL)
	mScreen = new Screen(mWindow, mRenderer, mOptions);

	// Inicializa JailAudio
	initJailAudio();

	// Aplica las opciones
	mLang->setLang(mOptions->language);

	// Inicializa el resto de variables
	init(section);
}

Director::~Director()
{
	saveConfigFile();

	delete mAsset;
	mAsset = nullptr;

	delete mInput;
	mInput = nullptr;

	delete mScreen;
	mScreen = nullptr;

	delete mLang;
	mLang = nullptr;

	delete mOptions;
	mOptions = nullptr;

	SDL_DestroyRenderer(mRenderer);
	SDL_DestroyWindow(mWindow);
	mRenderer = nullptr;
	mWindow = nullptr;

	SDL_Quit();
}

// Inicia las variables necesarias para arrancar el programa
void Director::init(Uint8 name)
{
	// Sección
	mSection.name = name;
	mSection.subsection = 0;

	// Textos
	mLang->setLang(mOptions->language);

	// Controles
	mInput->bindKey(INPUT_UP, SDL_SCANCODE_UP);
	mInput->bindKey(INPUT_DOWN, SDL_SCANCODE_DOWN);
	mInput->bindKey(INPUT_LEFT, SDL_SCANCODE_LEFT);
	mInput->bindKey(INPUT_RIGHT, SDL_SCANCODE_RIGHT);
	mInput->bindKey(INPUT_ACCEPT, SDL_SCANCODE_RETURN);
	mInput->bindKey(INPUT_CANCEL, SDL_SCANCODE_ESCAPE);
	mInput->bindKey(INPUT_BUTTON_1, SDL_SCANCODE_Q);
	mInput->bindKey(INPUT_BUTTON_2, SDL_SCANCODE_W);
	mInput->bindKey(INPUT_BUTTON_3, SDL_SCANCODE_E);
	mInput->bindKey(INPUT_BUTTON_PAUSE, SDL_SCANCODE_ESCAPE);  // PAUSE
	mInput->bindKey(INPUT_BUTTON_ESCAPE, SDL_SCANCODE_ESCAPE); // ESCAPE

	mInput->bindGameControllerButton(INPUT_UP, SDL_CONTROLLER_BUTTON_DPAD_UP);
	mInput->bindGameControllerButton(INPUT_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
	mInput->bindGameControllerButton(INPUT_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
	mInput->bindGameControllerButton(INPUT_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
	mInput->bindGameControllerButton(INPUT_ACCEPT, SDL_CONTROLLER_BUTTON_B);
	mInput->bindGameControllerButton(INPUT_CANCEL, SDL_CONTROLLER_BUTTON_A);
	mInput->bindGameControllerButton(INPUT_BUTTON_1, SDL_CONTROLLER_BUTTON_X);
	mInput->bindGameControllerButton(INPUT_BUTTON_2, SDL_CONTROLLER_BUTTON_Y);
	mInput->bindGameControllerButton(INPUT_BUTTON_3, SDL_CONTROLLER_BUTTON_B);
	mInput->bindGameControllerButton(INPUT_BUTTON_PAUSE, SDL_CONTROLLER_BUTTON_GUIDE);	// PAUSE
	mInput->bindGameControllerButton(INPUT_BUTTON_ESCAPE, SDL_CONTROLLER_BUTTON_GUIDE); // ESCAPE
}

// Inicializa JailAudio
void Director::initJailAudio()
{
	JA_Init(48000, AUDIO_S16, 2);
}

// Arranca SDL y crea la ventana
bool Director::initSDL()
{
	// Indicador de éxito
	bool success = true;

	// Inicializa SDL
	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER | SDL_INIT_AUDIO) < 0)
	{
		printf("SDL could not initialize!\nSDL Error: %s\n", SDL_GetError());
		success = false;
	}
	else
	{
		// Inicia el generador de numeros aleatorios
		std::srand(static_cast<unsigned int>(SDL_GetTicks()));

		// Establece el filtro de la textura
		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(mOptions->filter).c_str()))
		{
			printf("Warning: Nearest texture filtering not enabled!\n");
		}

		// Crea la ventana
		mWindow = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, mOptions->screenWidth * mOptions->windowSize, mOptions->screenHeight * mOptions->windowSize, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);
		if (mWindow == nullptr)
		{
			printf("Window could not be created!\nSDL Error: %s\n", SDL_GetError());
			success = false;
		}
		else
		{
			// Crea un renderizador para la ventana. El vsync se activa en funcion de las opciones
			if (mOptions->vSync)
				mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
			else
				mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED);

			if (mRenderer == nullptr)
			{
				printf("Renderer could not be created!\nSDL Error: %s\n", SDL_GetError());
				success = false;
			}
			else
			{
				// Inicializa el color de renderizado
				SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF);

				// Establece el tamaño del buffer de renderizado
				SDL_RenderSetLogicalSize(mRenderer, mOptions->screenWidth, mOptions->screenHeight);

				// Establece el modo de mezcla
				SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_BLEND);
			}
		}
	}

	printf("\n");
	return success;
}

// Crea el indice de ficheros
bool Director::setFileList()
{
	// Ficheros binarios
	mAsset->add("data/score.bin", data, false);
	mAsset->add("data/demo.bin", data);
	mAsset->add("data/config.bin", data, false);

	// Musicas
	mAsset->add("media/music/intro.ogg", music);
	mAsset->add("media/music/playing.ogg", music);
	mAsset->add("media/music/title.ogg", music);

	// Sonidos
	mAsset->add("media/sound/balloon.wav", sound);
	mAsset->add("media/sound/bubble1.wav", sound);
	mAsset->add("media/sound/bubble2.wav", sound);
	mAsset->add("media/sound/bubble3.wav", sound);
	mAsset->add("media/sound/bubble4.wav", sound);
	mAsset->add("media/sound/bullet.wav", sound);
	mAsset->add("media/sound/coffeeout.wav", sound);
	mAsset->add("media/sound/hiscore.wav", sound);
	mAsset->add("media/sound/itemdrop.wav", sound);
	mAsset->add("media/sound/itempickup.wav", sound);
	mAsset->add("media/sound/menu_cancel.wav", sound);
	mAsset->add("media/sound/menu_move.wav", sound);
	mAsset->add("media/sound/menu_select.wav", sound);
	mAsset->add("media/sound/player_collision.wav", sound);
	mAsset->add("media/sound/stage_change.wav", sound);
	mAsset->add("media/sound/title.wav", sound);
	mAsset->add("media/sound/clock.wav", sound);
	mAsset->add("media/sound/powerball.wav", sound);

	// Texturas
	mAsset->add("media/gfx/balloon.png", bitmap);
	mAsset->add("media/gfx/bullet.png", bitmap);
	mAsset->add("media/gfx/game_bg.png", bitmap);
	mAsset->add("media/gfx/game_text.png", bitmap);
	mAsset->add("media/gfx/intro.png", bitmap);
	mAsset->add("media/gfx/items.png", bitmap);
	mAsset->add("media/gfx/logo.png", bitmap);
	mAsset->add("media/gfx/player1_body.png", bitmap);
	mAsset->add("media/gfx/player1_death.png", bitmap);
	mAsset->add("media/gfx/player1_legs.png", bitmap);
	mAsset->add("media/gfx/title.png", bitmap);
	mAsset->add("media/gfx/player1_head.png", bitmap);
	mAsset->add("media/gfx/player2_body.png", bitmap);
	mAsset->add("media/gfx/player2_death.png", bitmap);
	mAsset->add("media/gfx/player2_legs.png", bitmap);
	mAsset->add("media/gfx/player2_head.png", bitmap);

	// Fuentes
	mAsset->add("media/font/8bithud.png", font);
	mAsset->add("media/font/8bithud.txt", font);
	mAsset->add("media/font/nokia.png", font);
	mAsset->add("media/font/nokia_big2.png", font);
	mAsset->add("media/font/nokia.txt", font);
	mAsset->add("media/font/nokia2.png", font);
	mAsset->add("media/font/nokia2.txt", font);
	mAsset->add("media/font/nokia_big2.txt", font);
	mAsset->add("media/font/smb2_big.png", font);
	mAsset->add("media/font/smb2_big.txt", font);
	mAsset->add("media/font/smb2.png", font);
	mAsset->add("media/font/smb2.txt", font);

	// Textos
	mAsset->add("media/lang/es_ES.txt", lang);
	mAsset->add("media/lang/en_UK.txt", lang);
	mAsset->add("media/lang/ba_BA.txt", lang);

	// DATA
	mAsset->add("data/gamecontrollerdb.txt", data);

	return mAsset->check();

	// Inicializa el vector
	/*for (int i = 0; i < MAX_FILE_LIST; i++)
		mFileList[i] = "";

	// Ficheros binarios
	mFileList[0] = mExecutablePath + "/" + "../data/score.bin";
	mFileList[1] = mExecutablePath + "/" + "../data/demo.bin";
	mFileList[2] = mExecutablePath + "/" + "../data/config.bin";

	// Musicas
	mFileList[3] = mExecutablePath + "/" + "../media/music/intro.ogg";
	mFileList[4] = mExecutablePath + "/" + "../media/music/playing.ogg";
	mFileList[5] = mExecutablePath + "/" + "../media/music/title.ogg";

	// Sonidos
	mFileList[6] = mExecutablePath + "/" + "../media/sound/balloon.wav";
	mFileList[7] = mExecutablePath + "/" + "../media/sound/bubble1.wav";
	mFileList[8] = mExecutablePath + "/" + "../media/sound/bubble2.wav";
	mFileList[9] = mExecutablePath + "/" + "../media/sound/bubble3.wav";
	mFileList[10] = mExecutablePath + "/" + "../media/sound/bubble4.wav";
	mFileList[11] = mExecutablePath + "/" + "../media/sound/bullet.wav";
	mFileList[12] = mExecutablePath + "/" + "../media/sound/coffeeout.wav";
	mFileList[13] = mExecutablePath + "/" + "../media/sound/hiscore.wav";
	mFileList[14] = mExecutablePath + "/" + "../media/sound/itemdrop.wav";
	mFileList[15] = mExecutablePath + "/" + "../media/sound/itempickup.wav";
	mFileList[16] = mExecutablePath + "/" + "../media/sound/menu_cancel.wav";
	mFileList[17] = mExecutablePath + "/" + "../media/sound/menu_move.wav";
	mFileList[18] = mExecutablePath + "/" + "../media/sound/menu_select.wav";
	mFileList[19] = mExecutablePath + "/" + "../media/sound/player_collision.wav";
	mFileList[20] = mExecutablePath + "/" + "../media/sound/stage_change.wav";
	mFileList[21] = mExecutablePath + "/" + "../media/sound/title.wav";
	mFileList[22] = mExecutablePath + "/" + "../media/sound/clock.wav";
	mFileList[23] = mExecutablePath + "/" + "../media/sound/powerball.wav";

	// Texturas
	mFileList[24] = mExecutablePath + "/" + "../media/gfx/balloon.png";
	mFileList[25] = mExecutablePath + "/" + "../media/gfx/bullet.png";
	mFileList[31] = mExecutablePath + "/" + "../media/gfx/game_bg.png";
	mFileList[32] = mExecutablePath + "/" + "../media/gfx/game_text.png";
	mFileList[33] = mExecutablePath + "/" + "../media/gfx/intro.png";
	mFileList[34] = mExecutablePath + "/" + "../media/gfx/items.png";
	mFileList[35] = mExecutablePath + "/" + "../media/gfx/logo.png";
	mFileList[37] = mExecutablePath + "/" + "../media/gfx/player1_body.png";
	mFileList[38] = mExecutablePath + "/" + "../media/gfx/player1_death.png";
	mFileList[39] = mExecutablePath + "/" + "../media/gfx/player1_legs.png";
	mFileList[40] = mExecutablePath + "/" + "../media/gfx/title.png";
	mFileList[41] = mExecutablePath + "/" + "../media/gfx/player1_head.png";
	mFileList[42] = mExecutablePath + "/" + "../media/gfx/player2_body.png";
	mFileList[43] = mExecutablePath + "/" + "../media/gfx/player2_death.png";
	mFileList[44] = mExecutablePath + "/" + "../media/gfx/player2_legs.png";
	mFileList[45] = mExecutablePath + "/" + "../media/gfx/player2_head.png";

	// Fuentes
	mFileList[27] = mExecutablePath + "/" + "../media/font/8bithud.png";
	mFileList[46] = mExecutablePath + "/" + "../media/font/8bithud.txt";
	mFileList[28] = mExecutablePath + "/" + "../media/font/nokia.png";
	mFileList[54] = mExecutablePath + "/" + "../media/font/nokia_big2.png";
	mFileList[52] = mExecutablePath + "/" + "../media/font/nokia.txt";
	mFileList[56] = mExecutablePath + "/" + "../media/font/nokia2.png";
	mFileList[57] = mExecutablePath + "/" + "../media/font/nokia2.txt";
	mFileList[55] = mExecutablePath + "/" + "../media/font/nokia_big2.txt";
	mFileList[29] = mExecutablePath + "/" + "../media/font/smb2_big.png";
	mFileList[47] = mExecutablePath + "/" + "../media/font/smb2_big.txt";
	mFileList[30] = mExecutablePath + "/" + "../media/font/smb2.png";
	mFileList[48] = mExecutablePath + "/" + "../media/font/smb2.txt";

	// Textos
	mFileList[49] = mExecutablePath + "/" + "../media/lang/es_ES.txt";
	mFileList[50] = mExecutablePath + "/" + "../media/lang/en_UK.txt";
	mFileList[51] = mExecutablePath + "/" + "../media/lang/ba_BA.txt";

	// DATA
	mFileList[53] = mExecutablePath + "/" + "../data/gamecontrollerdb.txt";
	*/
}

// Carga el fichero de configuración
bool Director::loadConfigFile()
{
	// Pone unos valores por defecto
	mOptions->fullScreenMode = 0;
	mOptions->windowSize = 3;
	mOptions->language = ba_BA;
	mOptions->difficulty = DIFFICULTY_NORMAL;
	mOptions->input[0].deviceType = INPUT_USE_KEYBOARD;
	mOptions->input[1].deviceType = INPUT_USE_GAMECONTROLLER;
	mOptions->filter = FILTER_NEAREST;
	mOptions->vSync = true;
	mOptions->screenWidth = SCREEN_WIDTH;
	mOptions->screenHeight = SCREEN_HEIGHT;
	mOptions->integerScale = true;
	mOptions->keepAspect = true;

	// Indicador de éxito en la carga
	bool success = true;

	const std::string p = mAsset->get("config.bin");
	std::string filename = p.substr(p.find_last_of("\\/") + 1);
	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b");

	// El fichero no existe
	if (file == nullptr)
	{
		printf("Warning: Unable to open %s file\n", filename.c_str());

		// Crea el fichero para escritura
		file = SDL_RWFromFile(p.c_str(), "w+b");
		if (file != nullptr)
		{
			printf("New file (%s) created!\n", filename.c_str());

			// Escribe los datos
			SDL_RWwrite(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1);
			SDL_RWwrite(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1);
			SDL_RWwrite(file, &mOptions->language, sizeof(mOptions->language), 1);
			SDL_RWwrite(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1);
			SDL_RWwrite(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1);
			SDL_RWwrite(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1);
			SDL_RWwrite(file, &mOptions->filter, sizeof(mOptions->filter), 1);
			SDL_RWwrite(file, &mOptions->vSync, sizeof(mOptions->vSync), 1);
			SDL_RWwrite(file, &mOptions->screenWidth, sizeof(mOptions->screenWidth), 1);
			SDL_RWwrite(file, &mOptions->screenHeight, sizeof(mOptions->screenHeight), 1);
			SDL_RWwrite(file, &mOptions->integerScale, sizeof(mOptions->integerScale), 1);
			SDL_RWwrite(file, &mOptions->keepAspect, sizeof(mOptions->keepAspect), 1);

			// Cierra el fichero
			SDL_RWclose(file);
		}
		else
		{
			printf("Error: Unable to create file %s\n", filename.c_str());
			success = false;
		}
	}
	// El fichero existe
	else
	{
		// Carga los datos
		printf("Reading file %s\n", filename.c_str());
		SDL_RWread(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1);
		SDL_RWread(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1);
		SDL_RWread(file, &mOptions->language, sizeof(mOptions->language), 1);
		SDL_RWread(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1);
		SDL_RWread(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1);
		SDL_RWread(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1);
		SDL_RWread(file, &mOptions->filter, sizeof(mOptions->filter), 1);
		SDL_RWread(file, &mOptions->vSync, sizeof(mOptions->vSync), 1);
		SDL_RWread(file, &mOptions->screenWidth, sizeof(mOptions->screenWidth), 1);
		SDL_RWread(file, &mOptions->screenHeight, sizeof(mOptions->screenHeight), 1);
		SDL_RWread(file, &mOptions->integerScale, sizeof(mOptions->integerScale), 1);
		SDL_RWread(file, &mOptions->keepAspect, sizeof(mOptions->keepAspect), 1);

		// Normaliza los valores
		if (!((mOptions->fullScreenMode == 0) ||
			  (mOptions->fullScreenMode == SDL_WINDOW_FULLSCREEN) ||
			  (mOptions->fullScreenMode == SDL_WINDOW_FULLSCREEN_DESKTOP)))
			mOptions->fullScreenMode = 0;
		if ((mOptions->windowSize < 1) || (mOptions->windowSize > 4))
			mOptions->windowSize = 3;
		if ((mOptions->language < 0) || (mOptions->language > MAX_LANGUAGES))
			mOptions->language = en_UK;

		// Cierra el fichero
		SDL_RWclose(file);
	}

	return success;
}

// Guarda el fichero de configuración
bool Director::saveConfigFile()
{
	bool success = true;
	const std::string p = mAsset->get("config.bin");
	std::string filename = p.substr(p.find_last_of("\\/") + 1);
	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b");
	if (file != nullptr)
	{
		// Guarda los datos
		SDL_RWwrite(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1);
		SDL_RWwrite(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1);
		SDL_RWwrite(file, &mOptions->language, sizeof(mOptions->language), 1);
		SDL_RWwrite(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1);
		SDL_RWwrite(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1);
		SDL_RWwrite(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1);
		SDL_RWwrite(file, &mOptions->filter, sizeof(mOptions->filter), 1);
		SDL_RWwrite(file, &mOptions->vSync, sizeof(mOptions->vSync), 1);
		SDL_RWwrite(file, &mOptions->screenWidth, sizeof(mOptions->screenWidth), 1);
		SDL_RWwrite(file, &mOptions->screenHeight, sizeof(mOptions->screenHeight), 1);
		SDL_RWwrite(file, &mOptions->integerScale, sizeof(mOptions->integerScale), 1);
		SDL_RWwrite(file, &mOptions->keepAspect, sizeof(mOptions->keepAspect), 1);

		printf("Writing file %s\n", filename.c_str());

		// Cierra el fichero
		SDL_RWclose(file);
	}
	else
	{
		printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError());
	}
	return success;
}

// Obtiene el valor de la variable
Uint8 Director::getSubsection()
{
	return mSection.subsection;
}

// Obtiene el valor de la variable
Uint8 Director::getSection()
{
	return mSection.name;
}

// Establece el valor de la variable
void Director::setSection(section_t section)
{
	mSection = section;
}

void Director::runLogo()
{
	mLogo = new Logo(mRenderer, mScreen, mAsset);
	setSection(mLogo->run());
	delete mLogo;
}

void Director::runIntro()
{
	mIntro = new Intro(mRenderer, mScreen, mAsset, mLang);
	setSection(mIntro->run());
	delete mIntro;
}

void Director::runTitle()
{
	mTitle = new Title(mWindow, mRenderer, mScreen, mInput, mAsset, mOptions, mLang);
	setSection(mTitle->run(mSection.subsection));
	delete mTitle;
}

void Director::runGame()
{
	if (mSection.subsection == GAME_SECTION_PLAY_1P)
	{
		mGame = new Game(1, 0, mRenderer, mScreen, mAsset, mLang, mInput, false, mOptions);
	}

	else if (mSection.subsection == GAME_SECTION_PLAY_2P)
	{
		mGame = new Game(2, 0, mRenderer, mScreen, mAsset, mLang, mInput, false, mOptions);
	}

	setSection(mGame->run());
	delete mGame;
}

void Director::run()
{
	// Bucle principal
	while (!(getSection() == PROG_SECTION_QUIT))
	{
		switch (getSection())
		{
		case PROG_SECTION_LOGO:
			runLogo();
			break;

		case PROG_SECTION_INTRO:
			runIntro();
			break;

		case PROG_SECTION_TITLE:
			runTitle();
			break;

		case PROG_SECTION_GAME:
			runGame();
			break;
		}
	}
}