#ifndef VECTOR2D_H
#define VECTOR2D_H

#include <num/num.h>


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


class Point2D
{
    public:
        Point2D() {};
        ~Point2D() {};

        libnum::num x, y;
};

class Circle
{
    public:
        Circle() {};
        ~Circle() {};

        libnum::num x,y,r;
};




class Vector2D
{

    public:

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

        Vector2D Clone( void );

        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 );
        Vector2D Perp( void );



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

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

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

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

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

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

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

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

};

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

        Point2D A;
        Point2D B;
        Vector2D N;
};


bool CollisionDroite(Point2D A,Point2D B, Circle C);
bool CollisionSegment(Point2D A,Point2D B,Circle C);
bool CollisionBorder(Border B, Circle C);
Vector2D GetNormale(Point2D A,Point2D B,Point2D C);
Point2D ProjectionI(Point2D A,Point2D B,Point2D C);
Vector2D ComputeVectorRebound(Vector2D v,Vector2D N);

#endif