/***************************************

	Auteur : Pierre Aubert

	Mail : pierre.aubert@lapp.in2p3.fr

	Licence : CeCILL-C

****************************************/

#ifndef __PTENSOR_H__

#define __PTENSOR_H__

#include <stdio.h>

#include "data_all.h"

#include "template_alloc.h"

#include "reshuffle_tensor.h"

#include "phoenix_assume_aligned.h"

#include "phoenix_transpose.h"

template<typename T>

class PBlock;

///@brief Deal with general tensor, allocation and other stuff

template<typename T>

class PTensor{

	public:

		PTensor(AllocMode::AllocMode allocMode, size_t nbElement);

		PTensor(AllocMode::AllocMode allocMode, size_t nbRow, size_t nbCol);

		PTensor(AllocMode::AllocMode allocMode, size_t nbSlice, size_t nbRow, size_t nbCol);

		PTensor(AllocMode::AllocMode allocMode = AllocMode::NONE, const size_t * tabShape = NULL, size_t nbDim = 0lu);

		PTensor(const PTensor<T> & other);

		virtual ~PTensor();

		PTensor & operator = (const PTensor<T> & other);

		bool reserve(const size_t * tabDim, size_t nbDim);

		bool resize(const size_t * tabDim, size_t nbDim);

		bool reserve(AllocMode::AllocMode allocMode, const size_t * tabDim, size_t nbDim);

		bool resize(AllocMode::AllocMode allocMode, const size_t * tabDim, size_t nbDim);

		bool resize(AllocMode::AllocMode allocMode, size_t nbValue);

		bool resize(AllocMode::AllocMode allocMode, size_t nbRow, size_t nbCol);

		bool resize(AllocMode::AllocMode allocMode, size_t nbSlice, size_t nbRow, size_t nbCol);

		bool fromFile(const std::string & fileName, AllocMode::AllocMode allocMode = AllocMode::NONE);

		void setAllocMode(AllocMode::AllocMode allocMode);

		void copyPointer(T * tabData, size_t * tabDim, size_t nbDim, bool isAligned, size_t padding);

		void fill(T value);

		void setData(const T * tabValue, size_t nbValue);

		void setData(const T * tabValue, size_t nbRow, size_t nbCol);

		void setValue(size_t index, T value);

		void setValue(size_t indexRow, size_t indexCol, T value);

		void setPaddingValue(T value);

		T getPaddingValue() const;

		void setNbVecNeighbour(size_t nbNeighbour);

		size_t getNbVecNeighbour() const;

		void fromScalToVecNeigbhour(const PTensor<T> & tensorScal);

		void fromScalToVecNeigbhour(const PTensor<T> & tensorScal, size_t vectorSize);

		void fromVecToScalNeigbhour(const PTensor<T> & tensorVec);

		void updateDupplicateVecNeighbour();

		void splitBlock(std::vector<PBlock<T> > & vecBlock, size_t blockSizeRow, size_t blockSizeCol, size_t neighborRing = 0lu) const;

		void mergeBlock(const std::vector<PBlock<T> > & vecBlock, size_t neighborRing = 0lu);

		void splitBlockLink(std::vector<PBlock<T> > & vecBlock, size_t blockSizeRow, size_t blockSizeCol, size_t neighborRing = 0lu) const;

		size_t getNbDim() const;

		size_t getFullSize() const;

		size_t getPadding() const;

		bool isAligned() const;

		size_t getNbCol() const;

		size_t getFullNbRow() const;

		AllocMode::AllocMode getAllocMode() const;

		const size_t * getShape() const;

		const T * getData() const;

		T * getData();

		const T & getValue(size_t index) const;

		T & getValue(size_t index);

		const T & getValue(size_t indexRow, size_t indexCol) const;

		T & getValue(size_t indexRow, size_t indexCol);

		///Opérator [] to get an element of the tensor

		/**	@param i : index of the element to be returned

		* 	@return i-th element of the tensor

		*/

		T & operator[] (size_t i){return p_tabData[i];}

		///Opérator [] to get an element of the tensor

