#ifndef _H_WEAPON_H
#define _H_WEAPON_H

#include <memory>
#include <glm/glm.hpp>
#include <functional>

#include "util.h"

#include "gameplay/entity.h"
#include "gameplay/weapons/bullet.h"
#include "utility/direction.h"

// TODO: Put all weapons inside of this base, we don't need a class for every weapon, we only need one class!

class Shader;
class Component;
class Camera;
class BulletManager;
class EventManager;
class ResourceManager;
class GameActor;
class WeaponScript;
struct PhysicsComponent;
struct WeaponData;

class Weapon : public Entity, public std::enable_shared_from_this<Weapon>
{
public:
	Weapon(std::shared_ptr<WeaponData> data, const std::shared_ptr<Shader>& weaponShader, const std::shared_ptr<Shader>& bulletShader, ResourceManager* resourceManager);

	void setWielder(const std::shared_ptr<GameActor>& wielder) { this->wielder = wielder; }
	void toggleInfiniteAmmo() { infiniteAmmo = !infiniteAmmo; }
	void wield() { wielded = true; }
	void putaway() { wielded = false; }

	void addComponent(const std::shared_ptr<Component>& component);
	void attachScript(const std::shared_ptr<WeaponScript>& script);
	void hookEventManager(const std::shared_ptr<EventManager>& eventManager);
	void shoot();
	void reload();
	void update(double deltaTime);
	void render(const std::shared_ptr<Camera>& camera);

	struct BulletData {
		glm::vec3 origin;
		glm::vec2 direction;
		float mass		= 1.f;
		float sizeMod	= 1.f;
		float speedMod	= 1.f;
		float dropMod	= 1.f;
	};
	void onHitCallback(std::shared_ptr<GameActor> target, std::shared_ptr<PhysicsComponent> bullet, const glm::vec2& normal);

	glm::vec2					getWeaponSize()		const { return weaponSize; }
	// This is the offset from the center right point of the weapon to the barrel of the gun defined in 
	// the XML file for the weapon
	glm::vec2					getWeaponOffset()	const { return weaponOffset; }
	float						getBulletSpeed()	const { return bulletSpeed; }
	glm::vec2					getBulletSize()		const { return bulletSize; }
	std::shared_ptr<GameActor>	getWielder()		const { return wielder; }
	const Uint32				getMagazine()		const { return weaponMag; }
	const Uint32				getAmmo()			const { return weaponAmmo; }

	Weapon::BulletData			genBulletData	();
	void						createBullet	(const BulletData& data);

private:
	void adjustWeapon();

	glm::vec2 weaponSize;
	glm::vec2 weaponOffset;
	// TODO: Add reloading
	// weaponMag will be unused for now, but we will do a reload animation and reload the weapon eventually
	Uint16 weaponMag, weaponMagSize, weaponAmmo;
	bool reloading = false;
	bool wasReloading = false;
	bool infiniteAmmo = false;

	float bulletSpeed;
	float bulletDrop;
	// in ms
	float fireSpeed;
	glm::vec2 bulletSize;
	std::shared_ptr<Shader> bulletShader;
	std::shared_ptr<Component> bulletSprite;
	std::shared_ptr<BulletManager> bulletManager;
	std::shared_ptr<EventManager> eventManager;

	std::shared_ptr<UTIL::RandomGenerator> bulletSpread;
	std::shared_ptr<UTIL::RandomGenerator> bulletModifer;

	std::shared_ptr<GameActor> wielder;
	// is the weapon currently active
	bool wielded = false;
	int lastFireTime = 0;

	Direction lastDir;

	std::vector <std::shared_ptr<Component>> components;
	std::shared_ptr<WeaponScript> weaponScript;
	
};

#endif // _H_WEAPON_H