#pragma once

#include "olcPixelGameEngine.h"
#include "olcPGEX_TransformedView.h"
#include "Constant.h"
#include "Image.h"

struct Marker{
	size_t index;
	size_t size;
};

enum MemoryType{
	HEALTH,
	RANGE,
	ATKSPD,
	MOVESPD,
	PROCEDURE
};

struct Memory{
	MemoryType type;
	int size;
};

struct Unit{
public:
	Unit(std::vector<Memory>memory,vf2d pos,Renderable&img,bool friendly=false,bool moveable=true);
	int GetHealth();
	int GetRange();
	int GetAtkSpd();
	int GetMoveSpd();
	int GetProcedure();
	int GetMemorySize();
	std::vector<bool>memory;
	std::vector<bool>ghostMemory;
	virtual void Update(PixelGameEngine*pge);
	virtual void Attack(Unit&victim)=0;
	virtual void Draw(TileTransformedView&game,std::map<Image,std::unique_ptr<Renderable>>&IMAGES);
	virtual void DrawHud(TileTransformedView&game,std::map<Image,std::unique_ptr<Renderable>>&IMAGES);
	bool IsFriendly();
	bool IsSelected();
	void Select();
	void Deselect();
	vf2d GetPos();
	bool IsDead();
	vf2d GetUnitSize();
	void SetTargetUnit(std::weak_ptr<Unit>target);
	void SetTargetLocation(vf2d targetLoc);
	void SetPos(vf2d newPos);
	void AttemptAttack(Unit*unit);
	bool InFogOfWar();
	bool GhostInFogOfWar();
	void HideGhost();
	vf2d GetGhostPos();
	void _Update(PixelGameEngine*pge);
	bool IsMoveable();

	std::vector<bool>& operator <<=(const int n){
		for(int i=0;i<GetMemorySize()-1;i++){
			memory[i]=memory[i+1];
		}
		memory[GetMemorySize()-1]=0;
		if(!InFogOfWar()){
			ghostMemory=memory;
		}
		return memory;
	}

	std::vector<bool>& operator >>=(const int n){
		for(int i=GetMemorySize()-1;i>0;i--){
			memory[i]=memory[i-1];
		}
		memory[0]=0;
		if(!InFogOfWar()){
			ghostMemory=memory;
		}
		return memory;
	}
protected:
	bool friendly;
	Renderable&img;
	Marker health;
	Marker range;
	Marker atkSpd;
	Marker moveSpd;
	Marker procedure;
	std::weak_ptr<Unit>target;
	vf2d targetLoc=CONSTANT::UNSELECTED;
private:
	vf2d pos;
	vf2d ghostPos;
	int GetBits(Marker&m);
	bool selected=false;
	bool dead=false;
	bool InRange(std::shared_ptr<Unit>target);
	bool InRange(vf2d pos);
	float reloadTimer=0;
	void _Attack(Unit*finalTarget);
	vf2d movementVel={0,0};
	float changeDirTimer=0;
	bool moveable=true;
};

struct BasicUnit:Unit{
	BasicUnit(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct BasicUnit2:Unit{
	BasicUnit2(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct LeftShifter:Unit{
	LeftShifter(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct RightShifter:Unit{
	RightShifter(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct BitRestorer:Unit{
	BitRestorer(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct MemorySwapper:Unit{
	MemorySwapper(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct Corrupter:Unit{
	Corrupter(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct MemoryAllocator:Unit{
	MemoryAllocator(vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false,bool moveable=true);
	void Attack(Unit&victim)override;
};

struct RAMBank:Unit{
	vf2d randomOffset;
	Renderable img;
	Renderable&originalImg;
	Renderable&matrixImg;
	RAMBank(PixelGameEngine*pge,vf2d pos,std::map<Image,std::unique_ptr<Renderable>>&IMAGES,bool friendly=false);
	void Update(PixelGameEngine*pge)override;
	void Attack(Unit&victim)override;
	void Draw(TileTransformedView&game,std::map<Image,std::unique_ptr<Renderable>>&IMAGES)override;
};