#include <algorithm>
#include <cmath>
#include <cstddef>
#include <functional>
#include <optional>
#include <utility>
#include <variant>

#include "../manager/ComponentManager.h"
#include "../manager/EventManager.h"
#include "api/BoxCollider.h"
#include "api/CircleCollider.h"
#include "api/Event.h"
#include "api/Metadata.h"
#include "api/Rigidbody.h"
#include "api/Transform.h"
#include "api/Vector2.h"

#include "Collider.h"
#include "CollisionSystem.h"
#include "types.h"
#include "util/OptionalRef.h"

using namespace crepe;

void CollisionSystem::update() {
	std::vector<CollisionInternal> all_colliders;
	game_object_id_t id = 0;
	ComponentManager & mgr = this->mediator.component_manager;
	RefVector<Rigidbody> rigidbodies = mgr.get_components_by_type<Rigidbody>();
	// Collisions can only happen on object with a rigidbody
	for (Rigidbody & rigidbody : rigidbodies) {
		if (!rigidbody.active) continue;
		id = rigidbody.game_object_id;
		Transform & transform = mgr.get_components_by_id<Transform>(id).front().get();
		// Check if the boxcollider is active and has the same id as the rigidbody.
		RefVector<BoxCollider> boxcolliders = mgr.get_components_by_type<BoxCollider>();
		for (BoxCollider & boxcollider : boxcolliders) {
			if (boxcollider.game_object_id != id) continue;
			if (!boxcollider.active) continue;
			all_colliders.push_back({.id = id,
									 .collider = collider_variant{boxcollider},
									 .transform = transform,
									 .rigidbody = rigidbody});
		}
		// Check if the circlecollider is active and has the same id as the rigidbody.
		RefVector<CircleCollider> circlecolliders
			= mgr.get_components_by_type<CircleCollider>();
		for (CircleCollider & circlecollider : circlecolliders) {
			if (circlecollider.game_object_id != id) continue;
			if (!circlecollider.active) continue;
			all_colliders.push_back({.id = id,
									 .collider = collider_variant{circlecollider},
									 .transform = transform,
									 .rigidbody = rigidbody});
		}
	}

	// Check between all colliders if there is a collision
	std::vector<std::pair<CollisionInternal, CollisionInternal>> collided
		= this->gather_collisions(all_colliders);

	// For both objects call the collision handler
	for (auto & collision_pair : collided) {
		this->collision_handler_request(collision_pair.first, collision_pair.second);
		// this->collision_handler_request(collision_pair.second, collision_pair.first);
	}
}

void CollisionSystem::collision_handler_request(CollisionInternal & this_data,
												CollisionInternal & other_data) {

	CollisionInternalType type
		= this->get_collider_type(this_data.collider, other_data.collider);
	std::pair<vec2, CollisionSystem::Direction> resolution_data
		= this->collision_handler(this_data, other_data, type);
	ComponentManager & mgr = this->mediator.component_manager;
	OptionalRef<Metadata> this_metadata
		= mgr.get_components_by_id<Metadata>(this_data.id).front().get();
	OptionalRef<Metadata> other_metadata
		= mgr.get_components_by_id<Metadata>(other_data.id).front().get();
	OptionalRef<Collider> this_collider;
	OptionalRef<Collider> other_collider;
	switch (type) {
		case CollisionInternalType::BOX_BOX: {
			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
			other_collider
				= std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
			break;
		}
		case CollisionInternalType::BOX_CIRCLE: {
			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
			other_collider
				= std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
			break;
		}
		case CollisionInternalType::CIRCLE_BOX: {
			this_collider
				= std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
			other_collider
				= std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
			break;
		}
		case CollisionInternalType::CIRCLE_CIRCLE: {
			this_collider
				= std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
			other_collider
				= std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
			break;
		}
	}

	// collision info
	crepe::CollisionSystem::CollisionInfo collision_info{
		.this_collider = this_collider,
		.this_transform = this_data.transform,
		.this_rigidbody = this_data.rigidbody,
		.this_metadata = this_metadata,
		.other_collider = other_collider,
		.other_transform = other_data.transform,
		.other_rigidbody = other_data.rigidbody,
		.other_metadata = other_metadata,
		.resolution = resolution_data.first,
		.resolution_direction = resolution_data.second,
	};

	// Determine if static needs to be called
	this->determine_collision_handler(collision_info);
}

