#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include <SFML/System.hpp>
#include <list>
#include <math.h>
#include <iostream>

// Pi
#define PI 3.1415926535f

using namespace std;

// Structures
struct sPoint
{
	float x = 0;
	float y = 0;
};
struct sSpline
{
	std::vector<sPoint> points;
	std::vector<sf::Sprite*> sprites;

	sPoint getSplinePoint(float t)
	{
		sPoint p;

		int p0, p1, p2, p3;
		p1 = (int)t + 1;
		p2 = p1 + 1;
		p3 = p2 + 1;
		p0 = p1 - 1;

		float tt = t * t;
		float ttt = tt * t;

		float q1 = -ttt + 2.0f * tt - t;
		float q2 = 3.0f * ttt - 5.0f * tt + 2.0f;
		float q3 = -3.0f * ttt + 4.0f * tt + t;
		float q4 = ttt - tt;

		p.x = 0.5f * (points[p0].x * q1 + points[p1].x * q2 + points[p2].x * q3 + points[p3].x * q4);
		p.y = 0.5f * (points[p0].y * q1 + points[p1].y * q2 + points[p2].y * q3 + points[p3].y * q4);

		return p;
	}
};

// Prototypes
void UserInput(std::vector<sPoint> &ControlPoints, std::vector<sf::Sprite*> &ControlPointsSprites, int &ControlPointHandler);
void MoveControlPoint(std::vector<sPoint> &ControlPoints, std::vector<sf::Sprite*> &ControlPointsSprites, int &ControlPointHandler);
void drawSpline(sSpline &spline, std::vector<sPoint> &ControlPoints, sf::RenderWindow &window);

int main()
{

	// Fenster öffnen
	sf::RenderWindow window(sf::VideoMode(1920, 1080), "Bezier Curve", sf::Style::Fullscreen);

	// Hintergrundbild
	sf::Sprite s;
	sf::IntRect r;
	sf::Texture t;

	t.loadFromFile("Data/Graphics/Background3.png");
	r.top = 0.0f;
	r.left = 0.0f;
	r.width = 1920.0f;
	r.height = 1080.0f;

	s.setTexture(t);
	s.setTextureRect(r);
	window.draw(s);

	// Punkte
	sPoint p1;
	p1.x = 100.0f;
	p1.y = 500.0f;
	sPoint p2;
	p2.x = 300.0f;
	p2.y = 500.0f;
	sPoint p3;
	p3.x = 500.0f;
	p3.y = 500.0f;
	sPoint p4;
	p4.x = 700.0f;
	p4.y = 500.0f;
	// Add to vector
	std::vector<sPoint> ControlPoints;
	ControlPoints.push_back(p1);
	ControlPoints.push_back(p2);
	ControlPoints.push_back(p3);
	ControlPoints.push_back(p4);
	// Vector for sprites
	std::vector<sf::Sprite*> ControlPointsSprites;

	// Draw ControlPoints
	for (int i = 0; i < ControlPoints.size(); i++)
	{
		// Init
		sf::Sprite *sprite = new sf::Sprite;
		sf::Texture *texture = new sf::Texture;
		sf::IntRect *rect = new sf::IntRect;

		// Def
		texture->loadFromFile("Data/Graphics/black.png");
		rect->left = 0;
		rect->top = 0;
		rect->width = 16.0f;
		rect->height = 16.0f;
		sprite->setTexture(*texture);
		sprite->setTextureRect(*rect);
		sprite->setOrigin(8.0f, 8.0f);
		sprite->setPosition(ControlPoints.at(i).x, ControlPoints.at(i).y);

		ControlPointsSprites.push_back(sprite);
	}

	// Variables for main loop
	bool beenden = false;
	int ControlPointsHandler = 100;
	sSpline spline;
	spline.points = ControlPoints;
	drawSpline(spline, ControlPoints, window);

	while (!beenden)
	{
		// Clear
		window.clear();

		// Events
		sf::Event e;
		if (window.pollEvent(e))
		{
			if (e.type = sf::Event::KeyPressed)
				if(e.key.code == sf::Keyboard::LAlt)
					beenden = true;
		}

		// Handle UserInput
		UserInput(ControlPoints, ControlPointsSprites, ControlPointsHandler);
		MoveControlPoint(ControlPoints, ControlPointsSprites, ControlPointsHandler);

		// Draw
			// BackgroundImage
			window.draw(s);
			// ControlPoints
			for (int i = 0; i < ControlPointsSprites.size(); i++)
				window.draw(*ControlPointsSprites.at(i));
			// Spline points
			for (int i = 0; i < spline.sprites.size(); i++)
				window.draw(*spline.sprites.at(i));

		// Display
		window.display();
	}

	return 0;
}

