#include "pch.h"
#include "Lib\SDL2-2.0.10\include\SDL_opengl.h"
#include "utils.h"

void utils::FillEllipse(float centerX, float centerY, float radX, float radY)
{
	float angle{ };
	
	glBegin(GL_POLYGON);
	while (angle < 360)
	{
		glVertex2f(centerX + radX * cos(angle * g_Pi / 180), centerY + radY * sin(angle * g_Pi / 180));
		angle += 0.25f;
	}
	glEnd();
}

void utils::FillEllipse(const Point2f& point, float radX, float radY)
{
	FillEllipse(point.x, point.y, radX, radY);
}

void utils::FillRect(const Point2f& point, float width, float height)
{
	FillRect(point.x, point.y, width, height);
}

void utils::FillRect(float left, float bottom, float width, float height)
{
	glBegin(GL_QUADS);
		glVertex2f(left, bottom);
		glVertex2f(left + width, bottom);
		glVertex2f(left + width, bottom + height);
		glVertex2f(left, bottom + height);
	glEnd();
}

void utils::DrawRectOutline(float left, float bottom, float width, float height)
{
	glBegin(GL_LINE_LOOP);
		glVertex2f(left, bottom);
		glVertex2f(left + width, bottom);
		glVertex2f(left + width, bottom + height);
		glVertex2f(left, bottom + height);
	glEnd();
}

float utils::GetDistance(const Point2f& p1, const Point2f& p2)
{
	return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}

bool utils::IsPointInRect(const Point2f& point, const Rectf& rect)
{
	if (point.x > rect.left && point.x < rect.left + rect.width)
	{
		if (point.y > rect.bottom && point.y < rect.bottom + rect.height)
		{
			return true;
		}
	}

	return false;
}

bool utils::IsPointInCircle(const Point2f& point, const Circlef& circle)
{
	if (GetDistance(point, circle.center) < circle.radius)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool utils::IsOverlapping(const Circlef& circle1, const Circlef& circle2)
{
	float angle{ };

	while (angle < 360)
	{
		Point2f point{ circle1.center.x + circle1.radius * cos(angle * g_Pi / 180), circle1.center.y + circle1.radius * sin(angle * g_Pi / 180) };
		if (GetDistance(point, circle2.center) < circle2.radius)
		{
			return true;
		}
		angle += 0.5f;
	}

	return false;
}

bool utils::IsOverlapping(const Rectf& rect1, const Rectf& rect2)
{
	Point2f r1v1{ rect1.left, rect1.bottom }, r1v2{ rect1.left + rect1.width, rect1.bottom },
		r1v3{ rect1.left + rect1.width, rect1.bottom + rect1.height }, r1v4{ rect1.left, rect1.bottom + rect1.height };

	Point2f r2v1{ rect1.left, rect1.bottom }, r2v2{ rect1.left + rect1.width, rect1.bottom },
		r2v3{ rect1.left + rect1.width, rect1.bottom + rect1.height }, r2v4{ rect1.left, rect1.bottom + rect1.height };

	if (IsPointInRect(r1v1, rect2))
	{
		return true;
	}

	if (IsPointInRect(r1v2, rect2))
	{
		return true;
	}

	if (IsPointInRect(r1v3, rect2))
	{
		return true;
	}

	if (IsPointInRect(r1v4, rect2))
	{
		return true;
	}

	if (IsPointInRect(r2v1, rect1))
	{
		return true;
	}

	if (IsPointInRect(r2v2, rect1))
	{
		return true;
	}

	if (IsPointInRect(r2v3, rect1))
	{
		return true;
	}

	if (IsPointInRect(r2v4, rect1))
	{
		return true;
	}

	return false;
}

void utils::DrawVector(const Vector2f& vector, const Point2f& startPoint)
{
	float angle{ float(atan2(startPoint.y + vector.y - startPoint.y, startPoint.x + vector.x - startPoint.x)) };
	float thirtyRadians{ 30 * g_Pi / 180 };

	glBegin(GL_LINES);
		// line
		glVertex2f(startPoint.x, startPoint.y);
		glVertex2f(startPoint.x + vector.x, startPoint.y + vector.y);

		// arrow
		glVertex2f(startPoint.x + vector.x, startPoint.y + vector.y);
		glVertex2f(startPoint.x + vector.x - 10 * cos(angle + thirtyRadians), startPoint.y + vector.y - 10 * sin(angle + thirtyRadians));

		glVertex2f(startPoint.x + vector.x, startPoint.y + vector.y);
		glVertex2f(startPoint.x + vector.x - 10 * cos(angle - thirtyRadians), startPoint.y + vector.y - 10 * sin(angle - thirtyRadians));
	glEnd();
}

std::string utils::ToString(const Vector2f& vector)
{
	std::string result;

	result = "[";
	result += std::to_string(vector.x);
	result += ", ";
	result += std::to_string(vector.y);
	result += "]";

	return result;
}

Vector2f utils::Add(const Vector2f& vector1, const Vector2f& vector2)
{
	Vector2f result{ vector1.x + vector2.x, vector1.y + vector2.y };

	return result;
}

Vector2f utils::Substract(const Vector2f& vector1, const Vector2f& vector2)
{
	Vector2f result{ vector1.x - vector2.x, vector1.y - vector2.y };

	return result;
}

float utils::DotProduct(const Vector2f& vector1, const Vector2f& vector2)
{
	float result{ vector1.x * vector2.x + vector1.y * vector2.y };

	return result;
}

float utils::CrossProduct(const Vector2f& vector1, const Vector2f& vector2)
{
	float result{ vector1.x * vector2.y - vector1.y * vector2.x };

	return result;
}

float utils::GetLength(const Vector2f& vector)
{
	float result{ float(sqrt(pow(vector.x, 2) + pow(vector.y, 2))) };

	return result;
}

Vector2f utils::Scale(const Vector2f& vector, float scalar)
{
	return Vector2f{vector.x * scalar, vector.y * scalar};
}

Vector2f utils::Normalize(const Vector2f& vector)
{
	return Vector2f{vector.x / GetLength(vector), vector.y / GetLength(vector) };
}

float utils::AngleBetween(const Vector2f& vector1, const Vector2f& vector2)
{
	return atan2(CrossProduct(vector1, vector2), DotProduct(vector1, vector2));
}

bool utils::AreEqual(const Vector2f& vector1, const Vector2f& vector2)
{
	if ((abs(vector1.x - vector2.x) <= FLT_EPSILON) && (abs(vector1.y - vector2.y) <= FLT_EPSILON))
	{
		return true;
	}

	return false;
}

int utils::GetIndex(int rowIdx, int colIdx, int nrCols)
{
	return (rowIdx * nrCols + colIdx);
}