std::pair<vec2, CollisionSystem::Direction>
CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal & data2,
								   CollisionInternalType type) {
	vec2 resolution;
	switch (type) {
		case CollisionInternalType::BOX_BOX: {
			const BoxCollider & collider1
				= std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
			const BoxCollider & collider2
				= std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
															data1.rigidbody);
			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
															data2.rigidbody);
			resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1,
													  collider_pos2);
			break;
		}
		case CollisionInternalType::BOX_CIRCLE: {
			const BoxCollider & collider1
				= std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
			const CircleCollider & collider2
				= std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
															data1.rigidbody);
			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
															data2.rigidbody);
			resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2,
														  collider_pos1);
			break;
		}
		case CollisionInternalType::CIRCLE_CIRCLE: {
			const CircleCollider & collider1
				= std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
			const CircleCollider & collider2
				= std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
															data1.rigidbody);
			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
															data2.rigidbody);
			resolution = this->get_circle_circle_resolution(collider1, collider2,
															collider_pos1, collider_pos2);
			break;
		}
		case CollisionInternalType::CIRCLE_BOX: {
			const CircleCollider & collider1
				= std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
			const BoxCollider & collider2
				= std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
															data1.rigidbody);
			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
															data2.rigidbody);
			resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1,
														 collider_pos2);
			break;
		}
	}

	Direction resolution_direction = Direction::NONE;
	if (resolution.x != 0 && resolution.y != 0) {
		resolution_direction = Direction::BOTH;
	} else if (resolution.x != 0) {
		resolution_direction = Direction::X_DIRECTION;
		//checks if the other velocity has a value and if this object moved
		if (data1.rigidbody.data.linear_velocity.x != 0
			&& data1.rigidbody.data.linear_velocity.y != 0)
			resolution.y = -data1.rigidbody.data.linear_velocity.y
						   * (resolution.x / data1.rigidbody.data.linear_velocity.x);
	} else if (resolution.y != 0) {
		resolution_direction = Direction::Y_DIRECTION;
		//checks if the other velocity has a value and if this object moved
		if (data1.rigidbody.data.linear_velocity.x != 0
			&& data1.rigidbody.data.linear_velocity.y != 0)
			resolution.x = -data1.rigidbody.data.linear_velocity.x
						   * (resolution.y / data1.rigidbody.data.linear_velocity.y);
	}

	return std::make_pair(resolution, resolution_direction);
}

vec2 CollisionSystem::get_box_box_resolution(const BoxCollider & box_collider1,
											 const BoxCollider & box_collider2,
											 const vec2 & final_position1,
											 const vec2 & final_position2) const {
	vec2 resolution; // Default resolution vector
	vec2 delta = final_position2 - final_position1;

	// Compute half-dimensions of the boxes
	float half_width1 = box_collider1.dimensions.x / 2.0;
	float half_height1 = box_collider1.dimensions.y / 2.0;
	float half_width2 = box_collider2.dimensions.x / 2.0;
	float half_height2 = box_collider2.dimensions.y / 2.0;

	// Calculate overlaps along X and Y axes
	float overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
	float overlap_y = (half_height1 + half_height2) - std::abs(delta.y);

	// Check if there is a collision should always be true
	if (overlap_x > 0 && overlap_y > 0) {
		// Determine the direction of resolution
		if (overlap_x < overlap_y) {
			// Resolve along the X-axis (smallest overlap)
			resolution.x = (delta.x > 0) ? -overlap_x : overlap_x;
		} else if (overlap_y < overlap_x) {
			// Resolve along the Y-axis (smallest overlap)
			resolution.y = (delta.y > 0) ? -overlap_y : overlap_y;
		} else {
			// Equal overlap, resolve both directions with preference
			resolution.x = (delta.x > 0) ? -overlap_x : overlap_x;
			resolution.y = (delta.y > 0) ? -overlap_y : overlap_y;
		}
	}

	return resolution;
}

vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle_collider1,
												   const CircleCollider & circle_collider2,
												   const vec2 & final_position1,
												   const vec2 & final_position2) const {
	vec2 delta = final_position2 - final_position1;

	// Compute the distance between the two circle centers
	float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y);

	// Compute the combined radii of the two circles
	float combined_radius = circle_collider1.radius + circle_collider2.radius;

	// Compute the penetration depth
	float penetration_depth = combined_radius - distance;

	// Normalize the delta vector to get the collision direction
	vec2 collision_normal = delta / distance;

	// Compute the resolution vector
	vec2 resolution = -collision_normal * penetration_depth;

	return resolution;
}

vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_collider,
												const BoxCollider & box_collider,
												const vec2 & circle_position,
												const vec2 & box_position) const {
	vec2 delta = circle_position - box_position;

	// Compute half-dimensions of the box
	float half_width = box_collider.dimensions.x / 2.0f;
	float half_height = box_collider.dimensions.y / 2.0f;

	// Clamp circle center to the nearest point on the box
	vec2 closest_point;
	closest_point.x = std::clamp(delta.x, -half_width, half_width);
	closest_point.y = std::clamp(delta.y, -half_height, half_height);

	// Find the vector from the circle center to the closest point
	vec2 closest_delta = delta - closest_point;

	// Normalize the delta to get the collision direction
	float distance
		= std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y);
	vec2 collision_normal = closest_delta / distance;

	// Compute penetration depth
	float penetration_depth = circle_collider.radius - distance;

	// Compute the resolution vector
	vec2 resolution = collision_normal * penetration_depth;

	return resolution;
}

void CollisionSystem::determine_collision_handler(CollisionInfo & info) {
	// If both objects are static skip handle call collision script
	if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;

	//	First body is not dynamic
	if(info.this_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC)
	{
		bool static_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC;
		bool kinematic_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC && info.this_rigidbody.data.kinematic_collision;
		// Inverted collision info
		CollisionInfo inverted = {
				.this_collider = info.other_collider,
				.this_transform = info.other_transform,
				.this_rigidbody = info.other_rigidbody,
				.this_metadata = info.other_metadata,
				.other_collider = info.this_collider,
				.other_transform = info.this_transform,
				.other_rigidbody = info.this_rigidbody,
				.other_metadata = info.this_metadata,
				.resolution = -info.resolution,
				.resolution_direction = info.resolution_direction,
				};
		
		if(static_collision || kinematic_collision){
			// Static collision
			this->static_collision_handler(inverted);
		};
		// Call scripts
		this->call_collision_events(inverted);
		return;
	}

	// Second body is not dynamic
	if(info.other_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC)
	{
		bool static_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC;
		bool kinematic_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.kinematic_collision;
		if(static_collision || kinematic_collision)	this->static_collision_handler(info);
		this->call_collision_events(info);
		return;
	}

	//dynamic
	this->dynamic_collision_handler(info);
	this->call_collision_events(info);
}

void CollisionSystem::call_collision_events(CollisionInfo & info){
	CollisionEvent data(info);
	EventManager & emgr = this->mediator.event_manager;
	emgr.trigger_event<CollisionEvent>(data, info.this_collider.game_object_id);
	emgr.trigger_event<CollisionEvent>(data, info.other_collider.game_object_id);
}

void CollisionSystem::static_collision_handler(CollisionInfo & info) {
	// Move object back using calculate move back value
	info.this_transform.position += info.resolution;

	switch (info.resolution_direction) {
		case Direction::BOTH:
			//bounce
			if (info.this_rigidbody.data.elastisity_coefficient > 0) {
				info.this_rigidbody.data.linear_velocity
					= -info.this_rigidbody.data.linear_velocity
					  * info.this_rigidbody.data.elastisity_coefficient;
			}
			//stop movement
			else {
				info.this_rigidbody.data.linear_velocity = {0, 0};
			}
			break;
		case Direction::Y_DIRECTION:
			// Bounce
			if (info.this_rigidbody.data.elastisity_coefficient > 0) {
				info.this_rigidbody.data.linear_velocity.y
					= -info.this_rigidbody.data.linear_velocity.y
					  * info.this_rigidbody.data.elastisity_coefficient;
			}
			// Stop movement
			else {
				info.this_rigidbody.data.linear_velocity.y = 0;
				info.this_transform.position.x -= info.resolution.x;
			}
			break;
		case Direction::X_DIRECTION:
			// Bounce
			if (info.this_rigidbody.data.elastisity_coefficient > 0) {
				info.this_rigidbody.data.linear_velocity.x
					= -info.this_rigidbody.data.linear_velocity.x
					  * info.this_rigidbody.data.elastisity_coefficient;
			}
			// Stop movement
			else {
				info.this_rigidbody.data.linear_velocity.x = 0;
				info.this_transform.position.y -= info.resolution.y;
			}
			break;
		case Direction::NONE:
			// Not possible
			break;
	}
}

