/*
 * Copyright (c) 2015 Tricoire Sebastien 3dsman@free.fr
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 */

#ifndef OE_UTILS_H
#define OE_UTILS_H

#include <math.h>
#include <vector>
		
struct vector_2d {
    float x, y;
    vector_2d( float _x,  float _y) {
        x = _x;
        y = _y;
    }
    vector_2d() {}
	
	 inline vector_2d operator *(const vector_2d& pt) const{
		return {pt.x*x,pt.y*y};
	}
	 inline vector_2d operator *( const float val) {
		return {val*x,val*y};
	}
	inline vector_2d operator /(const vector_2d& pt) const{
		return {x/pt.x,y/pt.y};
	}
	 inline vector_2d operator /( const float val) {
		return {x/val,y/val};
	}
	 inline vector_2d operator +(const vector_2d pt) const{
		return {pt.x+x,pt.y+y};
	}
	 inline vector_2d operator +(const float val) const{
		return {val+x,val+y};
	}
	 inline vector_2d operator -(const vector_2d pt) const{
		return {x-pt.x,y-pt.y};
	}
	 inline vector_2d operator -(const float val) const{
		return {x-val,y-val};
	}
	
	/** \brief normalise the vector (his length become 1)
	 */
    void normalize() {
        float length = 1/len() ;
        x *= length;
        y *= length;
    }
	
		
	/** \brief turn the vector 90° to the right
	 */
    void turnRight() {
		float tmpx = x;
        x = -y;
        y = tmpx;
    }
	
    void turnLeft() {
		float tmpx = x;
        x = y;
        y = -tmpx;
    }
	
	/** \brief parse the xml file to load params
	* \return true the length of the vector (always >=0)
	*/
    float len() {
		return sqrt(x*x+y*y);
    }
};

inline std::vector<vector_2d> normals(std::vector<vector_2d> segments)
{
			vector_2d tmpNormal;
			vector_2d normal;
			std::vector<vector_2d> out;
			for(unsigned i=0; i<segments.size()-1; i++)
			{
				normal = segments.at(i+1)-segments.at(i);
				normal.turnRight();
				if (i==0)
					tmpNormal = normal;
				tmpNormal =tmpNormal + normal;
				tmpNormal.normalize();
				out.push_back( tmpNormal);
			
				tmpNormal = normal;
			}
			tmpNormal.normalize();
			out.push_back( tmpNormal);
			return out;
}

inline std::vector<vector_2d> subd(vector_2d pt1, vector_2d pt2, float maxlen)
{
	std::vector<vector_2d> out;
	vector_2d tmpvec = pt2 - pt1;
	float len = tmpvec.len();
	if (!len) return out;
	if (len<maxlen)
	{
		out.push_back( pt2);
		return out;
	}
	
	int nbsub = ceilf(len / maxlen);
	len /= (float)nbsub;
	tmpvec.normalize();
	tmpvec = tmpvec*len;
	for (;nbsub>0;nbsub--)
	{
		pt1 = pt1 + tmpvec;
		out.push_back( pt1);
	}
	return out;
}


/* inline vector_2d operator *( const vector_2d vect, const float val)  {
	return {val*vect.x,val*vect.y};
}*/
 inline vector_2d operator *( const float val, const vector_2d vect)  {
	return {val*vect.x,val*vect.y};
}
 /*inline vector_2d operator -( const vector_2d vect1, const vector_2d vect2)  {
	return {vect1.x-vect2.x,vect1.y-vect2.y};
}*/
 inline vector_2d operator -( const float val, const vector_2d vect)  {
	return {val-vect.x,val-vect.y};
}
 inline vector_2d operator -( const vector_2d vect, const float val)  {
	return {vect.x-val , vect.y-val};
}

static inline float minf(float a, float b) { return a < b ? a : b; }
static inline float maxf(float a, float b) { return a > b ? a : b; }

#endif // OE_UTILS_H