// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_array
#define tools_array

#ifdef TOOLS_MEM
#include "mem"
#endif

#include <vector>
#include <string>

namespace tools {

// array handles an hyperparallelepiped of cells of class T.

template <class T>
class array {
public:
  static const std::string& s_class() {
    static const std::string s_v("tools::array");
    return s_v;
  }
public:
  typedef typename std::vector< std::pair<unsigned int,unsigned int> > cut_t;
  typedef typename std::vector<unsigned int> uints_t;
  typedef typename std::vector<T>::iterator vec_it_t;
  typedef typename std::vector<T>::const_iterator cons_vec_it_t;
public:
  array() {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }
  array(const uints_t& a_orders) {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    configure(a_orders);
  }
  array(unsigned int a_dimension,unsigned int a_order) { 
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    // A hypercube of dimension "a_dimension" and size "a_order".
    uints_t _orders(a_dimension);
    for(unsigned int index=0;index<a_dimension;index++) 
      _orders[index] = a_order;
    configure(_orders);
  } 
  virtual ~array() {
#ifdef TOOLS_MEM
    mem::decrement(s_class().c_str());
#endif
  }
public:
  array(const array& a_from)
  :m_orders(a_from.m_orders)
  ,m_offsets(a_from.m_offsets)
  ,m_vector(a_from.m_vector)
  ,m_is(a_from.m_is){
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }
  array& operator=(const array& a_from) {
    m_orders = a_from.m_orders;
    m_offsets = a_from.m_offsets;
    m_vector = a_from.m_vector;
    m_is = a_from.m_is;
    return *this;
  }
public: //operators:
  array& operator*=(const T& a_T) {multiply(a_T);return *this;}    
  bool operator==(const array& a_array) const {
    return equal(a_array);
  }
  bool operator!=(const array& a_array) const {
    return !operator==(a_array);
  }
  array operator*(const T& a_T) const {
    array a(*this);
    a.multiply(a_T);
    return a;
  }    
  // the below would need exception to do it properly.
  //array operator+(const array& a_array) const {
  //  array a(*this);
  //  if(!a.add(a_array)) {} //throw
  //  return a;
  //}    
  //array& operator+=(const array& a_array) {   
  //  if(!add(a_array)) {} //throw
  //  return *this;
  //}    
public:
  void copy(const array& a_from) {
    m_orders = a_from.m_orders;
    m_offsets = a_from.m_offsets;
    m_vector = a_from.m_vector;
    m_is = a_from.m_is;
  }
  void clear() {
    m_orders.clear();
    m_offsets.clear();
    m_vector.clear();
    m_is.clear();
  }
  bool configure(const uints_t& a_orders) {
    m_orders = a_orders;
    size_t dim = m_orders.size();
    if(dim==0) {
      clear();
      return false;
    }
    unsigned int _size = 1;
    for(size_t index=0;index<dim;index++) {
      //if(m_orders[index]<0) {
      //clear();
      //return false;
      //}
      _size *= m_orders[index];
    }
    m_vector.resize(_size);
    m_vector.assign(_size,zero());
    m_offsets.resize(dim,0);
    m_offsets[0] = 1;
    for(size_t iaxis=1;iaxis<dim;iaxis++) 
      m_offsets[iaxis] = m_offsets[iaxis-1] * m_orders[iaxis-1];
    m_is.resize(dim);
    m_is.assign(dim,0);
    return true;
  }
  size_t dimension() const { return m_orders.size();}
  const uints_t& orders() const { return m_orders;}
  size_t size() const {return m_vector.size();}
  bool set_value(const uints_t& a_is,const T& a_value) {
    unsigned int off = 0;
    if(!offset(a_is,off)) return false;
    m_vector[off] = a_value;
    return true;
  }
  bool value(const uints_t& a_is,T& a_value) const {
    unsigned int off = 0;
    if(!offset(a_is,off)) {
      a_value = 0;
      return false;
    }
    a_value = m_vector[off];
    return true;
  }
  T value_no_check(const uints_t& a_is) const { //TOUCHY
    unsigned int off = 0;
    if(!offset(a_is,off)) {}
    return m_vector[off];
  }
  void reset() {
    for(vec_it_t it=m_vector.begin();it!=m_vector.end();++it) *it = 0;
  }
  const std::vector<T>& vector() const { return m_vector;}
  std::vector<T>& vector() { return m_vector;}
  bool fill(const std::vector<T>& a_values,cut_t* a_cut = 0) {
    size_t dsize = a_values.size();
    size_t di = 0;
    unsigned int index = 0;
    for(vec_it_t it=m_vector.begin();it!=m_vector.end();++it,index++) {
      if(!a_cut || (a_cut && accept(index,*a_cut)) ) {
        if(di>=dsize) return false; //a_values exhausted too early
        *it = a_values[di];
        di++;
      }
    }
    return true;
  }
  bool fill(unsigned int a_sz,const T* a_data,cut_t* a_cut = 0) {
    unsigned int di = 0;
    unsigned int index = 0;
    for(vec_it_t it=m_vector.begin();it!=m_vector.end();++it,index++) {
      if(!a_cut || (a_cut && accept(index,*a_cut)) ) {
        if(di>=a_sz) return false; //a_values exhausted too early
        *it = a_data[di];
        di++;
      }
    }
    return true;
  }
  // Related to other array :
  bool equal(const array& a_array) const {
    if(m_orders!=a_array.m_orders) return false;
    cons_vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    for(;it!=m_vector.end();++it,++ait) {
      if((*it)!=(*ait)) return false;
    }
    return true;
  }
  bool equal(const array& a_array,T aEpsilon) const {
    if(m_orders!=a_array.m_orders) return false;
    cons_vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    for(;it!=m_vector.end();++it,++ait) {
      T diff = (*it) - (*ait);      
      if(diff<0) diff *= -1;
      if(diff>=aEpsilon) return false;
    }
    return true;
  }
  bool is_proportional(const array& a_array,T& a_factor) const {
    // If true, then : a_array = a_factor * this.
    a_factor = zero();
    if(m_orders!=a_array.m_orders) return false;
    bool first = true;
    cons_vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    for(;it!=m_vector.end();++it,++ait) {
             if( ((*it)==zero()) && ((*ait)==zero())) {
        continue;
      } else if( ((*it)!=zero()) && ((*ait)==zero())) {
        return false;
      } else if( ((*it)==zero()) && ((*ait)!=zero())) {
        return false;
      } else {
        if(first) {
          a_factor = (*ait)/(*it);
          first = false;
        } else {
          if((*ait)!=(*it)*a_factor) return false;
        }
      }
    }
    return true;
  }
  bool add(const array& a_array,cut_t* a_cut = 0) {
    if(m_orders!=a_array.m_orders) return false;
    vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    unsigned int index = 0;
    for(;it!=m_vector.end();++it,++ait,index++) {
      if(!a_cut || (a_cut && accept(index,*a_cut)) ) {
        (*it) += (*ait);
      }
    }
    return true;
  }
  bool subtract(const array& a_array) {
    if(m_orders!=a_array.m_orders) return false;
    vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    for(;it!=m_vector.end();++it,++ait) (*it) -= (*ait);
    return true;
  }
  bool multiply(const array& a_array) {
    if(m_orders!=a_array.m_orders) return false;
    vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    for(;it!=m_vector.end();++it,++ait) (*it) *= (*ait);
    return true;
  }
  bool divide(const array& a_array) {
    if(m_orders!=a_array.m_orders) return false;
    bool status = true;
    vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    for(;it!=m_vector.end();++it,++ait) {
      if((*ait)==zero())  {
        (*it) = zero(); //PAW convention.
        status = false;
      } else {
        (*it) /= (*ait);
      }
    }
    return status;
  }
  bool contract(const array& a_array,T& a_value) const {
    a_value = zero();
    if(m_orders!=a_array.m_orders) return false;
    cons_vec_it_t it = m_vector.begin();
    cons_vec_it_t ait = a_array.m_vector.begin();
    for(;it!=m_vector.end();++it,++ait) a_value += (*it) * (*ait);
    return true;
  }
  //Else:
  void add(const T& a_T,cut_t* a_cut = 0) {
    unsigned int index = 0;
    for(vec_it_t it = m_vector.begin();it!=m_vector.end();++it,index++) {
      if(!a_cut || (a_cut && accept(index,*a_cut)) ) {
        (*it) += a_T;
      }
    }
  }
  void multiply(const T& a_T) {
    for(vec_it_t it = m_vector.begin();it!=m_vector.end();++it) (*it) *= a_T;
  }
  bool divide(const T& a_T) {
    if(a_T==zero()) return false;
    for(vec_it_t it = m_vector.begin();it!=m_vector.end();++it) (*it) /= a_T;
    return true;
  }
  bool invert() {
    bool status = true;
    T v_one = one();
    for(vec_it_t it = m_vector.begin();it!=m_vector.end();++it) {
      if((*it)==zero())  {
        (*it) = zero(); //PAW convention.
        status = false;
      } else {
        T _value = (*it); 
        (*it) = v_one/_value;
      }
    }
    return status;
  }
  bool offset(const uints_t& a_is,unsigned int& a_offset) const {
    size_t dim = m_orders.size();
    a_offset = 0;
    if(a_is.size()!=dim) return false;
    if(dim==0) return false;
    for(size_t iaxis=0;iaxis<dim;iaxis++) { 
      unsigned int i = a_is[iaxis];
      if(i>=m_orders[iaxis]) {
        a_offset = 0;
        return false;
      }
      a_offset += i * m_offsets[iaxis];
    }
    return true;
  }
  bool indices(unsigned int a_offset,uints_t& a_is) const {
    if(a_offset>=m_vector.size()) return false;
    size_t dim = m_orders.size();
    unsigned int off = a_offset;
    for(int iaxis=int(dim)-1;iaxis>=0;iaxis--) { 
      a_is[iaxis] = off/m_offsets[iaxis];
      off -= a_is[iaxis] * m_offsets[iaxis];
    }
    return true;
  }
  bool accept(unsigned int a_index,const cut_t& a_cut) const {
    size_t dim = m_orders.size();
    if(a_cut.size()!=dim) return false;
    if(!indices(a_index,const_cast<uints_t&>(m_is))) return false;
    bool good = true;
    for(size_t iaxis=0;iaxis<dim;iaxis++) { 
      if(m_is[iaxis]<a_cut[iaxis].first) {good = false;break;}
      if(m_is[iaxis]>a_cut[iaxis].second) {good = false;break;}
    }
    return good;
  }
  void set_constant(const T& a_v) {
    for(vec_it_t it = m_vector.begin();it!=m_vector.end();++it) (*it) = a_v;
  }
  void set_zero(){
    set_constant(zero());
  }
public:
  static T zero() {
    //return (T)0;    
    //return T(0);    
    return T();    
  }
  static T one() {
    //return (T)1;    
    return T(1);    
  }
  static T minus_one() {
    //return (T)-1;    
    return T(-1);    
  }
  static T two() {
    //return (T)2;    
    return T(2);    
  }
protected:
  uints_t m_orders;
  uints_t m_offsets;
  std::vector<T> m_vector;
  uints_t m_is;
};

}

