#ifndef __PBASE_EXPRESSION_TEMPLATE_ITERATOR_H__
#define __PBASE_EXPRESSION_TEMPLATE_ITERATOR_H__


///Les opérateurs des expressions template générales
enum Operators{
	Add,   // addition
	Sub,   // soustraction
	Mult,  // multiplication
	Div,   // division
	Plus,  // + unaire
	Minus, // - unaire
	Const  // Constante
};

////////////////////////////////////////////////////////////////////////
//                                                                    //
//   Les opérateurs unitaires de nos expressions template génératles  //
//                                                                    //
////////////////////////////////////////////////////////////////////////

///Modèle de classe pour nos opérateurs unaires
template <class T, int Op>
struct UnaryOp {};

/// Classe de base pour nos opérateurs unaires
template <class T>
struct UnaryOpBase{
	UnaryOpBase(T t) : It(t) {}
	inline void operator ++(){++It;}
	T It;
};

/////////////////////////////////////////////////////////////
//                                                         //
//   Spécialisation des UnaryOp pour tous les opérateurs   //
//                                                         //
/////////////////////////////////////////////////////////////

///Spécialisation pour le moins unaire
template <class T>
struct UnaryOp<T, Minus> : public UnaryOpBase<T>{
	UnaryOp(T t) : UnaryOpBase<T>(t){}
	inline double operator *(){return -(*UnaryOpBase<T>::It);}
};

///Spécialisation pour les constantes
template <class T>
struct UnaryOp<T, Const> : public UnaryOpBase<T>{
	UnaryOp(T t) : UnaryOpBase<T>(t) {}
	inline void operator ++(){}
	inline double operator *(){return UnaryOpBase<T>::It;}
};

///Modèle de classe pour nos opérateurs binaires
template <class T, class U, int Op>
struct BinaryOp{
	inline double operator *(){return UnaryOpBase<T>::It;}
};

///Classe de base pour nos opérateurs binaires
template <class T, class U>
struct BinaryOpBase{
	BinaryOpBase(T I1, U I2) : It1(I1), It2(I2) {}
	inline void operator ++(){++It1; ++It2;}
	inline double operator *(){return *It1 + *It2;}
	T It1;
	U It2;
};

//////////////////////////////////////////////////////////////
//                                                          //
//   Spécialisation des BinaryOp pour tous les opérateurs   //
//                                                          //
//////////////////////////////////////////////////////////////

///Spécialisation pour l'addition
template <class T, class U>
struct BinaryOp<T, U, Add> : public BinaryOpBase<T, U>{
	BinaryOp(T I1, U I2) : BinaryOpBase<T, U>(I1, I2){}
	inline double operator *() {return *BinaryOpBase<T, U>::It1 + *BinaryOpBase<T, U>::It2;}
};

///Spécialisation pour la multiplication
template <class T, class U>
struct BinaryOp<T, U, Mult> : public BinaryOpBase<T, U>{
	BinaryOp(T I1, U I2) : BinaryOpBase<T, U>(I1, I2){}
	inline double operator *() {return *BinaryOpBase<T, U>::It1 * *BinaryOpBase<T, U>::It2;}
};

///Spécialisation pour la division
template <class T, class U>
struct BinaryOp<T, U, Sub> : public BinaryOpBase<T, U>{
	BinaryOp(T I1, U I2) : BinaryOpBase<T, U>(I1, I2){}
	inline double operator *() {return *BinaryOpBase<T, U>::It1 - *BinaryOpBase<T, U>::It2;}
};

