#pragma once
#include "Component.h"
#include "IStateController.h"

class ISoundSystem;

namespace dae
{
	enum FacingDirection : unsigned
	{
		RIGHT,
		LEFT
	};

	class AnimatedTextureComponent;
	class ColliderComponent;
	class RigidbodyComponent;
	class LevelComponent;
	class PlayerComponent : public Component, public IStateController<PlayerComponent>
	{
	public:
		PlayerComponent(float startX, float startY, int spriteId, int lives);
		~PlayerComponent();

		void Update(float deltaTime) override;
		void FixedUpdate(float deltaTime) override;
		void Render() const override {};

		void Initialize() override;
		void Reset();

		void RegisterLevel(LevelComponent* pLevelComponent);
		void RegisterEnemyColliders(const std::vector<ColliderComponent*>& enemyColliders);

		void ChangeDirection(float dirX, float dirY);
		FacingDirection GetDirection() const { return m_Direction; }

		const std::vector<ColliderComponent*>& GetEnemyColliders() { return m_EnemyColliders; }
		LevelComponent* GetLevelComponent() { return m_pLevelComponent; }

		void SetCurrentXSpeed(float xSpeed) { m_CurrentXSpeed = xSpeed; }
		float GetCurrentXSpeed() { return m_CurrentXSpeed;}

		void SetCurrentYSpeed(float ySpeed) { m_CurrentYSpeed = ySpeed; }
		float GetCurrentYSpeed() { return m_CurrentYSpeed; }

		float GetMoveSpeed() { return m_MoveSpeed; }
		float GetJumpSpeed() { return m_JumpSpeed; }

		ISoundSystem* GetSoundSystem() { return m_pSoundSystem;	}

		void SetIsGrounded(bool isGrounded) { m_IsGrounded = isGrounded; }
		bool GetIsGrounded() { return m_IsGrounded; }

		float GetShootDuration() { return m_ShootDuration; }
		void SetShootTimer(float value) { m_ShootTimer = value; }
		float GetShootTimer() { return m_ShootTimer; }

		ColliderComponent* GetCollider();

		void SpawnBubble();
		bool TryRespawn();

		bool IsCollidingWithEnemies();

		void Move(float dirX, float dirY);
		int GetLives() const { return m_Lives; }
		void DecrementLives() { m_Lives--; }
		int GetSpriteId() const { return m_SpriteId; }

		AnimatedTextureComponent* GetAnimComp()
		{
			return m_pAnimTexComp;
		}

		void ShootBubble();
		void HandleMovement(float deltaTime);

		friend class PlayerFrozenState;
		friend class PlayerInBubbleState;
		friend class PlayerIdleState;
		friend class PlayerRunningState;
		friend class PlayerJumpingState;
		friend class PlayerFallingState;
		friend class PlayerShootingBubbleState;
		friend class PlayerDeadState;

	private:

		AnimatedTextureComponent* m_pAnimTexComp{ nullptr };
		RigidbodyComponent* m_pRigidBodyComponent{ nullptr };

		LevelComponent* m_pLevelComponent{ nullptr };
		std::vector<ColliderComponent*> m_EnemyColliders;
		
		float m_ShootTimer{ 0 };
		float m_ShootDuration{ 1 / 3.f };
		int m_Lives{};
		int m_MaxLives{};
		int m_SpriteId;

		float m_StartX;
		float m_StartY;

		float m_CurrentXSpeed{};
		float m_CurrentYSpeed{};

		const float m_MoveSpeed{ 150.f };
		const float m_MoveSpeedFalling{ 75.f };

		const float m_JumpSpeed{ 300.f };
		const float m_AirDecelerationSpeed{ 525.f };
		const float m_MaxFallSpeed{ 300.f };

		FacingDirection m_Direction{ FacingDirection::RIGHT };

		int m_SpriteOffset{ 16 };
		bool m_IsGrounded{ true };

		ISoundSystem* m_pSoundSystem{ nullptr };
	};
}