		/**	@param i : index of the element to be returned

		* 	@return i-th element of the tensor

		*/

		const T & operator[] (size_t i) const{return p_tabData[i];}

		///Print the PTensor

		/**	@param other : PTensor to be printed

		 * 	@param[out] out : stream to be modified

		 * 	@return modified stream

		*/

				}

						}

					}

				}else{

				}

		}

		///Save the current PTensor in a stream

		/**	@param[out] ds : stream to be used

		 * 	@return true on success, false otherwise

		*/

		template<typename Stream>

			//Save the number of dimension of the tensor

			//Then save the dimension size

			//Save the alloc mode (do NOT remove the temporary, or you have to specialised a DataStream for the AllocMode::AllocMode)

			//If the data type is a simple data, then we save it with a fast way

				}else{				//If there is a padding, we save row by row

					}

				}

			}else{	//If it is not a simple type, we save it element per element

				}

			}

		}

		///Load the current PTensor with a stream

		/**	@param[out] ds : stream to be used

		 * 	@return true on success, false otherwise

		*/

		template<typename Stream>

			//Get the number of dimensions

			//Load the dimension size

			//Get the alloc mode (do NOT remove the temporary, or you have to specialised a DataStream for the AllocMode::AllocMode)

			//Some relevant function call

			//If the data type is a simple data, then we load it with a fast way

				}else{				//If there is a padding, we load row by row

					}

				}

			}else{	//If it is not a simple type, we load it element per element

				}

			}

		}

	protected:

		void copyPTensor(const PTensor<T> & other);

		///Number of dimension of the PTensor

		size_t p_nbDimension;

	private:

		void initialisationPTensor(AllocMode::AllocMode allocMode, const size_t * tabShape, size_t nbDim);

		void freeTabData();

		void copyTensorToBlock(PBlock<T> & block, size_t tensorNbCol, size_t blockSizeRow, size_t blockSizeCol,

					size_t fullBlockSizeRow, size_t fullBlockSizeCol, size_t i, size_t j, size_t neighborRing) const;

		void linkTensorToBlock(PBlock<T> & block, size_t tensorNbCol, size_t blockSizeRow, size_t blockSizeCol,

					size_t fullBlockSizeRow, size_t fullBlockSizeCol, size_t i, size_t j, size_t neighborRing) const;

		void updateBlockSize(size_t & nbTotalBlock, size_t & nbInBlockRow, size_t & nbInBlockCol,

					size_t & sizeLastInBlockRow, size_t & sizeLastInBlockCol,

					std::vector<PBlock<T> > & vecBlock, size_t blockSizeRow, size_t & blockSizeCol, size_t neighborRing) const;

		///Table of data

		T* p_tabData;

		///Size of each dimension of the PTensor

		size_t* p_shape;

		///Full number of elements of the tensor

		size_t p_fullSize;

		///Full number of elements of the tensor taking account the padding

		size_t p_fullPaddedSize;

		///Number of element on the last dimension of the PTensor

		size_t p_nbCol;

		///Full number of rows (including all dimensions except the very last one)

		size_t p_fullNbRow;

		///Number of elements which are neighbours together with the next ones (scalar: 1, vectorial: n)

		size_t p_nbNeighbour;

		///Number of rows in scalar mode

		size_t p_nbScalRow;

		///Reserved number of dimension of the PTensor

		size_t p_reservedNbDimension;

		///Reserved size of each dimension of the PTensor

		size_t* p_reservedShape;

		///Padding of the PTensor

		size_t p_padding;

		///True if the PTensor is aligned, false otherwise

		bool p_isAligned;

		///Allocation mode

		AllocMode::AllocMode p_allocMode;

		///True if the PTensor own the shape and data pointers

		bool p_isOwnData;

};

AllocMode::AllocMode tensor_getAllocMode(bool isAligned, size_t padding);

void splitBlockSize(size_t & nbInBlockRow, size_t & sizeLastInBlockRow, size_t & blockSizeRow, size_t nbRow, size_t neighborRing, size_t vectorNeigbour);

#include "PTensor_impl.h"

#include "PBlock.h"

#endif