/***************************************
	Auteur : Pierre Aubert
	Mail : aubertp7@gmail.com
	Licence : CeCILL-C
****************************************/

#ifndef __PABSTRACT_VECT_3_H__
#define __PABSTRACT_VECT_3_H__

#include <iostream>

#define VECT3F_NULL PAbstractVect3<T>(0, 0, 0)

template<typename T>
class PAbstractVect3;

///@brief Abstract vector
template <typename T>
class PAbstractVect3{
	public:
		PAbstractVect3();
		PAbstractVect3(const T & x, const T & y);
		PAbstractVect3(const T & x, const T & y, const T & z);
		PAbstractVect3(const PAbstractVect3<T> & other);
		virtual ~PAbstractVect3();
		
		///définition de l'opérateur [] pour un PAbstractVect3 non constant
		/**	@param i : indice de l'élément du PAbstractVect3 que l'on veut retourner
		* 	@return valeur de l'élément du PAbstractVect3
		*/
		T & operator[] (long unsigned int i){return p_values[i];}
		
		///définition de l'opérateur [] pour un PAbstractVect3 constant
		/**	@param i : indice de l'élément du PAbstractVect3 que l'on veut retourner
		* 	@return valeur de l'élément du PAbstractVect3
		*/
		const T & operator[] (long unsigned int i) const{return p_values[i];}
		
		///Définition de l'opérateur parenthèse pour être compatible avec le parcours des expressions template
		/**	@param r : valeur de l'élément que l'on veut retourner
		 * 	@param i : indice de l'élément que l'on veut récupérer
		*/
		void operator () (T & r, long unsigned int i) const{r = p_values[i];}
		
		PAbstractVect3 &  operator = (const PAbstractVect3<T> & vect);
		PAbstractVect3 &  operator += (const PAbstractVect3<T> & vect);
		PAbstractVect3 & operator -= (const PAbstractVect3<T> & vect);
		PAbstractVect3 & operator *= (const T & scal);
		PAbstractVect3 & operator /= (const T & scal);
		PAbstractVect3 operator -() const;
		
		void setComposante(const T & x);
		void setComposante(const T & x, const T & y);
		void setComposante(const T & x, const T & y, const T & z);
		
		void setX(const T & x);
		void setY(const T & y);
		void setZ(const T & z);
		
		void addX(const T & dx);
		void addY(const T & dy);
		void addZ(const T & dz);
		
		void sousX(const T & dx);
		void sousY(const T & dy);
		void sousZ(const T & dz);
		
		void scaleX(const T & sx);
		void scaleY(const T & sy);
		void scaleZ(const T & sz);
		void scale(const T & sx, const T & sy, const T & sz);
		
		T getX() const;
		T & getX();
		T getY() const;
		T & getY();
		T getZ() const;
		T & getZ();
		
//////////////////////////////////////////////////////////////////
//                                                              //
//          Opérateurs amis de la classe PAbstractVect3         //
//                                                              //
//////////////////////////////////////////////////////////////////
		
		///Définition du produit scalaire entre deux PAbstractVect3
		/**	@param vect1  : PAbstractVect3
		* 	@param vect2 : PAbstractVect3
		* 	@return T, produit scalaire de vect1 et vect2
		* 	C'est vrai que dans ce cas on n'utilise pas les expressions templates, mais on a besoin d'un temporaire, car c'est un scalaire, et faire plusieur fois le même calcul ne serait pas constructif
		*/
		friend T operator * (const PAbstractVect3<T> & vect1, const PAbstractVect3<T> & vect2){
			return vect1.p_values[0]*vect2.p_values[0] + vect1.p_values[1]*vect2.p_values[1] + vect1.p_values[2]*vect2.p_values[2];
		}
		
		///Définition de l'addition de deux Vecteur3
		/**	@param vect1 : Vecteur3
			@param vect2 : Vecteur3
			@return Vecteur3 addition de vect1 + vect2
		*/
		friend PAbstractVect3<T> operator + (const PAbstractVect3<T> & vect1, const PAbstractVect3<T> & vect2){
			PAbstractVect3<T> vect3(vect1.p_values[0] + vect2.p_values[0], vect1.p_values[1] + vect2.p_values[1], vect1.p_values[2] + vect2.p_values[2]);
			return vect3;
		}
		
		///Définition de la soustraction de deux Vecteur3, const à droite
		/**	@param vect1 : Vecteur3
			@param vect2 : Vecteur3
			@return Vecteur3 soustraction de vect1 - vect2
		*/
		friend PAbstractVect3<T> operator - (const PAbstractVect3<T> & vect1, const PAbstractVect3<T> & vect2){
			PAbstractVect3<T> vect3(vect1.p_values[0] - vect2.p_values[0], vect1.p_values[1] - vect2.p_values[1], vect1.p_values[2] - vect2.p_values[2]);
			return vect3;
		}
		
