#pragma once
#include "ifdefs.h"
#include "const.h"
#include "utils.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 "input.h"
#include "fade.h"
#include "jail_audio.h"

#ifndef GAME_H
#define GAME_H

// Game
class Game
{
private:
	struct enemyInits_t
	{
		int x;					// Posición en el eje X donde crear al enemigo
		int y;					// Posición en el eje Y donde crear al enemigo
		float velX;				// Velocidad inicial en el eje X
		Uint8 kind;				// Tipo de enemigo
		Uint16 creationCounter; // Temporizador para la creación del enemigo
	};

	struct enemyFormation_t // Contiene la información de una formación enemiga
	{
		Uint8 numberOfEnemies;									 // Cantidad de enemigos que forman la formación
		enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
	};
	enemyFormation_t mEnemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas

	struct enemyPool_t
	{
		enemyFormation_t *set[10]; // Conjunto de formaciones enemigas
	};
	enemyPool_t mEnemyPool[10]; // Variable con los diferentes conjuntos de formaciones enemigas

	struct stage_t // Contiene todas las variables relacionadas con una fase
	{
		enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase
		Uint16 currentPower;	// Cantidad actual de poder
		Uint16 powerToComplete; // Cantidad de poder que se necesita para completar la fase
		Uint8 maxMenace;		// Umbral máximo de amenaza de la fase
		Uint8 minMenace;		// Umbral mínimo de amenaza de la fase
		Uint8 number;			// Numero de fase
	};

	struct effect_t
	{
		bool flash;			// Indica si se ha de pintar la pantalla de blanco
		bool shake;			// Indica si se ha de agitar la pantalla
		Uint8 shakeCounter; // Contador para medir el tiempo que dura el efecto
	};

	struct helper_t
	{
		bool needCoffee;		   // Indica si se necesitan cafes
		bool needCoffeeMachine;	   // Indica si se necesita PowerUp
		bool needPowerBall;		   // Indica si se necesita una PowerBall
		int counter;			   // Contador para no dar ayudas consecutivas
		int itemPoints1Odds;	   // Probabilidad de aparición del objeto
		int itemPoints2Odds;	   // Probabilidad de aparición del objeto
		int itemPoints3Odds;	   // Probabilidad de aparición del objeto
		int itemClockOdds;		   // Probabilidad de aparición del objeto
		int itemCoffeeOdds;		   // Probabilidad de aparición del objeto
		int itemCoffeeMachineOdds; // Probabilidad de aparición del objeto
	};

	SDL_Renderer *mRenderer;   // El renderizador de la ventana
	std::string *mFileList;	   // Lista de ficheros con los recursos
	std::string *mTextStrings; // Vector con los textos del juego

	int mNumPlayers;	// Numero de jugadores
	Player *mPlayer[2]; // Vector con los jugadores jugador
	Input *mInput[2];		   // Manejador de entrada, uno por cada jugador

	Balloon *mBalloon[MAX_BALLOONS];			  // Vector con los objetos globo
	Bullet *mBullet[MAX_BULLETS];				  // Vector con los objetos bala
	Item *mItem[MAX_ITEMS];						  // Vector con los objetos item
	SmartSprite *mSmartSprite[MAX_SMART_SPRITES]; // Vector para almacenar y gestionar SmartSprites

	LTexture *mTextureBalloon;		// Textura para los enemigos
	LTexture *mTextureBullet;		// Textura para las balas
	LTexture *mTextureGameBG;		// Textura para el fondo del juego
	LTexture *mTextureGameText;		// Textura para los sprites con textos
	LTexture *mTextureItems;		// Textura para los items
	LTexture *mTexturePlayer1Head;	// Textura para la cabeza del jugador1
	LTexture *mTexturePlayer1Body;	// Textura para el cuerpo del jugador1
	LTexture *mTexturePlayer1Death; // Textura para la animación de muerte del jugador1
	LTexture *mTexturePlayer1Legs;	// Textura para las piernas del jugador
	LTexture *mTexturePlayer2Head;	// Textura para la cabeza del jugador2
	LTexture *mTexturePlayer2Body;	// Textura para el cuerpo del jugador2
	LTexture *mTexturePlayer2Death; // Textura para la animación de muerte del jugador2
	LTexture *mTexturePlayer2Legs;	// Textura para las piernas del jugador
	LTexture *mTextureText;			// Textura para el texto
	LTexture *mTextureText2;		// Textura para el texto

	Text *mText;   // Variable con todos los objetos de texto
	Text *mTextX2; // Variable con todos los objetos de texto

	Menu *mMenuGameOver; // Menú de la pantalla de game over
	Menu *mMenuPause;	 // Menú de la pantalla de pausa