void CollisionSystem::dynamic_collision_handler(CollisionInfo & info){
	info.this_transform.position += info.resolution/2;
	info.other_transform.position += -(info.resolution/2);

	switch (info.resolution_direction) {
		case Direction::BOTH:
			info.this_rigidbody.data.linear_velocity = {0, 0};
			break;
		case Direction::Y_DIRECTION:
			info.this_rigidbody.data.linear_velocity.y = 0;
			info.this_transform.position.x -= info.resolution.x;
			break;
		case Direction::X_DIRECTION:
			info.this_rigidbody.data.linear_velocity.x = 0;
			info.this_transform.position.y -= info.resolution.y;
			break;
		case Direction::NONE:
			// Not possible
			break;
	}
}

std::vector<std::pair<CollisionSystem::CollisionInternal, CollisionSystem::CollisionInternal>>
CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {

	// TODO:
	// If no colliders skip
	// Check if colliders has rigidbody if not skip

	// TODO:
	// If amount is higer than lets say 16 for now use quadtree otwerwise skip
	// Quadtree code
	// Quadtree is placed over the input vector

	// Return data of collided colliders which are variants
	std::vector<std::pair<CollisionInternal, CollisionInternal>> collisions_ret;
	//using visit to visit the variant to access the active and id.
	for (size_t i = 0; i < colliders.size(); ++i) {
		for (size_t j = i + 1; j < colliders.size(); ++j) {
			if (colliders[i].id == colliders[j].id) continue;
			if (!have_common_layer(colliders[i].rigidbody.data.collision_layers,
								   colliders[j].rigidbody.data.collision_layers))
				continue;
			CollisionInternalType type
				= get_collider_type(colliders[i].collider, colliders[j].collider);
			if (!get_collision(
					{
						.collider = colliders[i].collider,
						.transform = colliders[i].transform,
						.rigidbody = colliders[i].rigidbody,
					},
					{
						.collider = colliders[j].collider,
						.transform = colliders[j].transform,
						.rigidbody = colliders[j].rigidbody,
					},
					type))
				continue;
			collisions_ret.emplace_back(colliders[i], colliders[j]);
		}
	}

	return collisions_ret;
}

bool CollisionSystem::have_common_layer(const std::set<int> & layers1,
										const std::set<int> & layers2) {

	// Check if any number is equal in the layers
	for (int num : layers1) {
		if (layers2.contains(num)) {
			// Common layer found
			return true;
			break;
		}
	}
	// No common layer found
	return false;
}

CollisionSystem::CollisionInternalType
CollisionSystem::get_collider_type(const collider_variant & collider1,
								   const collider_variant & collider2) const {
	if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)) {
		if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2)) {
			return CollisionInternalType::CIRCLE_CIRCLE;
		} else {
			return CollisionInternalType::CIRCLE_BOX;
		}
	} else {
		if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2)) {
			return CollisionInternalType::BOX_CIRCLE;
		} else {
			return CollisionInternalType::BOX_BOX;
		}
	}
}

