#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include <SFML/System.hpp>
#include <optional>
#include <random>
#include <cmath>
#include <iostream>
#include <string>
#include <exception>

#define WINDOW_HEIGHT 720
#define WINDOW_WIDTH 1080
#define RACKET_SPEED 10.0
#define BALL_SPEED 0.3

using namespace sf;

enum gameState
{
	inGame,
	inSettings,
	inMenu
};

class Button : public Drawable, Transformable
{
public:
	Button(Vector2f size, Font labelFont) : m_rect(size), m_label(labelFont) {}
	Button(const Button& b) : m_rect(b.m_rect), m_label(b.m_label) {}
	void setLabel(std::string label, Color labelColor = Color::White)
	{
		m_label.setString(label);
		m_label.setFillColor(labelColor);
	}
	void setFillColor(Color rectColor)
	{
		m_rect.setFillColor(rectColor);
	}
	Color getFillColor()
	{
		return m_rect.getFillColor();
	}
	void setPosition(Vector2f position)
	{
		try
		{
			m_rect.setPosition(position);
			const FloatRect textRect = m_label.getGlobalBounds();
			Vector2f scaleFactor(0.6 * m_rect.getSize().x / textRect.size.x, 0.6 * m_rect.getSize().y / textRect.size.y);
			if (scaleFactor.x < 1 or scaleFactor.y < 1)
				m_label.setScale(scaleFactor);
			m_label.setPosition({ position.x + (position.x + m_rect.getSize().x - m_label.getGlobalBounds().size.x) / 2, position.y + (position.y + m_rect.getSize().y - m_label.getGlobalBounds().size.y) / 2 });
		}
		catch(std::exception const& e)
		{
			std::cerr << "ERREUR : " << e.what() << std::endl;
		}
		
	}
	Vector2f getPosition()
	{
		return m_rect.getPosition();
	}
	bool contains(Vector2f point)
	{
		return m_rect.getGlobalBounds().contains(point);
	}

private:
	void draw(sf::RenderTarget& target, sf::RenderStates states) const override
	{
		states.transform *= getTransform();
		target.draw(m_rect, states);
		target.draw(m_label, states);
	}

	RectangleShape m_rect;
	Text m_label;
};

class ButtonArray : public Drawable, Transformable
{
public:
	void addButton(const Button& b)
	{
		array.push_back(b);
	}
	size_t size()
	{
		return array.size();
	}
	Button& operator[](size_t i)
	{
		return array[i];
	}
	const Button& operator[](size_t i) const
	{
		return array[i];
	}
	void pop_back()
	{
		array.pop_back();
	}
	bool empty() const
	{
		return array.empty();
	}
	void removeAll()
	{
		array.clear();
	}
	void setLabelToAll(std::string label, unsigned int size, Color labelColor = Color::White)
	{
		for (Button b : array)
			b.setLabel(label, labelColor);
	}
	void setFillColorToAll(Color rectColor)
	{
		for (Button b : array)
			b.setFillColor(rectColor);
	}

private:
	void draw(sf::RenderTarget& target, sf::RenderStates states) const override
	{
		states.transform *= getTransform();
		for (Button b : array)
			target.draw(b, states);
	}

	std::vector<Button> array;
};

