#define OLC_PGE_APPLICATION
#include "olcPixelGameEngine.h"
#include "olcUTIL_Camera2D.h"
#define OLC_PGEX_TRANSFORMEDVIEW
#include "olcPGEX_TransformedView.h"
#include "olcUTIL_Animate2D.h"
#include "Monster.h"
#include "Animation.h"

//192x192
const vi2d WINDOW_SIZE={24*8,24*8};

extern std::map<MonsterName,MonsterData>MONSTER_DATA;
std::map<AnimationState,Animate2D::FrameSequence>ANIMATION_DATA;
std::vector<Monster>MONSTER_LIST;
std::vector<MonsterSpawner>SPAWNER_LIST;

struct Player{
	private:
	int hp=100,maxhp=hp;
	int atk=10;
	vf2d pos;
	float moveSpd=1.0f;
	float size=1.0f;
	float attack_range=1.5f;
	Animate2D::Animation<AnimationState>animation;
	Animate2D::AnimationState internal_animState;
	Key lastReleasedMovementKey;
	public:
	Player(){};
	Player(vf2d pos):
		pos(pos){
	};
	void SetX(float x){
		pos.x=x;
	};
	void SetY(float y){
		pos.y=y;
	}
	void SetPos(vf2d pos){
		this->pos=pos;
	}
	vf2d&GetPos(){
		return pos;
	}
	float GetX(){
		return pos.x;
	}
	float GetY(){
		return pos.y;
	}
	int GetHealth(){
		return hp;
	}
	int GetMaxHealth(){
		return maxhp;
	}
	int GetAttack(){
		return atk;
	}
	float GetMoveSpdMult(){
		return moveSpd;
	}
	float GetSizeMult(){
		return size;
	}
	float GetAttackRangeMult(){
		return attack_range;
	}

	void Update(float fElapsedTime){
		animation.UpdateState(internal_animState,fElapsedTime);
	}
	void AddAnimation(AnimationState state){
		animation.AddState(state,ANIMATION_DATA[state]);
	};
	void UpdateAnimation(AnimationState animState){
		animation.ChangeState(internal_animState,animState);
	}

	Animate2D::Frame GetFrame(){
		return animation.GetFrame(internal_animState);
	}

	void SetLastReleasedMovementKey(Key k){
		lastReleasedMovementKey=k;
	}
	Key GetLastReleasedMovementKey(){
		return lastReleasedMovementKey;
	}

	//Triggers when the player has moved.
	void Moved(){
		for(MonsterSpawner&spawner:SPAWNER_LIST){
			if(!spawner.SpawnTriggered()&&geom2d::overlaps(geom2d::circle<float>(pos,size*12),geom2d::circle<float>(spawner.GetPos(),spawner.GetRange()))){
				spawner.SetTriggered(true);
			}
		}
	}
};

class Crawler : public olc::PixelGameEngine
{
	const vi2d WORLD_SIZE={64,8};
	Camera2D camera;
	TileTransformedView view;
	Player player=Player{{}};
	Renderable GFX_Pl_Sheet,GFX_Slime_Sheet;

public:
	Crawler()
	{
		sAppName = "Crawler Concept";
	}

public:
	bool OnUserCreate() override
	{
		//Initialize Camera.
		camera=Camera2D{WINDOW_SIZE};
		camera.SetMode(olc::utils::Camera2D::Mode::LazyFollow);
		camera.SetTarget(player.GetPos());
		camera.SetWorldBoundary({0,0},WORLD_SIZE*24);
		camera.EnableWorldBoundary(true);

		//Graphics
		GFX_Pl_Sheet.Load("assets/nico-warrior.png");
		GFX_Slime_Sheet.Load("assets/slime.png");

		//Animations
		InitializeAnimations();

		player.AddAnimation(AnimationState::WALK_N);
		player.AddAnimation(AnimationState::WALK_E);
		player.AddAnimation(AnimationState::WALK_S);
		player.AddAnimation(AnimationState::WALK_W);
		player.AddAnimation(AnimationState::IDLE_N);
		player.AddAnimation(AnimationState::IDLE_E);
		player.AddAnimation(AnimationState::IDLE_S);
		player.AddAnimation(AnimationState::IDLE_W);
		view=TileTransformedView{GetScreenSize(),{1,1}};

		player.SetPos({4*24,4*24});
		player.UpdateAnimation(AnimationState::IDLE_S);

		SPAWNER_LIST.push_back(MonsterSpawner({336,96},4*24,{{{MonsterName::SLIME_GREEN,{-32,-40}},{MonsterName::SLIME_GREEN,{64,20}}}}));
		
		return true;
	}