void UserInput(std::vector<sPoint> &ControlPoints, std::vector<sf::Sprite*> &ControlPointsSprites, int &ControlPointHandler)
{
	if (sf::Mouse::isButtonPressed(sf::Mouse::Button::Left) && ControlPointHandler == 100)
	{
		for (int i = 0; i < ControlPoints.size(); i++)
		{
			if (ControlPointsSprites.at(i)->getGlobalBounds().contains(sf::Mouse::getPosition().x,
																	   sf::Mouse::getPosition().y))
			{
				ControlPointHandler = i;
				ControlPointsSprites.at(ControlPointHandler)->setColor(sf::Color::Red);
			}
		}
	}
	if (!sf::Mouse::isButtonPressed(sf::Mouse::Button::Left))
	{
		if(ControlPointHandler != 100)
			ControlPointsSprites.at(ControlPointHandler)->setColor(sf::Color::Black);
		ControlPointHandler = 100;
	}
}
void MoveControlPoint(std::vector<sPoint> &ControlPoints, std::vector<sf::Sprite*> &ControlPointsSprites, int &ControlPointHandler)
{
	if (ControlPointHandler != 100)
	{
		ControlPoints.at(ControlPointHandler).x = sf::Mouse::getPosition().x;
		ControlPoints.at(ControlPointHandler).y = sf::Mouse::getPosition().y;
		ControlPointsSprites.at(ControlPointHandler)->setPosition(ControlPoints.at(ControlPointHandler).x, ControlPoints.at(ControlPointHandler).y);
	}
}
void drawSpline(sSpline &spline, std::vector<sPoint> &ControlPoints, sf::RenderWindow &window)
{
	for (float t = 0.0f; t < 1.0f; t += 0.01f)
	{
		// Punkt
		sPoint pos = spline.getSplinePoint(t);

		// Draw
		sf::Sprite *sprite = new sf::Sprite;
		sf::IntRect *rect = new sf::IntRect;
		sf::Texture *texture = new sf::Texture;

		// Winkel zwischen Punkten
		float gegenkathete = spline.points.at(t).y - ControlPoints.at(t - 0.01f).y;
		float ankathete = spline.points.at(t).x - ControlPoints.at(t - 0.01f).x;
		float hypothenuse = std::pow(gegenkathete, 2) + std::pow(ankathete, 2);
		float winkel = atan(gegenkathete / ankathete) * 180 / PI;

		texture->loadFromFile("Data/Graphics/red.png");
		rect->top = 0.0f;
		rect->left = 0.0f;
		rect->width = 16.0f;
		rect->height = 16.0f;

		sprite->setTexture(*texture);
		sprite->setTextureRect(*rect);
		sprite->setRotation(winkel);
		sprite->setScale(std::pow(hypothenuse, 0.5f) / 2.0f, 1);
		sprite->setOrigin(rect->width / 2, rect->height / 2);
		sprite->setPosition(spline.points.at(t).x, spline.points.at(t).y);

		spline.sprites.push_back(sprite);

		window.draw(*sprite);
	}
}


/*void drawBezier(Point p1, Point p2, Point p3, sf::RenderWindow &window)
{
	std::list<Point> p;

	for (float t = 0.0f; t < 1; t += 0.01f)
	{

		Point P;
		P.x = std::pow(1 - t, 2) * p1.x + (1 - t) * 2 * t * p2.x + t * t * p3.x;

		P.y = std::pow(1 - t, 2) * p1.y + (1 - t) * 2 * t * p2.y + t * t * p3.y;
		p.push_back(P);
	}

	// Iterator
	std::list<Point>::iterator it = p.begin();
	Point lastPoint = *it;
	it++;

	while(it != p.end())
	{
		// SFML Graphic
		sf::Sprite *S = new sf::Sprite;
		sf::IntRect *R = new sf::IntRect;
		sf::Texture *T = new sf::Texture;

		// Winkel zwischen Punkten
		float gegenkathete = it->y - lastPoint.y;
		float ankathete = it->x - lastPoint.x;
		float hypothenuse = std::pow(gegenkathete, 2) + std::pow(ankathete, 2);
		float winkel = atan(gegenkathete / ankathete) * 180 / PI;

		T->loadFromFile("Data/Graphics/dot.png");
		R->top = 0.0f;
		R->left = 0.0f;
		R->width = 2.0f;
		R->height = 2.0f;

		S->setTexture(*T);
		S->setTextureRect(*R);
		S->setRotation(winkel);
		S->setScale(std::pow(hypothenuse, 0.5f) / 2.0f, 1);
		//S->setOrigin(R->width / 2, R->height / 2);

		S->setPosition(it->x, it->y);
		lastPoint = *it;
		it++;

		window.draw(*S);
	}
}
*/