#ifndef VECTOR2D_H
#define VECTOR2D_H

#include <num/num.h>


libnum::num32 sqrt_num32(libnum::num32 v);


class Vector2D
{

    public:

        Vector2D();
        Vector2D( float x, float y );
        Vector2D( libnum::num32 x, libnum::num32 y );
        Vector2D( const Vector2D &v );
        ~Vector2D();

        Vector2D Clone( void );
        Vector2D MakeVector( Vector2D A, Vector2D B);

        void AddVectors( Vector2D a, Vector2D b );
        void Add( Vector2D v, libnum::num32 scale );
        void SubtractVectors( Vector2D a, Vector2D b );
        void Subtract( Vector2D v, libnum::num32 scale );

        libnum::num32 Length( void );
        void Scale( libnum::num32 scale );

        libnum::num32 Dot( Vector2D v );
        libnum::num32 Det( Vector2D v );
        Vector2D Perp( void );

        libnum::num32 operator[](uint8_t pos)
        {
            return pos == 0 ? x : y;
        } 

        Vector2D &operator=(const Vector2D &v )
        {
            this->x = v.x;
            this->y = v.y;
            return *this;
        }

        Vector2D operator+(const Vector2D &v ) const
        {
            return Vector2D(x + v.x, y + v.y);
        }

        Vector2D operator-(const Vector2D &v ) const
        {
            return Vector2D(x - v.x, y - v.y);
        }

        Vector2D &operator+=( Vector2D const &other ) 
        {
            this->x += other.x;
            this->y += other.y;
            return *this;
        }

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

		Vector2D operator+() const
		{
			return *this;
		}

        Vector2D &operator-=( Vector2D const &other )
        {
            this->x -= other.x;
            this->y -= other.y;
            return *this;
        }

        Vector2D &operator*=( libnum::num32 scale )
        {
            this->x *= scale;
            this->y *= scale;
            return *this;
        }

        Vector2D &operator/=( libnum::num32 scale )
        {
            this->x /= scale;
            this->y /= scale;
            return *this;
        }

        friend Vector2D operator*(libnum::num32 scale, Vector2D const &v)
        {
            Vector2D r;
            r.x = v.x * scale;
            r.y = v.y * scale;
            return r;
        }

        friend Vector2D operator*(Vector2D const &v, libnum::num32 scale)
        {
            Vector2D r;
            r.x = v.x * scale;
            r.y = v.y * scale;
            return r;
        }

        friend Vector2D operator/(Vector2D const &v, libnum::num32 scale) {
            Vector2D r;
            r.x = v.x / scale;
            r.y = v.y / scale;
            return r;
        }

        libnum::num32 x;
        libnum::num32 y;

};

class Border
{
    public:
        Border();
        ~Border();

        Vector2D A;
        Vector2D B;
        Vector2D N;
        uint16_t color;
};

#endif