		///mutiplication par un scalaire à droite
		/**	Définition de la multiplication par un scalaire à droite
			@param vect : Vecteur3
			@param scal : scalaire
			@return Vecteur3 produit de vect1*scal
		*/
		friend PAbstractVect3<T> operator * (const PAbstractVect3<T> & vect, const T & scal){
			PAbstractVect3<T> vect2(vect.p_values[0]*scal, vect.p_values[1]*scal, vect.p_values[2]*scal);
			return vect2;
		}

		///mutiplication par un scalaire à gauche
		/**	Définition de la multiplication par un scalaire à gauche
			@param scal : scalaire
			@param vect : Vecteur3
			@return Vecteur3 produit de scal*vect1
		*/
		friend PAbstractVect3<T> operator * (const T & scal, const PAbstractVect3<T> & vect){
			PAbstractVect3<T> vect2(vect.p_values[0]*scal, vect.p_values[1]*scal, vect.p_values[2]*scal);
			return vect2;
		}
		
		///	division par un scalaire
		/**	@param vect : Vecteur3
			@param scal : scalaire
			@return Vecteur3 division de vect1/scal
		*/
		friend PAbstractVect3<T> operator / (const PAbstractVect3<T> & vect, const T & scal){
			PAbstractVect3<T> vect2(vect.p_values[0]/scal, vect.p_values[1]/scal, vect.p_values[2]/scal);
			return vect2;
		}

		///	Définition  du produit vectoriel
		/**	@param vect1 : Vecteur3
			@param vect2 : Vecteur3
			@return Vecteur3 produit vectoriel vect1^vect2
		*/
		friend PAbstractVect3<T> operator ^ (const PAbstractVect3<T> & vect1, const PAbstractVect3<T> & vect2){
			PAbstractVect3<T> vect(vect1.p_values[1]*vect2.p_values[2] - vect1.p_values[2]*vect2.p_values[1], -vect1.p_values[0]*vect2.p_values[2] + vect1.p_values[2]*vect2.p_values[0], vect1.p_values[0]*vect2.p_values[1] - vect1.p_values[1]*vect2.p_values[0]);
			return vect;
		}
		
		///Définition de l'égalité entre deux PAbstractVect3
		/**	@param vect1 : PAbstractVect3
		* 	@param vect2 : PAbstractVect3
		* 	@return true si vect1 est égale vect2, false sinon
		*/
		friend bool operator == (const PAbstractVect3<T> & vect1, const PAbstractVect3<T> & vect2){
			return (abstractEqual(vect1.p_values[0], vect2.p_values[0]) && abstractEqual(vect1.p_values[1], vect2.p_values[1]) && abstractEqual(vect1.p_values[2], vect2.p_values[2]));
		}

		///Définition de l'inégalité entre deux PAbstractVect3
		/**	@param vect1 : PAbstractVect3
		* 	@param vect2 : PAbstractVect3
		* 	@return true si vect1 est différent vect2, false sinon
		*/
		friend bool operator != (const PAbstractVect3<T> & vect1, const PAbstractVect3<T> & vect2){
			return (!abstractEqual(vect1.p_values[0], vect2.p_values[0]) || !abstractEqual(vect1.p_values[1], vect2.p_values[1]) || !abstractEqual(vect1.p_values[2], vect2.p_values[2]));
		}

		///permet l'affichage d'un vecteur dans la console
		/**	@param out : sortie de la console
		* 	@param vecteur : PAbstractVect3 que l'on veut afficher
		* 	@return sortie de la console avec le PAbstractVect3
		*/
		friend std::ostream & operator << (std::ostream & out, const PAbstractVect3<T> & vecteur){
			out << vecteur.p_values[0] << " " << vecteur.p_values[1] << " " << vecteur.p_values[2];
			return out;
		}
		
		///permet l'initialisation d'un PAbstractVect3 dans la console où avec un fichier de config
		/**	@param in : entrée standart de la console (cin)
			@param v : PAbstractVect3 à initialiser
		*/
		friend std::istream & operator >> (std::istream & in, PAbstractVect3<T> & v){
			in >> v.p_values[0] >> v.p_values[1]  >> v.p_values[2];
			return in;
		}

	private:
		void copyPAbstractVect3(const PAbstractVect3<T> & other);
		///composantes de la classe PAbstractVect3
		T p_values[3];
};

#include "PAbstractVect3_impl.h"

#endif