int main()
{
	RenderWindow window(VideoMode({ WINDOW_WIDTH, WINDOW_HEIGHT }), "Pong");

	gameState actState = inMenu;
	Font pfont;
	if (!pfont.openFromFile("arial.ttf"))
	{
		std::cerr << "Load font error !" << std::endl;
		exit(1);
	}

	ButtonArray menuButton;
	menuButton.addButton(Button({ WINDOW_WIDTH / 3, WINDOW_HEIGHT / 5 }, pfont));
	menuButton.addButton(Button({ WINDOW_WIDTH / 3, WINDOW_HEIGHT / 5 }, pfont));
	menuButton[0].setLabel("JOUER");
	menuButton[1].setLabel("PARAMETRES");
	menuButton[0].setFillColor(Color::Green);
	menuButton[1].setFillColor(Color(150, 150, 150));
	menuButton[0].setPosition({ WINDOW_WIDTH * 3, WINDOW_HEIGHT * 5 });
	menuButton[1].setPosition({ WINDOW_WIDTH * 3, 3 * WINDOW_HEIGHT * 5 });

	// Éléments graphiques de jeux
	RectangleShape racket1({ 10, WINDOW_HEIGHT / 15 });
	racket1.setPosition({ WINDOW_WIDTH / 16, WINDOW_HEIGHT / 2 - WINDOW_HEIGHT / 30 });
	racket1.setFillColor(Color::White);
	RectangleShape racket2({ 10, WINDOW_HEIGHT / 15 });
	racket2.setPosition({ 15 * WINDOW_WIDTH / 16, WINDOW_HEIGHT / 2 - WINDOW_HEIGHT / 30 });
	racket2.setFillColor(Color::White);
	RectangleShape ball({ 10, 10 });
	ball.setPosition({ WINDOW_WIDTH / 2 - 5, WINDOW_HEIGHT / 2 - 5 });
	ball.setFillColor(Color::White);

	//Texte affiché en jeu
	unsigned int score1 = 0, score2 = 0;
	Font font;
	if (!font.openFromFile("consola.ttf"))
	{
		std::cerr << "Erreur de chargement de la police." << std::endl;
		exit(1);
	}
	Text textScore1(font), textScore2(font);
	textScore1.setFillColor(Color::White);
	textScore2.setFillColor(Color::White);
	textScore1.setCharacterSize(48);
	textScore2.setCharacterSize(48);
	textScore1.setPosition({ WINDOW_WIDTH / 4 - textScore1.getGlobalBounds().size.x , 20 });
	textScore2.setPosition({ 3 * WINDOW_WIDTH / 4 - textScore1.getGlobalBounds().size.x , 20 });

	//Génération aléatoire de l'angle de la trajectoire de la balle en début de jeu
	Angle ballAngle;
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<> dist(-179, 179);
	do
	{
		ballAngle = degrees(dist(gen));
	} while (ballAngle == degrees(90) or ballAngle == degrees(-90));
	float ballSpeed = BALL_SPEED;

	//Variables relatives à l'affichage du score pendant le jeu
	bool scoreMoment = true;
	Time scoreTime(Time::Zero);
	Time elapsed(Time::Zero);
	Clock gameClock;

	while (window.isOpen())
	{
		while (std::optional event = window.pollEvent())
		{
			if (event->is<Event::Closed>())
				window.close();
			if (actState == inMenu)
			{

				if (const auto* m = event->getIf<Event::MouseButtonReleased>())
				{
					Vector2f point;
					point.x = m->position.x;
					point.y = m->position.y;
					for (size_t i = 0; i < menuButton.size(); i++)
					{
						if (menuButton[i].contains(point))
						{
							if (i == 0)
								actState = inGame;
							else if (i == 1)
								actState = inSettings;
						}
					}
				}
			}
			else if (!scoreMoment and actState == inGame)
			{
				if (Keyboard::isKeyPressed(Keyboard::Scan::W))
					racket1.move({ 0, -RACKET_SPEED });
				else if (Keyboard::isKeyPressed(Keyboard::Scan::S))
					racket1.move({ 0, RACKET_SPEED });
				if (Keyboard::isKeyPressed(Keyboard::Scan::Up))
					racket2.move({ 0, -RACKET_SPEED });
				else if (Keyboard::isKeyPressed(Keyboard::Scan::Down))
					racket2.move({ 0, RACKET_SPEED });
			}
		}

		window.clear(Color::Black);

		if (actState == inMenu)
			window.draw(menuButton);
		else if (actState == inGame)
		{
			window.draw(racket1);
			window.draw(racket2);
			window.draw(ball);

			if (scoreMoment)
			{
				std::string sscore1, sscore2;
				std::ostringstream flux1, flux2;
				flux1 << score1;
				flux2 << score2;
				sscore1 = flux1.str();
				sscore2 = flux2.str();
				textScore1.setString(sscore1);
				textScore2.setString(sscore2);
				window.draw(textScore1);
				window.draw(textScore2);
				scoreTime = gameClock.getElapsedTime() - elapsed;

				do
				{
					ballAngle = degrees(dist(gen));
				} while (ballAngle == degrees(90) or ballAngle == degrees(-90));
				ballSpeed = BALL_SPEED;

				if (scoreTime >= seconds(2))
					scoreMoment = false;
			}
			else
				ball.move({ ballSpeed * std::cos(ballAngle.asRadians()), -ballSpeed * std::sin(ballAngle.asRadians()) });

			std::optional<FloatRect> intersec1 = ball.getGlobalBounds().findIntersection(racket1.getGlobalBounds());
			std::optional<FloatRect> intersec2 = ball.getGlobalBounds().findIntersection(racket2.getGlobalBounds());
			if (ball.getPosition().y <= 0 or ball.getPosition().y >= WINDOW_HEIGHT - ball.getSize().y)
			{
				ballAngle = -ballAngle;
				ballSpeed *= 1.1;
			}
			else if (intersec1.has_value() or intersec2.has_value())
			{
				ballAngle = degrees(180) - ballAngle;
				ballSpeed *= 1.1;
			}
			else if (ball.getPosition().x <= 0)
			{
				score2++;
				ball.setPosition({ WINDOW_WIDTH / 2 - 5, WINDOW_HEIGHT / 2 - 5 });
				ballSpeed = 0;
				scoreMoment = true;
				elapsed = gameClock.getElapsedTime();
			}
			else if (ball.getPosition().x >= WINDOW_WIDTH)
			{
				score1++;
				ball.setPosition({ WINDOW_WIDTH / 2 - 5, WINDOW_HEIGHT / 2 - 5 });
				ballSpeed = 0;
				scoreMoment = true;
				elapsed = gameClock.getElapsedTime();
			}
		}

		window.display();
	}

	return 0;
}