	bool OnUserUpdate(float fElapsedTime) override
	{
		HandleUserInput(fElapsedTime);
		player.Update(fElapsedTime);
		for(Monster&m:MONSTER_LIST){
			m.Update(fElapsedTime);
		}
		UpdateCamera(fElapsedTime);
		RenderWorld();
		return true;
	}
	
	void InitializeAnimations(){
		Animate2D::FrameSequence pl_walk_s{0.2};
		pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{0,0}*24,{24,24}}});
		pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{1,0}*24,{24,24}}});
		pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{0,0}*24,{24,24}}});
		pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{2,0}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::WALK_S]=pl_walk_s;
		Animate2D::FrameSequence pl_walk_e{0.2};
		pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{0,3}*24,{24,24}}});
		pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{1,3}*24,{24,24}}});
		pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{0,3}*24,{24,24}}});
		pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{2,3}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::WALK_E]=pl_walk_e;
		Animate2D::FrameSequence pl_walk_w{0.2};
		pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{0,2}*24,{24,24}}});
		pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{1,2}*24,{24,24}}});
		pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{0,2}*24,{24,24}}});
		pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{2,2}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::WALK_W]=pl_walk_w;
		Animate2D::FrameSequence pl_walk_n{0.2};
		pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{0,1}*24,{24,24}}});
		pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{1,1}*24,{24,24}}});
		pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{0,1}*24,{24,24}}});
		pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{2,1}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::WALK_N]=pl_walk_n;
		Animate2D::FrameSequence pl_idle_s;
		pl_idle_s.AddFrame({&GFX_Pl_Sheet,{vi2d{0,0}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::IDLE_S]=pl_idle_s;
		Animate2D::FrameSequence pl_idle_e;
		pl_idle_e.AddFrame({&GFX_Pl_Sheet,{vi2d{0,3}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::IDLE_E]=pl_idle_e;
		Animate2D::FrameSequence pl_idle_w;
		pl_idle_w.AddFrame({&GFX_Pl_Sheet,{vi2d{0,2}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::IDLE_W]=pl_idle_w;
		Animate2D::FrameSequence pl_idle_n;
		pl_idle_n.AddFrame({&GFX_Pl_Sheet,{vi2d{0,1}*24,{24,24}}});
		ANIMATION_DATA[AnimationState::IDLE_N]=pl_idle_n;
		for(int slime=0;slime<4;slime++){
			for(int state=0;state<5;state++){
				Animate2D::FrameSequence anim;
				for (int frame=0;frame<10;frame++){
					anim.AddFrame({&GFX_Slime_Sheet,{vi2d{frame,state+5*slime}*24,{24,24}}});
				}
				ANIMATION_DATA[AnimationState(AnimationState::GREEN_SLIME_IDLE+state+slime*5)]=anim;
			}
		}
	}

	void HandleUserInput(float fElapsedTime){
		bool setIdleAnimation=true;
		if(GetKey(RIGHT).bHeld){
			if(player.GetPos().x+12+fElapsedTime*100*player.GetMoveSpdMult()<WORLD_SIZE.x*24){
				player.SetX(player.GetX()+fElapsedTime*100*player.GetMoveSpdMult());
			} else {
				player.SetX(WORLD_SIZE.x*24-12);
			}
			player.UpdateAnimation(AnimationState::WALK_E);
			setIdleAnimation=false;
		}
		if(GetKey(LEFT).bHeld){
			if(player.GetPos().x-12+fElapsedTime*100*player.GetMoveSpdMult()>0){
				player.SetX(player.GetX()-fElapsedTime*100*player.GetMoveSpdMult());
			} else {
				player.SetX(12);
			}
			if(setIdleAnimation){
				player.UpdateAnimation(AnimationState::WALK_W);
			}
			setIdleAnimation=false;
		}
		if(GetKey(UP).bHeld){
			if(player.GetPos().y-12+fElapsedTime*100*player.GetMoveSpdMult()>0){
				player.SetY(player.GetY()-fElapsedTime*100*player.GetMoveSpdMult());
			} else {
				player.SetY(12);
			}
			if(setIdleAnimation){
				player.UpdateAnimation(AnimationState::WALK_N);
			}
			setIdleAnimation=false;
		}
		if(GetKey(DOWN).bHeld){
			if(player.GetPos().y+12+fElapsedTime*100*player.GetMoveSpdMult()<WORLD_SIZE.y*24){
				player.SetY(player.GetY()+fElapsedTime*100*player.GetMoveSpdMult());
			} else {
				player.SetY(WORLD_SIZE.y*24-12);
			}
			if(setIdleAnimation){
				player.UpdateAnimation(AnimationState::WALK_S);
			}
			setIdleAnimation=false;
		}

		if(GetKey(UP).bReleased){
			player.SetLastReleasedMovementKey(UP);
			if(GetKey(RIGHT).bHeld){
				player.UpdateAnimation(AnimationState::WALK_E);
			} else
			if(GetKey(DOWN).bHeld){
				player.UpdateAnimation(AnimationState::WALK_S);
			} else
			if(GetKey(LEFT).bHeld){
				player.UpdateAnimation(AnimationState::WALK_W);
			}
		}
		if(GetKey(RIGHT).bReleased){
			player.SetLastReleasedMovementKey(RIGHT);
			if(GetKey(UP).bHeld){
				player.UpdateAnimation(AnimationState::WALK_N);
			} else
			if(GetKey(DOWN).bHeld){
				player.UpdateAnimation(AnimationState::WALK_S);
			} else
			if(GetKey(LEFT).bHeld){
				player.UpdateAnimation(AnimationState::WALK_W);
			}
		}
		if(GetKey(LEFT).bReleased){
			player.SetLastReleasedMovementKey(LEFT);
			if(GetKey(RIGHT).bHeld){
				player.UpdateAnimation(AnimationState::WALK_E);
			} else
			if(GetKey(DOWN).bHeld){
				player.UpdateAnimation(AnimationState::WALK_S);
			} else
			if(GetKey(UP).bHeld){
				player.UpdateAnimation(AnimationState::WALK_N);
			}
		}
		if(GetKey(DOWN).bReleased){
			player.SetLastReleasedMovementKey(DOWN);
			if(GetKey(RIGHT).bHeld){
				player.UpdateAnimation(AnimationState::WALK_E);
			} else
			if(GetKey(UP).bHeld){
				player.UpdateAnimation(AnimationState::WALK_N);
			} else
			if(GetKey(LEFT).bHeld){
				player.UpdateAnimation(AnimationState::WALK_W);
			}
		}

		if(setIdleAnimation){
			switch(player.GetLastReleasedMovementKey()){
				case UP:{
					player.UpdateAnimation(AnimationState::IDLE_N);
				}break;
				case DOWN:{
					player.UpdateAnimation(AnimationState::IDLE_S);
				}break;
				case LEFT:{
					player.UpdateAnimation(AnimationState::IDLE_W);
				}break;
				case RIGHT:{
					player.UpdateAnimation(AnimationState::IDLE_E);
				}break;
				default:{
					player.UpdateAnimation(AnimationState::IDLE_S);
				}
			}
		} else {
			//We have moved.
			player.Moved();
		}
	}

	void UpdateCamera(float fElapsedTime){
		camera.Update(fElapsedTime);
		view.SetWorldOffset(vi2d(camera.GetViewPosition()));
	}

	void RenderWorld(){
		Clear({100,180,100});
		for (int x = view.GetTopLeftTile().x/24-1; x <= view.GetBottomRightTile().x/24; x++){
			for (int y = view.GetTopLeftTile().y/24-1; y <= view.GetBottomRightTile().y/24; y++){
				view.DrawRect(vi2d{x,y}*24,{24,24},VERY_DARK_GREY);
			}
		}
		view.DrawPartialDecal(player.GetPos()-vi2d{12,12}*player.GetSizeMult(),player.GetFrame().GetSourceImage()->Decal(),player.GetFrame().GetSourceRect().pos,player.GetFrame().GetSourceRect().size,vf2d(player.GetSizeMult(),player.GetSizeMult()));
		for(Monster&m:MONSTER_LIST){
			view.DrawPartialDecal(m.GetPos()-vi2d{12,12}*m.GetSizeMult(),m.GetFrame().GetSourceImage()->Decal(),m.GetFrame().GetSourceRect().pos,m.GetFrame().GetSourceRect().size,vf2d(m.GetSizeMult(),m.GetSizeMult()));
		}
	}
};


int main()
{
	Crawler demo;
	if (demo.Construct(WINDOW_SIZE.x, WINDOW_SIZE.y, 4, 4))
		demo.Start();

	return 0;
}