/*
License (OLC-3)
~~~~~~~~~~~~~~~

Copyright 2018 - 2023 OneLoneCoder.com

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions or derivations of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

2. Redistributions or derivative works in binary form must reproduce the above
copyright notice. This list of conditions and the following	disclaimer must be
reproduced in the documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors may
be used to endorse or promote products derived from this software without specific
prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
*/
#pragma once
#include "olcPixelGameEngine.h"
#include "Animation.h"
#include "State.h"
#include "Buff.h"
#include "olcUTIL_Animate2D.h"
#include "DamageNumber.h"
#include "DEFINES.h"
#include "Attributable.h"

struct Player;
class Crawler;

enum class Attribute;

enum MonsterAnimation{
	IDLE,
	JUMP,
	SHOOT,
	DEATH
};

struct MonsterData{
	private:
	int id;
	std::string name;
	int hp;
	int atk;
	float moveSpd;//1.0=100%
	float size;
	std::vector<std::string> animations;
	int strategy;
	int collisionDmg;
	std::string jumpAnimation="WARRIOR_IDLE_S";
	std::string shootAnimation="WARRIOR_IDLE_S";
	std::string deathAnimation="WARRIOR_IDLE_S";
	public:
	MonsterData();
	MonsterData(int id,std::string name,int hp,int atk,std::vector<std::string>animations,float moveSpd=1.0f,float size=1.0f,int strategy=0,int collisionDmg=0);
	int GetHealth();
	int GetAttack();
	float GetMoveSpdMult();
	float GetSizeMult();
	int GetAIStrategy();
	int GetCollisionDmg();
	int GetID();
	std::string GetIdleAnimation();
	std::string GetJumpAnimation();
	std::string GetShootAnimation();
	std::string GetDeathAnimation();
	std::vector<std::string>GetAnimations(){
		return animations;
	}
	std::string GetDisplayName();
	static void InitializeMonsterData();
	static std::map<int,Renderable*>imgs;
};


struct Monster:IAttributable{
	friend struct STRATEGY;
private:
	int id=0;
	vf2d pos;
	vf2d vel={0,0};
	float friction=400;
	vf2d target={0,0};
	float targetAcquireTimer=0;
	int hp,maxhp;
	int atk;
	float moveSpd;
	float size;
	float attackCooldownTimer=0;
	float queueShotTimer=0;
	float z=0;
	float iframe_timer=0;
	Key facingDirection;
	int strategy;
	State::State state=State::NORMAL;
	Animate2D::Animation<std::string>animation;
	Animate2D::AnimationState internal_animState;
	float randomFrameOffset=0.f;
	float deathTimer=0.f;
	std::vector<Buff>buffList;
	std::string GetDeathAnimationName();
	bool hasHitPlayer=false;
	bool canMove=true; //Set to false when stuck due to collisions.
	bool upperLevel=false;
	vf2d pathTarget={};
	std::vector<vf2d>path;
	int pathIndex=0;
	float lastHitTimer=0;
	std::shared_ptr<DamageNumber>damageNumberPtr;
	int phase=0;
	bool diesNormally=true; //If set to false, the monster death is handled in a special way. Set it to true when it's time to die.
	float targetSize=0;
	bool isBoss=false;
protected:
public:
	Monster()=delete;
	Monster(vf2d pos,MonsterData data,bool upperLevel=false,bool bossMob=false);
	vf2d&GetPos();
	int GetHealth();
	int GetAttack();
	float GetMoveSpdMult();
	float GetSizeMult();
	Animate2D::Frame GetFrame();
	void UpdateAnimation(std::string state);
	bool Update(float fElapsedTime);
	//Returns true when damage is actually dealt. Provide whether or not the attack is on the upper level or not. Monsters must be on the same level to get hit by it. (there is a death check and level check here.)
	//If you need to hurt multiple enemies try Crawler::HurtEnemies()
	bool Hurt(int damage,bool onUpperLevel,float z);
	bool IsAlive();
	vf2d&GetTargetPos();
	Key GetFacingDirection();
	void Draw();
	void DrawReflection(float drawRatioX,float multiplierX);
	void Collision(Player*p);
	void Collision(Monster&p);
	void Collision();
	void SetVelocity(vf2d vel);
	//Returns false if the monster could not be moved to the requested location due to collision.
	bool SetPos(vf2d pos);
	//Returns false if the monster could not be moved to the requested location due to collision.
	bool SetX(float x);
	//Returns false if the monster could not be moved to the requested location due to collision.
	bool SetY(float y);
	void PerformJumpAnimation();
	void PerformShootAnimation();
	void PerformIdleAnimation();
	bool OnUpperLevel();
	void Moved();
	void StartPathfinding(float pathingTime);
	void PathAroundBehavior(float fElapsedTime);
	void AddBuff(BuffType type,float duration,float intensity);
	std::vector<Buff>GetBuffs(BuffType buff);
	State::State GetState();
	void SetState(State::State newState);
	static void InitializeStrategies();
	bool HasIframes();
	float GetZ();
	void SetZ(float z);
	std::string GetStrategy();
	void SetSize(float newSize,bool immediate=true);
	void SetStrategyDrawFunction(std::function<void(Crawler*)>func);
	std::function<void(Crawler*)>strategyDraw=[](Crawler*pge){};
private:
	struct STRATEGY{
		static int _GetInt(Monster&m,std::string param,int strategyNumber,int index=0);
		static float _GetFloat(Monster&m,std::string param,int strategyNumber,int index=0);
		static std::string _GetString(Monster&m,std::string param,int strategyNumber,int index=0);
		static void RUN_STRATEGY(Monster&m,float fElapsedTime);
		static void RUN_TOWARDS(Monster&m,float fElapsedTime,int strategyNumber);
		static void SHOOT_AFAR(Monster&m,float fElapsedTime,int strategyNumber);
		static void TURRET(Monster&m,float fElapsedTime,int strategyNumber);
		static void SLIMEKING(Monster&m,float fElapsedTime,int strategyNumber);
		static void RUN_AWAY(Monster&m,float fElapsedTime,int strategyNumber);
	};
};

struct MonsterSpawner{
	private:
	vf2d pos;
	vf2d range;
	std::vector<std::pair<int,vf2d>>monsters;
	bool triggered=false;
	bool upperLevel=false;
	std::string bossNameDisplay="";
	public:
	MonsterSpawner();
	//For the monster list, the second pair item is the position relative to the spawner to spawn the monster.
	MonsterSpawner(vf2d pos,vf2d range,std::vector<std::pair<int,vf2d>>MONSTER_LIST,bool upperLevel=false,std::string bossNameDisplay="");
	bool SpawnTriggered();
	vf2d GetRange();
	vf2d GetPos();
	bool DoesUpperLevelSpawning();
	void SetTriggered(bool trigger,bool spawnMonsters=true);
	friend std::ostream&operator<<(std::ostream&os,MonsterSpawner&rhs);
};