bool CollisionSystem::get_collision(const CollisionInternal & first_info,
									const CollisionInternal & second_info,
									CollisionInternalType type) const {
	switch (type) {
		case CollisionInternalType::BOX_BOX: {
			const BoxCollider & box_collider1
				= std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
			const BoxCollider & box_collider2
				= std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
			return this->get_box_box_collision(box_collider1, box_collider2,
											   first_info.transform, second_info.transform,
											   second_info.rigidbody, second_info.rigidbody);
		}
		case CollisionInternalType::BOX_CIRCLE: {
			const BoxCollider & box_collider
				= std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
			const CircleCollider & circle_collider
				= std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
			return this->get_box_circle_collision(
				box_collider, circle_collider, first_info.transform, second_info.transform,
				second_info.rigidbody, second_info.rigidbody);
		}
		case CollisionInternalType::CIRCLE_CIRCLE: {
			const CircleCollider & circle_collider1
				= std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
			const CircleCollider & circle_collider2
				= std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
			return this->get_circle_circle_collision(
				circle_collider1, circle_collider2, first_info.transform,
				second_info.transform, second_info.rigidbody, second_info.rigidbody);
		}
		case CollisionInternalType::CIRCLE_BOX: {
			const CircleCollider & circle_collider
				= std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
			const BoxCollider & box_collider
				= std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
			return this->get_box_circle_collision(
				box_collider, circle_collider, first_info.transform, second_info.transform,
				second_info.rigidbody, second_info.rigidbody);
		}
	}
	return false;
}

bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2,
											const Transform & transform1,
											const Transform & transform2,
											const Rigidbody & rigidbody1,
											const Rigidbody & rigidbody2) const {
	// Get current positions of colliders
	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
	vec2 final_position2 = this->get_current_position(box2.offset, transform2, rigidbody2);

	// Calculate half-extents (half width and half height)
	float half_width1 = box1.dimensions.x / 2.0;
	float half_height1 = box1.dimensions.y / 2.0;
	float half_width2 = box2.dimensions.x / 2.0;
	float half_height2 = box2.dimensions.y / 2.0;

	// Check if the boxes overlap along the X and Y axes
	return (final_position1.x + half_width1 > final_position2.x - half_width2
			&& final_position1.x - half_width1 < final_position2.x + half_width2
			&& final_position1.y + half_height1 > final_position2.y - half_height2
			&& final_position1.y - half_height1 < final_position2.y + half_height2);
}

bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1,
											   const CircleCollider & circle2,
											   const Transform & transform1,
											   const Transform & transform2,
											   const Rigidbody & rigidbody1,
											   const Rigidbody & rigidbody2) const {
	// Get current positions of colliders
	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);

	// Calculate box half-extents
	float half_width = box1.dimensions.x / 2.0;
	float half_height = box1.dimensions.y / 2.0;

	// Find the closest point on the box to the circle's center
	float closest_x = std::max(final_position1.x - half_width,
							   std::min(final_position2.x, final_position1.x + half_width));
	float closest_y = std::max(final_position1.y - half_height,
							   std::min(final_position2.y, final_position1.y + half_height));

	// Calculate the distance squared between the circle's center and the closest point on the box
	float distance_x = final_position2.x - closest_x;
	float distance_y = final_position2.y - closest_y;
	float distance_squared = distance_x * distance_x + distance_y * distance_y;

	// Compare distance squared with the square of the circle's radius
	return distance_squared < circle2.radius * circle2.radius;
}

bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1,
												  const CircleCollider & circle2,
												  const Transform & transform1,
												  const Transform & transform2,
												  const Rigidbody & rigidbody1,
												  const Rigidbody & rigidbody2) const {
	// Get current positions of colliders
	vec2 final_position1 = this->get_current_position(circle1.offset, transform1, rigidbody1);
	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);

	float distance_x = final_position1.x - final_position2.x;
	float distance_y = final_position1.y - final_position2.y;
	float distance_squared = distance_x * distance_x + distance_y * distance_y;

	// Calculate the sum of the radii
	float radius_sum = circle1.radius + circle2.radius;

	// Check if the distance between the centers is less than or equal to the sum of the radii
	return distance_squared < radius_sum * radius_sum;
}

vec2 CollisionSystem::get_current_position(const vec2 & collider_offset,
										   const Transform & transform,
										   const Rigidbody & rigidbody) const {
	// Get the rotation in radians
	float radians1 = transform.rotation * (M_PI / 180.0);

	// Calculate total offset with scale
	vec2 total_offset = (rigidbody.data.offset + collider_offset) * transform.scale;

	// Rotate
	float rotated_total_offset_x1
		= total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
	float rotated_total_offset_y1
		= total_offset.x * sin(radians1) + total_offset.y * cos(radians1);

	// Final positions considering scaling and rotation
	return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
}