#ifndef GEO_POINT3_H
#define GEO_POINT3_H

#include "../Assertions.h"
#include <cmath>
#include "Point2.h"

/**
 * 3D Point
 */
struct Point3 {

	float x;
	float y;
	float z;

	/** ctor */
	Point3() : x(0), y(0), z(0) {;}

	/** ctor */
	Point3(const float x, const float y, const float z) : x(x), y(y), z(z) {;}


	Point3 operator - () const {return Point3(-x, -y, -z);}


	Point3 operator + (const Point3& o) const {return Point3(x+o.x, y+o.y, z+o.z);}

	Point3 operator - (const Point3& o) const {return Point3(x-o.x, y-o.y, z-o.z);}

	Point3 operator * (const Point3& o) const {return Point3(x*o.x, y*o.y, z*o.z);}

	Point3 operator * (const float v) const {return Point3(v*x, v*y, v*z);}

	Point3 operator / (const float v) const {return Point3(x/v, y/v, z/v);}


	Point3& operator *= (const float v) {x*=v; y*=v; z*=v; return *this;}

	Point3& operator /= (const float v) {x/=v; y/=v; z/=v; return *this;}


	Point3& operator += (const Point3& o) {x+=o.x; y+=o.y; z+=o.z; return *this;}

	Point3& operator -= (const Point3& o) {x-=o.x; y-=o.y; z-=o.z; return *this;}

	Point3& operator *= (const Point3& o) {x*=o.x; y*=o.y; z*=o.z; return *this;}

	Point3& operator /= (const Point3& o) {x/=o.x; y/=o.y; z/=o.z; return *this;}


	bool operator < (const Point3& o) const {return x<o.x && y<o.y && z<o.z;}

	bool operator == (const Point3& o) const {return x==o.x && y==o.y && z==o.z;}

	bool operator != (const Point3& o) const {return x!=o.x || y!=o.y || z!=o.z;}

	bool eq (const Point3& o, const float delta) const { return eq(x,o.x,delta) && eq(y,o.y,delta) && eq(z,o.z,delta); }


	Point2 xy() const {return Point2(x,y);}


	Point3 rotX(const float r) const {
		return Point3(x, y*cos(r) - z*sin(r), y*sin(r) + z*cos(r));
	}
	Point3 rotY(const float r) const {
		return Point3(z*sin(r) + x*cos(r), y, z*cos(r) - x*sin(r));
	}
	Point3 rotZ(const float r) const {
		return Point3(x*cos(r) - y*sin(r), x*sin(r) + y*cos(r), z);
	}
	Point3 rot(const float rx, const float ry, const float rz) const {
		return rotX(rx).rotY(ry).rotZ(rz);
		//return rotZ(rz).rotY(ry).rotX(rx);
	}


	/** read-only array access */
	float operator [] (const int idx) const {
		Assert::isBetween(idx, 0, 2, "index out of bounds");
		if (0 == idx)	{return x;}
		if (1 == idx)	{return y;}
						return z;
	}

	/** get the distance between this point and the other one */
	float getDistance(const Point3& o) const {
		const float dx = x - o.x;
		const float dy = y - o.y;
		const float dz = z - o.z;
		return std::sqrt(dx*dx + dy*dy + dz*dz);
	}

	/** get a normalized copy */
	Point3 normalized() const {return *this / this->length();}

	float length() const {return std::sqrt(x*x + y*y + z*z);}

	float length(const float norm) const {
		return std::pow(
					(std::pow(std::abs(x),norm) +
					 std::pow(std::abs(y),norm) +
					 std::pow(std::abs(z),norm)
				), 1.0f/norm);
	}

	std::string asString() const {
		return "(" + std::to_string(x) + ", " + std::to_string(y) + ", " + std::to_string(z) + ")";
	}

private:

	static inline bool eq(const float a, const float b, const float delta) {return std::abs(a-b) <= delta;}
	static inline bool ne(const float a, const float b, const float delta) {return std::abs(a-b)  > delta;}

};

inline float dot(const Point3 p1, const Point3 p2) {
	return (p1.x*p2.x) + (p1.y*p2.y) + (p1.z*p2.z);
}

inline Point3 cross(const Point3 a, const Point3 b) {
	return Point3(
		a.y*b.z - a.z*b.y,
		a.z*b.x - a.x*b.z,
		a.x*b.y - a.y*b.x
	);
}

#endif // GEO_POINT3_H