///Spécialisation pour la division
template <class T, class U>
struct BinaryOp<T, U, Div> : public BinaryOpBase<T, U>{
	BinaryOp(T I1, U I2) : BinaryOpBase<T, U>(I1, I2){}
	inline double operator * () {return *BinaryOpBase<T, U>::It1 / *BinaryOpBase<T, U>::It2;}
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//   fonctions qui permettent de simplifier la surcharge des opérateurs   //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

///Simplification de la surchage de l'addition
template <class T, class U>
inline BinaryOp<T, U, Add> MakeAdd(const T& t, const U& u){
	return BinaryOp<T, U, Add>(t, u);
}

///Simplification de la surchage de la soustraction
template <class T, class U>
inline BinaryOp<T, U, Sub> MakeSub(const T& t, const U& u){
	return BinaryOp<T, U, Sub>(t, u);
}

///Simplification de la surchage de la multiplication
template <class T, class U>
inline BinaryOp<T, U, Mult> MakeMult(const T& t, const U& u){
	return BinaryOp<T, U, Mult>(t, u);
}

///Simplification de la surchage de la division
template <class T, class U>
inline BinaryOp<T, U, Div> MakeDiv(const T& t, const U& u){
	return BinaryOp<T, U, Div>(t, u);
}

///Simplification de la surchage de la négation
template <class T>
inline UnaryOp<T, Minus> MakeMinus(const T& t){
	return UnaryOp<T, Minus>(t);
}

///Simplification de la surchage de la constante
template <class T>
inline UnaryOp<T, Const> MakeConst(const T& t){
	return UnaryOp<T, Const>(t);
}

//////////////////////////////////////////
//                                      //
//       Surcharge des opérateurs       //
//                                      //
//////////////////////////////////////////

//////////////////////////////////////////////////////////////////
//                                                              //
//       Surcharge des opérateurs pour des types abstraits      //
//                                                              //
//////////////////////////////////////////////////////////////////

///Surcharge de l'opérateur + pour deux types abstraits
template <class T, class U>
BinaryOp<T, U, Add> operator +(const T& v1, const U& v2){
	return MakeAdd(v1, v2);
}

///Surcharge de l'opérateur - pour deux types abstraits
template <class T, class U>
BinaryOp<T, U, Sub> operator - (const T& v1, const U& v2){
	return MakeSub(v1, v2);
}

// Surcharge de l'opérateur - pour un type abstrait
template <class T>
UnaryOp<T, Minus> operator - (const T& v1){
	return MakeMinus(v1);
}

///Surcharge de l'opérateur * pour un type abstrait à gauche et un double (en dur je sais, mais c'est déja bien pour faire des tests)
template <class T>
BinaryOp<T, UnaryOp<double, Const>, Mult> operator * (const T& v1, double d){
	return MakeMult(v1, MakeConst(d));
}

///Surcharge de l'opérateur * pour un type abstrait à droite et un double (en dur je sais, mais c'est déja bien pour faire des tests)
template <class T>
BinaryOp<UnaryOp<double, Const>, T, Mult> operator * (double d, const T& v1){
	return MakeMult(MakeConst(d), v1);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                 //
//   Macros qui définissent la surcharge des opérateurs pour un type quelconque et son itérateur   //
//                                                                                                 //
/////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////
//                                //
//   Ce qui conserne l'addition   //
//                                //
////////////////////////////////////

//Macro qui permet de définir la surchage de l'opérateur + à gauche pour un type définit, et son iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_ADD_LEFT(TYPE,TYPECONSTITERATOR) template<class T> BinaryOp<TYPECONSTITERATOR, T, Add> operator +(const TYPE& v1, const T& v2){return MakeAdd(v1.begin(), v2);}

//Macro qui permet de définir la surchage de l'opérateur + à droite pour un type définit, et son iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_ADD_RIGHT(TYPE,TYPECONSTITERATOR) template <class T> BinaryOp<T, TYPECONSTITERATOR, Add> operator +(const T& v1, const TYPE& v2){return MakeAdd(v1, v2.begin());}

//Macro qui permet de définir la surchage de l'opérateur + pour deux types définis, et leur iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_ADD_TYPE(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, TYPECONSTITERATOR, Add> operator +(const TYPE& v1, const TYPE& v2){return MakeAdd(v1.begin(), v2.begin());}

/////////////////////////////////////////
//                                     //
//   Ce qui conserne la soustraction   //
//                                     //
/////////////////////////////////////////

//Macro qui permet de définir la surchage de l'opérateur - pour deux types définis, et leur iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_SUB_TYPE(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, TYPECONSTITERATOR, Sub> operator - (const TYPE& v1, const TYPE& v2){return MakeSub(v1.begin(), v2.begin());}

///////////////////////////////////////////
//                                       //
//   Ce qui conserne la multiplication   //
//                                       //
///////////////////////////////////////////

//Macro qui permet de définir la surchage de l'opérateur * à gauche pour un type définit, et son iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_MULT_LEFT(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, UnaryOp<double, Const>, Mult> operator * (const TYPE& v1, double d){return MakeMult(v1.begin(), MakeConst(d));}

//Macro qui permet de définir la surchage de l'opérateur * à droite pour un type définit, et son iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_MULT_RIGHT(TYPE,TYPECONSTITERATOR) BinaryOp<UnaryOp<double, Const>, TYPECONSTITERATOR, Mult> operator * (double d, const TYPE& v1){return MakeMult(MakeConst(d), v1.begin());}

//Macro qui permet de définir la surchage de l'opérateur / à droite pour un scalaire (ici un double), et son iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_DIV_SCAL(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, UnaryOp<double, Const>, Div> operator / (const TYPE& v1, double d){return MakeDiv(v1.begin(), MakeConst(d));}

//Macro qui permet de définir la surchage de l'opérateur - (pour définir l'opposé d'un type), et son iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_MINUS(TYPE,TYPECONSTITERATOR) UnaryOp<TYPECONSTITERATOR, Minus> operator - (const TYPE& v1){return MakeMinus(v1.begin());}

////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                        //
//   Et maintenant une grosse macro de fainéant qui permet de tout faire d'un seul coup   //
//                                                                                        //
////////////////////////////////////////////////////////////////////////////////////////////

//Macro qui permet de définir la surchage de tout les opérateurs pour un type, et son iterateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_ALL_OP(TYPE,TYPECONSTITERATOR) PSURCHAGE_IT_TYPE_OP_ADD_LEFT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_ADD_RIGHT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_ADD_TYPE(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_SUB_TYPE(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_MULT_LEFT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_MULT_RIGHT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_DIV_SCAL(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_MINUS(TYPE,TYPECONSTITERATOR)

#endif