#ifndef PLAYER_HPP
#define PLAYER_HPP

#include <SFML/Graphics/CircleShape.hpp>
#include <SFML/Graphics/Color.hpp>
#include <SFML/Graphics/RectangleShape.hpp>
#include <SFML/System/Vector2.hpp>
#include <memory>

#include "data.hpp"
#include "globals.hpp"
#include "scheduler.hpp"

enum class CollisionDir
{
	None,
	Left,
	Right,
	Top,
	Bottom
};
class Entity;
class Object;
class Player;

class Object
{
       public:
	Object(ObjectData data);
	CollisionDir find_intersection(Object& entity);
	float find_horizontal_difference_from_interesection(Object& entity);
	sf::RectangleShape rect;
};

class Entity : public Object
{
       public:
	Entity(EntityData data) : Object(data), _velocity(data.velocity) {};
	void set_velocity(sf::Vector2f velocity);
	void set_velocity_x(int velocity);
	void set_velocity_y(int velocity);
	sf::Vector2<float> get_velocity();

       protected:
	sf::Vector2f _velocity;
};

class Player : public Entity
{
       public:
	Player(PlayerData data, float gravity)
	    : Entity(data),
	      max_dash_acceleration(data.max_vertical_acceleration),
	      max_vertical_acceleration(data.max_vertical_acceleration),
	      gravity(gravity), _min_velocity(data.velocity) {};
	float max_vertical_acceleration;
	float max_dash_acceleration;
	float gravity;
	bool m_jumping { false };
	std::unique_ptr<Object> bounding_box;
	void initialize_bounding_box();
	void update_bounding_box();
	int check_bounding_box(
	    std::array<std::array<std::unique_ptr<Object>, MAX_COLS>, MAX_ROWS>& tilemap);
	void handle_movment(Timer& dash);
	void handle_gravity();
	bool get_jumping();
	void horizontal_no_out_of_bounds();
	void vertical_no_out_of_bounds(Entity& base);
	bool get_horizontal_collision(
	    std::array<std::array<std::unique_ptr<Object>, MAX_COLS>, MAX_ROWS>& tilemap);
	bool get_vertical_top_collision(
	    std::array<std::array<std::unique_ptr<Object>, MAX_COLS>, MAX_ROWS>& tilemap);
	bool get_vertical_bottom_collision(
	    std::array<std::array<std::unique_ptr<Object>, MAX_COLS>, MAX_ROWS>& tilemap);

       private:
	sf::Vector2f _min_velocity { 0, 0 };
	std::string direction;
};

float
total_distance(int k);

float
distance_to_acceleration(int target);

#endif