#pragma once

#include <cstdint>

namespace td {

template<typename T>
struct Vec2 {
	union {
		T x;
		T r;
	};

	union {
		T y;
		T g;
	};

	constexpr Vec2(T X = 0, T Y = 0) : x(X), y(Y) {}
};

template<typename T>
inline bool operator==(const Vec2<T>& vec2, const Vec2<T>& other) {
	return vec2.x == other.x && vec2.y == other.y;
}

template<typename T>
struct Vec3 {
	union {
		T x;
		T r;
	};

	union {
		T y;
		T g;
	};

	union {
		T z;
		T b;
	};

	constexpr Vec3(T X = 0, T Y = 0, T Z = 0) : x(X), y(Y), z(Z) {}
};

template<typename T>
inline bool operator==(const Vec3<T>& vec3, const Vec3<T>& other) {
	return vec3.x == other.x && vec3.y == other.y && vec3.z == other.z;
}

template<typename T>
struct Vec4 {
	union {
		T x;
		T r;
	};

	union {
		T y;
		T g;
	};

	union {
		T z;
		T b;
	};

	union {
		T w;
		T a;
	};

	constexpr Vec4(Vec3<T> vec, T W = 1) : x(vec.x), y(vec.y), z(vec.z), w(W) {}
	constexpr Vec4(T X = 0, T Y = 0, T Z = 0, T W = 0) : x(X), y(Y), z(Z), w(W) {}
};

template<typename T>
inline bool operator==(const Vec4<T>& vec4, const Vec4<T>& other) {
	return vec4.x == other.x && vec4.y == other.y && vec4.z == other.z && vec4.w = other.w;
}

using Vec2i = Vec2<int>;
using Vec2u = Vec2<unsigned int>;
using Vec2f = Vec2<float>;
using Vec2d = Vec2<double>;

using Vec3i = Vec3<int>;
using Vec3u = Vec3<unsigned int>;
using Vec3f = Vec3<float>;
using Vec3d = Vec3<double>;

using Vec4i = Vec4<int>;
using Vec4u = Vec4<unsigned int>;
using Vec4f = Vec4<float>;
using Vec4d = Vec4<double>;

using Color = Vec3<unsigned char>;

template<typename T>
struct Mat4 {
	static const std::size_t MATRIX_SIZE = 4;

	T x0, x1, x2, x3;
	T y0, y1, y2, y3;
	T z0, z1, z2, z3;
	T w0, w1, w2, w3;

	T operator[] (std::size_t offset) const {
		return reinterpret_cast<const T*>(this)[offset];
	}

	T& operator[] (std::size_t offset) {
		return reinterpret_cast<T*>(this)[offset];
	}

	T* data() {
		return reinterpret_cast<T*>(this);
	}

	const T* data() const{
		return reinterpret_cast<const T*>(this);
	}

	T at(std::size_t row, std::size_t column) const {
		return operator[](row * MATRIX_SIZE + column);
	}

	T& at(std::size_t row, std::size_t column) {
		return operator[](row * MATRIX_SIZE + column);
	}
};

typedef Mat4<float> Mat4f;
typedef Mat4<int> Mat4i;
typedef Mat4<double> Mat4d;

} // namespace td