	Fade *mFade;			  // Objeto para renderizar fades
	SDL_Event *mEventHandler; // Manejador de eventos

	MovingSprite *mClouds1a;   // Sprite para las nubes superiores
	MovingSprite *mClouds1b;   // Sprite para las nubes superiores
	MovingSprite *mClouds2a;   // Sprite para las nubes inferiores
	MovingSprite *mClouds2b;   // Sprite para las nubes inferiores
	SmartSprite *m1000Bitmap;  // Sprite con el texto 1.000
	SmartSprite *m2500Bitmap;  // Sprite con el texto 2.500
	SmartSprite *m5000Bitmap;  // Sprite con el texto 5.000
	Sprite *mSpriteBackground; // Sprite con los graficos frontales del fondo
	Sprite *mSpriteGetReady;   // Sprite para el texto de GetReady del principio de la partida
	Sprite *mSpriteGradient;   // Sprite con los graficos del degradado de color de fondo
	Sprite *mSpriteGrass;	   // Sprite para la hierba
	Sprite *mSpritePowerMeter; // Sprite para el medidor de poder de la fase
	Sprite *mSpriteScoreBoard; // Sprite para el fondo del marcador

	JA_Sound mSoundBalloon;			// Sonido para la explosión del globo
	JA_Sound mSoundBullet;			// Sonido para los disparos
	JA_Sound mSoundPlayerCollision; // Sonido para la colisión del jugador con un enemigo
	JA_Sound mSoundHiScore;			// Sonido para cuando se alcanza la máxima puntuación
	JA_Sound mSoundItemDrop;		// Sonido para cuando se genera un item
	JA_Sound mSoundItemPickup;		// Sonido para cuando se recoge un item
	JA_Sound mSoundCoffeeOut;		// Sonido para cuando el jugador pierde el café al recibir un impacto
	JA_Sound mSoundStageChange;		// Sonido para cuando se cambia de fase
	JA_Sound mSoundBubble1;			// Sonido para cuando el jugador muere
	JA_Sound mSoundBubble2;			// Sonido para cuando el jugador muere
	JA_Sound mSoundBubble3;			// Sonido para cuando el jugador muere
	JA_Sound mSoundBubble4;			// Sonido para cuando el jugador muere
	JA_Sound mSoundClock;			// Sonido para cuando se detiene el tiempo con el item reloj
	JA_Sound mSoundPowerBall;		// Sonido para cuando se explota una Power Ball
	JA_Sound mSoundCollision;		// Sonido para cuando la máquina de café toca el suelo

	JA_Music mMusicPlaying; // Musica de fondo

	Uint32 mTicks;	   // Contador de ticks para ajustar la velocidad del programa
	Uint8 mTicksSpeed; // Velocidad a la que se repiten los bucles del programa

