#pragma once
#include "ifdefs.h"
#include "sprite.h"
#include "movingsprite.h"
#include "smartsprite.h"
#include "player.h"
#include "balloon.h"
#include "bullet.h"
#include "item.h"
#include "text.h"
#include "text2.h"
#include "menu.h"
#include "const.h"
#include "jail_audio.h"
#include <math.h>

#ifndef GAMEDIRECTOR_H
#define GAMEDIRECTOR_H

// GameDirector
class GameDirector
{
public:
	// Constructor
	GameDirector();

	// Destructor
	~GameDirector();

	// Iniciador
	void init(bool reset);

	// Arranca SDL y crea la ventana
	bool initSDL();

	// Crea el indice de ficheros
	void setFileList();

	// Comprueba que todos los ficheros existen
	bool checkFileList();

	// Carga un archivo de imagen en una textura
	bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer);

	// Carga los recursos necesarios
	bool loadMedia(Uint8 section);

	// Descrga los recursos necesarios
	bool unLoadMedia(Uint8 section);

	// Establece el valor de la variable
	void setExecutablePath(std::string path);

	// Establece el valor de la variable
	void setScore(Uint32 score);

	// Establece el valor de la variable
	void setHiScore(Uint32 score);

	// Actualiza el valor de HiScore en caso necesario
	void updateHiScore();

	// Transforma un valor numérico en una cadena de 6 cifras
	std::string updateScoreText(Uint32 num);

	// Pinta el marcador en pantalla usando un objeto texto
	void renderScoreBoard();

	// Actualiza el valor de la variable mStage
	void updateStage();

	// Actualiza el estado de muerte
	void updateDeath();

	// Renderiza el fade final cuando se acaba la partida
	void renderDeathFade();

	// Mueve todos los globos activos
	void moveBalloons();

	// Pinta en pantalla todos los globos activos
	void renderBalloons();

	// Devuelve el primer indice no activo del vector de globos
	Uint8 getBallonFreeIndex();

	// Crea un globo nuevo en el vector de globos
	Uint8 createNewBalloon(float x, int y, Uint8 kind, float velx, Uint16 stoppedtimer, LTexture *texture);

	// Establece a cero todos los valores del vector de objetos globo
	void resetBalloons();

	// Explosiona un globo. Lo destruye y crea otros dos si es el caso
	void popBalloon(Uint8 index);

	// Explosiona todos los globos
	void popAllBallons();

	// Detiene todos los globos
	void stopAllBalloons(Uint16 time);

	// Pone en marcha todos los globos
	void startAllBalloons();

	// Obtiene el numero de globos activos
	Uint8 countBalloons();

	// Comprueba la colisión entre el jugador y los globos activos
	bool checkPlayerBallonCollision();

	// Comprueba la colisión entre el jugador y los items
	void checkPlayerItemCollision();

	// Comprueba la colisión entre las balas y los globos
	void checkBulletBallonCollision();

	// Mueve las balas activas
	void moveBullets();

	// Pinta las balas activas
	void renderBullets();

	// Devuelve el primer indice no activo del vector de balas
	Uint8 getBulletFreeIndex();

	// Establece a cero todos los valores del vector de objetos bala
	void resetBullets();

	// Crea un objeto bala
	void createBullet(int x, int y, Uint8 kind);

	// Actualiza los items
	void updateItems();

	// Pinta los items activos
	void renderItems();

	// Devuelve el primer indice no activo del vector de items
	Uint8 getItemFreeIndex();

	// Establece a cero todos los valores del vector de objetos item
	void resetItems();

	// Devuelve un item en función del azar
	Uint8 dropItem();

	// Crea un objeto item
	void createItem(int x, int y, Uint8 kind);

	// Crea un objeto SmartSprite
	void createItemScoreSprite(int x, int y, SmartSprite *sprite);

	// Crea un SmartSprite para arrojar el item café al recibir un impacto
	void throwCoffee(int x, int y);

	// Crea un SmartSprite para arrojar al jugador al morir
	void throwPlayer(int x, int y);

	// Actualiza los SmartSprites
	void updateSmartSprites();

	// Pinta los SmartSprites activos
	void renderSmartSprites();

	// Devuelve el primer indice no activo del vector de SmartSprites
	Uint8 getSmartSpriteFreeIndex();

	// Establece a cero todos los valores del vector de objetos SmafrtSprite
	void resetSmartSprites();

	// Acciones a realizar cuando el jugador muere
	void killPlayer();

	// Calcula y establece el valor de amenaza en funcion de los globos activos
	void calculateMenaceLevel();

	// Obtiene el valor de la variable
	Uint8 getMenaceLevel();

	// Obtiene el valor de la variable
	bool isPlayFieldDrawOnly();

	// Establece el valor de la variable
	void setPlayFieldDrawOnly(bool state);

	// Establece el valor de la variable
	void setTimeStopped(bool value);

	// Obtiene el valor de la variable
	bool isTimeStopped();

	// Establece el valor de la variable
	void setTimeStoppedTimer(Uint16 value);

	// Actualiza y comprueba el valor de la variable
	void updateTimeStoppedTimer();

	// Establece el valor de la variable
	void setExplosionTime(bool value);

	// Obtiene el valor de la variable
	bool isExplosionTime();

	// Establece el valor de la variable
	void setRemainingExplosions(Uint8 value);

	// Actualiza y comprueba el valor de la variable
	void updateRemainingExplosionsTimer();

	// Gestiona el nivel de amenaza
	void checkMenaceLevel();

	// Actualiza el campo de juego
	void updatePlayField();

	// Actualiza el fondo
	void updateBackground();

	// Dibuja el fondo
	void renderBackground();

	// Dibuja el campo de juego
	void renderPlayField();

	// Gestiona las entradas desde el mando de juego
	bool checkGameController(Uint8 state);

	// Gestiona la entrada durante el juego
	void checkGameInput();

	// Gestiona la entrada de teclado y mando durante el menu
	void checkMenuInput(Menu *menu);

	// Obtiene el valor de la variable
	Uint8 getGameStatus();

	// Establece el valor de la variable
	void setGameStatus(Uint8 status);

	// Pinta una transición en pantalla
	void renderFade(Uint8 index);

	// Pinta diferentes mensajes en la pantalla
	void renderMessages();

	// Habilita el efecto del item de detener el tiempo
	void enableTimeStopItem();

	// Deshabilita el efecto del item de detener el tiempo
	void disableTimeStopItem();

	// Cambia el valor de la variable de modo de pantalla completa
	void changeFullScreenMode();

	// Actualiza los elementos del menu de opciones
	void updateOptionsMenu();

	// Agita la pantalla
	void shakeScreen();

	// Bucle para el logo del juego
	void runLogo();

	// Bucle para la intro del juego
	void runIntro();

	// Bucle para el titulo del juego
	void runTitle();

	// Bucle para el juego
	void runGame();

	// Bucle para el menu de pausa del juego
	void runPausedGame();

	// Bucle para la pantalla de instrucciones
	void runInstructions();

	// Bucle para la pantalla de game over
	void runGameOverScreen();

	// Dibuja la informacion de debug en pantalla
	void renderDebugInfo();

	// Activa el modo Demo
	void enableDemoMode();

	// Desactiva el modo Demo
	void disableDemoMode();

	// Intercambia el proximo estado del juego despues del titulo
	void toogleTitleNextGS();