#include <ostream>

// Helpers array<T> :
namespace tools {

template <class T>
inline bool contract(
 const array<T>& aA
,unsigned int aIA
,const array<T>& aB
,unsigned int aIB
,array<T>& aR
){
  // Contract a tensor (aA) with a vector (aB) 
  // on indice aIA of aA and aIB of aB.
  // aA.dimension must be > 1.
  // aB.dimension must be > 1.
  if(&aR==&aA) return false;
  if(&aR==&aB) return false;

  if(aA.dimension()==0) return false;
  if(aB.dimension()==0) return false;
  if(aIA>=aA.dimension()) return false;
  if(aIB>=aB.dimension()) return false;
  if(aA.orders()[aIA]!=aB.orders()[aIB]) return false;

  unsigned int rdima = aA.dimension()-1;
  unsigned int rdimb = aB.dimension()-1;

  if((rdima+rdimb)==0) {
    std::vector<unsigned int> rorders(1);
    rorders[0] = 1;   
    if(!aR.configure(rorders)) return false;
    const std::vector<T>& vA = aA.vector();
    const std::vector<T>& vB = aB.vector();
    T value = array<T>::zero();
    for(unsigned int index=0;index<vA.size();index++) {
      value += vA[index]*vB[index];
    }
    aR.vector()[0] = value;
    return true;
  }

  std::vector<unsigned int> rorders(rdima+rdimb);
  unsigned int index;
  for(index=0;index<aIA;index++) 
    rorders[index] = aA.orders()[index];
  for(index=aIA;index<rdima;index++) 
    rorders[index] = aA.orders()[index+1];

  for(index=0;index<aIB;index++) 
    rorders[rdima+index] = aB.orders()[index];
  for(index=aIB;index<rdimb;index++) 
    rorders[rdima+index] = aB.orders()[index+1];

  if(!aR.configure(rorders)) return false;

  std::vector<unsigned int> ais(aA.dimension());
  std::vector<unsigned int> bis(aB.dimension());
  std::vector<unsigned int> ris(aR.dimension());

  //FIXME : optimize the below.
  unsigned int order = aA.orders()[aIA];
  unsigned int rsize = aR.size();

  std::vector<T>& rvec = aR.vector();

  for(unsigned int roffset=0;roffset<rsize;roffset++) {
    if(!aR.indices(roffset,ris)) return false;

    for(index=0;index<aIA;index++) ais[index] = ris[index];
    for(index=aIA;index<rdima;index++) ais[index+1] = ris[index];

    for(index=0;index<aIB;index++) bis[index] = ris[rdima+index];
    for(index=aIB;index<rdimb;index++) bis[index+1] = ris[rdima+index];

    T value = 0;
    for(index=0;index<order;index++) {
      ais[aIA] = index;
      T av;
      if(!aA.value(ais,av)) return false;

      bis[aIB] = index;
      T bv;
      if(!aB.value(bis,bv)) return false;

      value += av * bv;
    }

    rvec[roffset] = value;
  }

  return true;
}

template <class T>
inline bool swap(
 const array<T>& aV
,unsigned int aI1
,unsigned int aI2
,array<T>& aR
){
  if(&aR==&aV) return false;

  unsigned int dim = aV.dimension();
  if(aI1>=dim) return false;
  if(aI2>=dim) return false;

  if(aI1==aI2) {
    aR.copy(aV);
    return true;
  }

  if(!aR.configure(aV.orders())) return false;

  std::vector<unsigned int> vis(aV.dimension());
  std::vector<unsigned int> ris(aV.dimension());

  const std::vector<T>& vvec = aV.vector();

  unsigned int size = aV.size();
  for(unsigned int offset=0;offset<size;offset++) {
    T value = vvec[offset];

    if(!aV.indices(offset,vis)) return false;
    unsigned int i = vis[aI1]; 
    vis[aI1] = vis[aI2]; 
    vis[aI2] = i; 
    if(!aR.set_value(vis,value)) return false;
  }

  return true;
}

//NOTE : print is a Python keyword.
template <class T> 
inline void dump(std::ostream& a_out,const tools::array<T>& a_array,const std::string& a_title){
  if(a_title.size()) a_out << a_title << std::endl;
  const std::vector<T>& vec = a_array.vector();
  typedef typename std::vector<T>::const_iterator cons_vec_it_t;
  for(cons_vec_it_t it = vec.begin();it!=vec.end();++it) {
    a_out << (*it) << std::endl;
  }
}

template <class T> 
inline void diff(std::ostream& a_out,const array<T>& aA,const array<T>& aB,T a_epsilon){
  if(aA.orders()!=aB.orders()) {
    a_out << "tools::arrays::diff : not same orders" << std::endl;
    return;
  }
  bool header_done = false;
  unsigned int dim = aA.dimension();
  std::vector<unsigned int> is(dim);
  unsigned int vsize = aA.vector().size();
  for(unsigned int index=0;index<vsize;index++) {
    T diff = aA.vector()[index]-aB.vector()[index];      
    if(diff<0) diff *= -1;
    if(diff>=a_epsilon) {
      aA.indices(index,is);
      if(!header_done) {
        a_out << "tools::arrays::diff :" << std::endl;
        header_done = true;
      }
      for(unsigned int i=0;i<dim;i++) a_out << is[i] << " ";
      a_out << aA.vector()[index] << " " << aB.vector()[index] << std::endl;
    }
  }
}

//////////////////////////////////////////////////////////////////////////////
/// common array /////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

template <class T>
class kronecker : public array<T> {
public:
  kronecker(unsigned int a_order):array<T>(a_order,a_order){
    //  epsilon(i1,i2,....in) with n = a_order and i in [0,n[.
    // Then an Array of a_order * a_order.
    unsigned int index = 0;
    typedef typename std::vector<unsigned int> _uints_t;
    _uints_t is(a_order);
    std::vector<T>& vec = array<T>::vector();
    typedef typename std::vector<T>::iterator _vec_it_t;
    _vec_it_t it = vec.begin();
    for(;it!=vec.end();++it,index++) {
      if(!array<T>::indices(index,is)) return; //FIXME throw.
      bool good = true;
     {for(unsigned int iaxis=0;iaxis<a_order;iaxis++) {
        unsigned int ival = is[iaxis];
        for(unsigned int iaxis2=iaxis+1;iaxis2<a_order;iaxis2++) {
          if(is[iaxis2]==ival) {
            good = false;
            break;
          }
        }
        if(!good) break;
      }}
      if(!good) continue;
      // All indicies are different.
      unsigned int n = 0;
      for(unsigned int iaxis=0;iaxis<a_order;) { 
        unsigned int ival = is[iaxis];
        if(ival!=iaxis) {
          // Swap and add one permutation :
          unsigned int old = is[ival];
          is[ival] = ival;
          is[iaxis] = old;
          n +=1;
        } else {
          iaxis++;
        }
      }
     {unsigned int n_2 = n/2;
      if(2*n_2==n) (*it) = array<T>::one();
      else (*it) = array<T>::minus_one();}
    }
  }
};

template <class T>
inline array<T> operator+(const array<T>& a1,const array<T>& a2) {
  array<T> res(a1);
  if(!res.add(a2)) {}
  return res;
}
template <class T>
inline array<T> operator-(const array<T>& a1,const array<T>& a2) {
  array<T> res(a1);
  if(!res.subtract(a2)) {}
  return res;
}
template <class T>
inline array<T> operator*(const T& a_fac,const array<T>& a_m) {
  array<T> res(a_m);
  res *= a_fac;
  return res;
}

}

#endif