#include <iostream>
#include <duchamp/duchamp.hh>
#include <duchamp/DataArrays/DataArrayBase.hh>

namespace duchamp {

    template <class T> 
    DataArrayBase<T>::DataArrayBase():
	itsDim()
    {
	this->setup();
    }
  
    template <class T>
    DataArrayBase<T>::DataArrayBase(std::vector<size_t> dim):
	itsDim(dim)
    {
	this->setup();
    }

    template <class T>
    DataArrayBase<T>::DataArrayBase(const DataArrayBase<T>& other)
    {
	this->operator=(other);
    }
  
    template <class T>
    DataArrayBase<T>& DataArrayBase<T>::operator= (const DataArrayBase<T>& other)
    {
	if(this==&other) return *this;
	if(this->itsNumPixels > 0){
	    delete [] this->itsArray;
	    this->itsNumPixels = 0;
	}
	this->itsDim = other.itsDim;
	this->itsNumPixels = other.itsNumPixels;

	size_t product=(this->itsDim.size()>0)?1:0;
	for(size_t i=0;i<this->itsDim.size();i++) product *= this->itsDim[i];
	if(product!=this->itsNumPixels) DUCHAMPTHROW("DataArrayBase","Pixel size mismatch");

	if(this->itsNumPixels > 0){
	    this->itsArray = new T[this->itsNumPixels];
	    for(size_t i=0;i<this->itsNumPixels;i++) this->itsArray[i] = other.itsArray[i];
	}

	return *this;
    }

    template <class T>
    DataArrayBase<T>::~DataArrayBase()
    {
	if(this->itsNumPixels > 0)
	    delete [] this->itsArray;
    }
  
    template <class T>
    void DataArrayBase<T>::setup()
    {
	this->itsArray = 0;
	this->itsNumPixels = 0;
	if(this->itsDim.size()>0){
	    this->itsNumPixels = this->itsDim[0];
	    for(size_t i=1;i<this->itsDim.size();i++) this->itsNumPixels *= this->itsDim[i];
	    if(this->itsNumPixels>0) this->itsArray = new T[this->itsNumPixels];
	}
    }

    template <class T>
    size_t DataArrayBase<T>::pixArrayToPos(size_t *pix)
    {
	size_t loc=0,dimfactor=1;
	for(size_t i=0;i<this->itsDim.size();i++){
	    loc += dimfactor*pix[i];
	    dimfactor *= this->itsDim[i];
	}
	return loc;
    }

    template <class T>
    size_t DataArrayBase<T>::pixVecToPos(std::vector<size_t> pix)
    {
	size_t loc=0,dimfactor=1;
	for(size_t i=0;i<this->itsDim.size();i++){
	    loc += dimfactor*pix[i];
	    dimfactor *= this->itsDim[i];
	}
	return loc;
    }

    template <class T>
    T DataArrayBase<T>::operator()(size_t pix)
    {
	T val=T(0);
	if(this->itsNumPixels>0){
	    if(pix<this->itsNumPixels) val = this->itsArray[pix];
	    else DUCHAMPTHROW("DataArrayBase","Overflow in pixel request: Requested pixel " << pix << " from array of size " << this->itsNumPixels);
	}
	else this->throwInitErr();
	return val;
    }

    template <class T>
    T DataArrayBase<T>::operator()(size_t *pix)
    {
	if(this->itsNumPixels>0){
	    return this->operator()(pixArrayToPos(pix));
	}
	else this->throwInitErr();
    }

    template <class T>
    T DataArrayBase<T>::operator()(std::vector<size_t> pix)
    {
	T val=T(0);
	if(this->itsNumPixels>0){
	    if(pix.size() != this->itsDim.size()) DUCHAMPTHROW("DataArrayBase","Pixel dimensions do not match array dimensions");
	    val = this->operator()(pixVecToPos(pix));
	}
	else this->throwInitErr();
	return val;
    }

    template <class T>
    void DataArrayBase<T>::operator+=(T val)
    {
	if(this->itsNumPixels>0){
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] += val;
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    void DataArrayBase<T>::operator+=(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] += other.itsArray[i];
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    void DataArrayBase<T>::operator*=(T val)
    {
	if(this->itsNumPixels>0){
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] *= val;
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    void DataArrayBase<T>::operator*=(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] *= other.itsArray[i];
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    void DataArrayBase<T>::operator-=(T val)
    {
	if(this->itsNumPixels>0){
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] -= val;
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    void DataArrayBase<T>::operator-=(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] -= other.itsArray[i];
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    void DataArrayBase<T>::operator/=(T val)
    {
	if(this->itsNumPixels>0){
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] /= val;
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    void DataArrayBase<T>::operator/=(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    for(size_t i=0;i<this->itsNumPixels;i++){
		this->itsArray[i] /= other.itsArray[i];
	    }
	}
	else this->throwInitErr();
    }

    template <class T>
    DataArrayBase<T> DataArrayBase<T>::operator+(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    DataArrayBase<T> result(this->itsDim);
	    for(size_t i=0;i<this->itsNumPixels;i++){
		result[i] = this->itsArray[i] + other.itsArray[i];
	    }
	    return result;
	}
	else this->throwInitErr();
	
    }

    template <class T>
    DataArrayBase<T> DataArrayBase<T>::operator-(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    DataArrayBase<T> result(this->itsDim);
	    for(size_t i=0;i<this->itsNumPixels;i++){
		result[i] = this->itsArray[i] - other.itsArray[i];
	    }
	    return result;
	}
	else this->throwInitErr();
	
    }

    template <class T>
    DataArrayBase<T> DataArrayBase<T>::operator*(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    DataArrayBase<T> result(this->itsDim);
	    for(size_t i=0;i<this->itsNumPixels;i++){
		result[i] = this->itsArray[i] * other.itsArray[i];
	    }
	    return result;
	}
	else this->throwInitErr();
	
    }

    template <class T>
    DataArrayBase<T> DataArrayBase<T>::operator/(DataArrayBase &other)
    {
	if(this->itsNumPixels>0){
	    if(this->itsNumPixels != other.itsNumPixels) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different sizes");
	    if(this->itsDim != other.itsDim) 
		DUCHAMPTHROW("DataArrayBase", "Arrays of different shapes");
	    DataArrayBase<T> result(this->itsDim);
	    for(size_t i=0;i<this->itsNumPixels;i++){
		result[i] = this->itsArray[i] / other.itsArray[i];
	    }
	    return result;
	}
	else this->throwInitErr();
	
    }


}