private:
	// La ventana donde dibujamos
	SDL_Window *mWindow;

	// El renderizador de la ventana
	SDL_Renderer *mRenderer;

	// Texturas donde dibujar
	SDL_Texture *mBackbuffer;
	SDL_Texture *mTitleSurface;
	SDL_Texture *mInstructionsSurface;

	// Manejador para el mando 1
	SDL_Joystick *mGameController;
	bool mGameControllerFound;
	SDL_Haptic *mControllerHaptic;

	// Datos del fichero
	Uint32 mScoreDataFile[TOTAL_SCORE_DATA];
	DemoKeys mDemoDataFile[TOTAL_DEMO_DATA];

	// Manejador de eventos
	SDL_Event *mEventHandler;

	// El jugador
	Player *mPlayer;

	// Vector con los objetos globo
	Balloon *mBalloon[MAX_BALLOONS];

	// Vector con los objetos bala
	Bullet *mBullet[MAX_BULLETS];

	// Vector con los objetos item
	Item *mItem[MAX_ITEMS];

	// Fondo del juego
	Sprite *mGameBackgroundFront;
	Sprite *mGameBackgroundSky;
	MovingSprite *mGBClouds1;
	MovingSprite *mGBClouds1b;
	MovingSprite *mGBClouds2;
	MovingSprite *mGBClouds2b;
	Sprite *mGrass;

	// Instrucciones
	Sprite *mInstructions;

	// Fondo de la pantalla de titulo
	Sprite *mTitleTile;

	// Ventana visible de la textura de fondo del titulo
	SDL_Rect mBackgroundWindow;

	// Vector con los valores del seno para 360 grados
	double mSen[360];

	// Texto
	struct text
	{
		Text *white;
		Text *black;
		Text *nokia;
	};

	text mText;

	// Variable con lkos menus del juego
	struct menu
	{
		Menu *title;	// Menu de la pantalla de título
		Menu *pause;	// Menú de la pantalla de pausa
		Menu *gameOver; // Menú de la pantalla de game over
		Menu *options;	// Menú de la pantalla de opciones
		Menu *active;	// Menu activo (de momento para la pantalla del titulo)
	};

	menu mMenu;

	// Notificación GetReady!
	SmartSprite *mGetReadyBitmap;

	// Dibujos de la intro
	SmartSprite *mIntroBitmap[INTRO_TOTAL_BITMAPS];

	// Sprites con el titulo del juego para la pantalla de titulo
	SmartSprite *mCoffeeBitmap;
	SmartSprite *mCrisisBitmap;
	AnimatedSprite *mDustSpriteLeft;
	AnimatedSprite *mDustSpriteRight;

	// Sprites con los puntos de algunos objetos
	SmartSprite *m1000Bitmap;
	SmartSprite *m2500Bitmap;
	SmartSprite *m5000Bitmap;

	// Vector para almacenar y gestionar SmartSprites
	SmartSprite *mSmartSprite[MAX_SMART_SPRITES];

	// Textos de la intro
	Text2 *mIntroText[INTRO_TOTAL_TEXTS];

	// Vector para coordinar los eventos de la intro
	Uint8 mIntroEvents[INTRO_TOTAL_EVENTS];

	// Vector para coordinar los eventos de la pantalla de titulo
	Uint8 mTitleEvents[TITLE_TOTAL_EVENTS];

	// Indicador para el bucle del titulo
	Uint8 mTitleStatus;

	struct game
	{
		Uint32 score;					 // Puntuación actual
		Uint32 hiScore;					 // Puntuación máxima
		Uint8 status;					 // Indicador para el bucle principal
		bool paused;					 // Idica si el juego está en pausa
		bool hiScoreAchieved;			 // Indica si se ha superado la puntuación máxima
		Uint8 stage;					 // Pantalla actual
		Uint8 stageCounter;				 // Contador para el tiempo visible del texto de Stage
		double stagePath[STAGE_COUNTER]; // Vector con los puntos Y por donde pasará la etiqueta
		Uint16 deathCounter;			 // Contador para la animación de muerte del jugador
		Uint8 deathIndex;				 // Indice del vector de smartsprites que contiene el sprite del jugador
	};

	game mGame;

	// Contador de ticks para ajustar la velocidad del juego
	Uint32 mTicks;

	// Velocidad a la que se repite el bucle de juego
	Uint8 mTicksSpeed;

	// Nivel de amenaza actual
	Uint8 mMenaceLevel;

	// Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral,
	// se generan más globos. Si el umbral aumenta, aumenta el numero de globos
	Uint8 mMenaceLevelThreshold;

	// Indica si el bucle de juego avanza o solo pinta
	bool mPlayFieldDrawOnly;

	// Indica si se va a mostrar la información de debug
	bool mDebug;

	// Almacena los códigos de teclado correspondientes
	Input mKeyboard;

	// Buffer para teclas pulsadas
	Input mKeyboardBuffer;

	// Indica si el tiempo está detenido
	bool mTimeStopped;

	// Temporizador para llevar la cuenta del tiempo detenido
	Uint16 mTimeStoppedTimer;

	// Cantidad de explosiones restantes
	Uint8 mRemainingExplosions;

	// Temporizador para la cantidad de explosiones restantes
	Uint16 mRemainingExplosionsTimer;

	// Indica si las explosiones estan en marcha
	bool mExplosionTime;

	// Contador para las instrucciones
	Uint16 mInstructionsCounter;

	// Temporizador para la pantalla de titulo
	Uint16 mTitleTimer;

	// Temporizador para el fondo de tiles de la pantalla de titulo
	Uint16 mTitleBackgroundTimer;

	// Variable para almacenar el tipo de efecto que hará el foindo del titulo
	Uint8 mTitleBackgroundMode;

	// Indicador para saber si se muestra el menu del titulo o la frase intermitente
	bool mTitleMenuVisible;

	// Indica si está activo el modo demo
	bool mDemo;

	// Indica si está activado el modo para grabar la demo
	bool mDemoRecording;

	// Contador para el modo demo
	Uint16 mDemoCounter;
	DemoKeys mDemoKeys;

	// Indica a que estado pasara el juego cuando acabe el temporizador del titulo
	Uint8 mTiteNextGS;

	// Contador para el juego
	Uint32 mGameCounter;

	// Variable para evitar la repetición de teclas en los menus
	bool mMenuKeyPressed;

	// Variables para el tamaño y modo de la ventana y variables para almacenar el valor si cancelamos en el menu de opciones
	Uint32 mFullScreenMode;
	Uint32 mFullScreenModePrevious;
	Uint8 mWindowSize;
	Uint8 mWindowSizePrevious;

	// Variables para el logo
	struct logo
	{
		Uint16 counter;
		Sprite *sprite;
	};
	logo mLogo;

	// Path del ejecutable
	std::string mExecutablePath;

	// Recursos
	struct resourceBinFile
	{
		std::string file;
		bool loaded;
	};

	resourceBinFile mBinFile[TOTAL_BINFILE];

	struct resourceSound
	{
		std::string file;
		bool loaded;
		JA_Sound sound;
	};

	resourceSound mSound[TOTAL_SOUND];

	struct resourceMusic
	{
		std::string file;
		bool loaded;
		JA_Music music;
	};

	resourceMusic mMusic[TOTAL_MUSIC];

	struct resourceTexture
	{
		std::string file;
		bool loaded;
		LTexture *texture;
	};

	resourceTexture mTexture[TOTAL_TEXTURE];
};

#endif