	//Uint32 mScore;							  // Puntuación actual
	Uint32 mHiScore;						  // Puntuación máxima
	bool mHiScoreAchieved;					  // Indica si se ha superado la puntuación máxima
	section_t mSection;						  // Seccion actual dentro del juego
	stage_t mStage[10];						  // Variable con los datos de cada pantalla
	Uint8 mCurrentStage;					  // Indica la fase actual
	Uint8 mStageBitmapCounter;				  // Contador para el tiempo visible del texto de Stage
	float mStageBitmapPath[STAGE_COUNTER];	  // Vector con los puntos Y por donde se desplaza el texto
	float mGetReadyBitmapPath[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
	Uint16 mDeathCounter;					  // Contador para la animación de muerte del jugador
	Uint8 mDeathIndex;						  // Indice del vector de smartsprites que contiene el sprite del jugador
	Uint8 mMenaceCurrent;					  // Nivel de amenaza actual
	Uint8 mMenaceThreshold;					  // 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
	bool mTimeStopped;						  // Indica si el tiempo está detenido
	Uint16 mTimeStoppedCounter;				  // Temporizador para llevar la cuenta del tiempo detenido
	Uint8 mRemainingExplosions;				  // Cantidad de explosiones restantes
	Uint16 mRemainingExplosionsCounter;		  // Temporizador para la cantidad de explosiones restantes
	bool mExplosionTime;					  // Indica si las explosiones estan en marcha
	Uint32 mCounter;						  // Contador para el juego
	Uint32 mScoreDataFile[TOTAL_SCORE_DATA];  // Datos del fichero de puntos
	SDL_Rect mGradientRect[4];				  // Vector con las coordenadas de los 4 gradientes
	Uint16 mBalloonsPopped;					  // Lleva la cuenta de los globos explotados
	Uint8 mLastEnemyDeploy;					  // Guarda cual ha sido la última formación desplegada para no repetir;
	Uint8 mEnemyDeployCounter;				  // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
	float mEnemySpeed;						  // Velocidad a la que se mueven los enemigos
	effect_t mEffect;						  // Variable para gestionar los efectos visuales
	helper_t mHelper;						  // Variable para gestionar las ayudas
	bool mPowerBallEnabled;					  // Indica si hay una powerball ya activa
	bool mCoffeeMachineEnabled;				  // Indica si hay una máquina de café en el terreno de juego
	Uint8 mPostFade;						  // Qué hacer al acabar el fade
	float mSin[360];						  // Vector con los valores del seno para 360 grados
	bool mGameCompleted;					  // Indica si se ha completado la partida, llegando al final de la ultima pantalla
	int mGameCompletedCounter;				  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos

	struct demo_t
	{
		bool enabled;						  // Indica si está activo el modo demo
		bool recording;						  // Indica si está activado el modo para grabar la demo
		Uint16 counter;						  // Contador para el modo demo
		demoKeys_t keys;					  // Variable con las pulsaciones de teclas del modo demo
		demoKeys_t dataFile[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la demo
	};
	demo_t mDemo; // Variable con todas las variables relacionadas con el modo demo

	struct debug_t
	{
		bool enabled;			   // Indica si se va a mostrar la información de debug
		Uint8 enemySet;			   // Escoge el set enemigo a generar
		Uint8 gradR, gradG, gradB; // Colores RGB para modificar el color del gradiente de fondo
		float hudW, hudH;		   // Multiplica el tamaño del hud de debug;
	};
	debug_t mDebug;

public:
	// Constructor
	Game(int numPlayers, SDL_Renderer *renderer, std::string *filelist, std::string *textStrings, Input *input1, Input *input2, bool demo);

	// Destructor
	~Game();

	// Inicializa el vector con los valores del seno
	void initSin();

	// Inicializa las variables necesarias para la sección 'Game'
	void init();

	// Carga los recursos necesarios para la sección 'Game'
	bool loadMedia();

	// Carga el fichero de puntos
	bool loadScoreFile();

	// Carga el fichero de datos para la demo
	bool loadDemoFile();

	// Guarda el fichero de puntos
	bool saveScoreFile();

	// Guarda el fichero de datos para la demo
	bool saveDemoFile();

	// Inicializa las formaciones enemigas
	void initEnemyFormations();

	// Inicializa los conjuntos de formaciones
	void initEnemyPools();

	// Inicializa las fases del juego
	void initGameStages();

	// Crea una formación de enemigos
	void deployEnemyFormation();

	// Aumenta el poder de la fase
	void increaseStageCurrentPower(Uint8 power);

	// 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 las variables del jugador
	void updatePlayer();

	// Actualiza las variables de la fase
	void updateStage();

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

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

	// Actualiza los globos
	void updateBalloons();

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

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

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

	// Crea una PowerBall
	void createPowerBall();

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

	// Establece la velocidad de los globos
	void setBalloonSpeed(float speed);

	// Incrementa la velocidad de los globos
	void incBalloonSpeed();

	// Decrementa la velocidad de los globos
	void decBalloonSpeed();

	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
	void updateBalloonSpeed();

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

	// Explosiona un globo. Lo destruye
	void destroyBalloon(Uint8 index);

	// Explosiona todos los globos
	void popAllBalloons();

	// Destruye todos los globos
	void destroyAllBalloons();

	// 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 checkPlayerBalloonCollision(int index);

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

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

	// 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, bool poweredUp, int owner);

	// 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);

	// Dibuja el efecto de flash
	void renderFlashEffect();

	// Actualiza el efecto de agitar la pantalla
	void updateShakeEffect();

	// 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, int index);

	// 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(int index);

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

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

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

	// 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 setTimeStoppedCounter(Uint16 value);

	// Incrementa el valor de la variable
	void incTimeStoppedCounter(Uint16 value);

	// Actualiza la variable EnemyDeployCounter
	void updateEnemyDeployCounter();

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

	// 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 updateRemainingExplosionsCounter();

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

	// 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();

	// 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();

	// Agita la pantalla
	void shakeScreen();

	// Bucle para el juego
	section_t run();

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

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

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

	// Indica si se puede crear una powerball
	bool canPowerBallBeCreated();

	// Calcula el poder actual de los globos en pantalla
	int calculateScreenPower();

	// Inicializa las variables que contienen puntos de ruta para mover objetos
	void initPaths();

	// Actualiza el tramo final de juego, una vez completado
	void updateGameCompleted();

	// Actualiza las variables de ayuda
	void updateHelper();
};

#endif