#ifndef __GRID__
#define __GRID__

using XMLIOSERVER::XML::XMLNode;
using XMLIOSERVER::XML::THashAttributes;

namespace XMLIOSERVER
{
   class CGrid : public ObjectTemplate<CGrid>, public GridAttribut
   {
      public:

         CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
         { /* Ne rien faire de plus */ }

         CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
         { /* Ne rien faire de plus */ }

         static string GetName(void) { return ("grid"); }

         const CAxis* getRelAxis(void) const { return (axis); }
         const CDomain* getRelDomain(void) const { return (domain); }

         inline void solveReference(void) ;
         inline void solveDomainRef(void) ;
         inline void solveAxisRef(void) ;

         inline void computeIndex(void);

         bool _hasAxis(void) const { return (hasAxis); }

         inline void storeField(const Array<double, 1>& field, Array<double, 1>& stored);
         inline void storeField(const Array<double, 2>& field, Array<double, 1>& stored);
         inline void storeField(const Array<double, 3>& field, Array<double, 1>& stored);
         inline void storeField(const double* const data, Array<double, 1>& stored);

         inline void outputField(const Array<double,1>& stored, Array<double, 2>& outField);
         inline void outputField(const Array<double,1>& stored, Array<double, 3>& outField);

         inline static CGrid* CreateObject(const CDomain* const a_domain, const CAxis* const a_axis);
         inline static CGrid* CreateObject(const CDomain* const a_domain);

         virtual ~CGrid(void)
         { /* Ne rien faire de plus */ }

      private:

         bool hasAxis ;

         CAxis* axis ;
         CDomain* domain ;

         Array<int, 1> storeIndex ;
         Array<int, 1> out_i_index ;
         Array<int, 1> out_j_index ;
         Array<int, 1> out_l_index ;

   }; // class CGrid

   CGrid* CGrid::CreateObject(const CDomain* const a_domain, const CAxis* const a_axis)
   {
      string new_id = string("___") + a_domain->getId() + string("_") + a_axis->getId() + string("__") ;
      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;

      grid->domain_ref = a_domain->getId() ;
      grid->axis_ref   = a_axis  ->getId() ;

      return (grid);
   }

   CGrid* CGrid::CreateObject(const CDomain* const a_domain)
   {
      string new_id = string("___") + a_domain->getId() + string("__") ;
      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;

      grid->domain_ref = a_domain->getId() ;

      return (grid);
   }

   void CGrid::solveReference(void)
   {

      static bool isReferenceSolved = false;
      if (isReferenceSolved) return;

      // Résolution de chacune des références et indexation.
      solveDomainRef() ;
      solveAxisRef() ;
      computeIndex() ;

      isReferenceSolved = true ;
   }

   void CGrid::solveDomainRef(void)
   {
      if (domain_ref.hasValue())
      {
         if (CDomain::HasObject(domain_ref))
         {
           domain = CDomain::GetObject(domain_ref) ;
           domain->check() ;
         }
         else ERROR("Référence au domaine incorrecte") ;
      }
      else ERROR("Domaine non défini") ;
   }

   void CGrid::solveAxisRef(void)
   {
      if (axis_ref.hasValue())
      {
         hasAxis = true ;
         if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
         else ERROR("Référence a l'axe incorrecte") ;
      }
      else hasAxis = false ; // hasAxis est normalement déjà à false(?).
   }

   void CGrid::computeIndex(void)
   {

      int ni = domain->ni ;
      int nj = domain->nj ;
      int size = (hasAxis) ? (int)axis->size : 1 ;
      int data_dim = domain->data_dim ;
      int data_n_index = domain->data_n_index ;
      int data_ibegin  = domain->data_ibegin ;
      int data_jbegin  = (data_dim == 2) ? (int)domain->data_jbegin : -1;

      Array<int, 1>& data_i_index =* domain->data_i_index ;
      Array<int, 1>& data_j_index =* domain->data_j_index ;
      Array<bool, 2>& mask =* domain->mask ;
      int i, j, l, n ;
      int count, indexCount ;

      for(indexCount=0, l=0; l<size ; l++)
      {
         for(n=0; n<data_n_index; n++)
         {
            if (data_dim == 1)
            {
               i = (data_i_index(n) + data_ibegin) % ni ;
               j = (data_i_index(n) + data_ibegin) / ni ;
               //cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
            }
            else
            {
               i = data_i_index(n) + data_ibegin ;
               j = data_j_index(n) + data_jbegin ;
               //cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
            }

            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j) ) indexCount++ ;
         }
      }

      storeIndex.resize(indexCount) ;
      out_l_index.resize(indexCount) ;
      out_i_index.resize(indexCount) ;
      out_j_index.resize(indexCount) ;

      for(count=0, indexCount=0, l=0; l<size; l++)
      {
         for(n=0; n<data_n_index; n++, count++)
         {
            if (data_dim == 1)
            {
               i = (data_i_index(n) + data_ibegin) % ni ;
               j = (data_i_index(n) + data_ibegin) / ni ;
            }
            else // (dat_dim == 2)
            {
               i = data_i_index(n) + data_ibegin ;
               j = data_j_index(n) + data_jbegin ;
            }

            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j))
            {
               storeIndex(indexCount) = count ;
               out_l_index(indexCount) = l ;
               out_i_index(indexCount) = i ;
               out_j_index(indexCount) = j ;
               indexCount++ ;
            }
         }
      }

      /** Pour tests

      cout << "Out of CGrid::ComputeIndex" << endl ;

      cout << "storeIndex : " << endl ;
      cout << storeIndex << endl ;

      cout << "out_i_index : " << endl ;
      cout << out_i_index << endl ;

      cout << "out_j_index : " << endl ;
      cout << out_j_index << endl ;

      cout << "out_l_index : " << endl ;
      cout << out_l_index << endl ;

      **/

   }

   void CGrid::storeField(const Array<double, 1>& field, Array<double, 1>& stored)
   {
      storeField(field.dataFirst(), stored) ;
      //cout<<"Stored 1"<<stored<<endl ;
   }

   void CGrid::storeField(const Array<double, 2>& field, Array<double, 1>& stored)
   {
      storeField(field.dataFirst(), stored) ;
      //cout<<"Stored 2"<<stored<<endl ;
   }

   void CGrid::storeField(const Array<double, 3>& field, Array<double, 1>& stored)
   {
      storeField(field.dataFirst(), stored) ;
      //cout<<"Stored 3"<<stored<<endl ;
   }

   void CGrid::storeField(const double* const data, Array<double, 1>& stored)
   {
      int size = storeIndex.size() ;
      //cout << "size " << size << endl ;

      stored.resize(shape(size)) ;
      //cout << "Stored " << stored << endl ;

      for(int i = 0; i < size; i++) stored(i) = data[storeIndex(i)] ;
      //cout << "Stored " << stored << endl ;
   }

   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField)
   {
      for(int n = 0; n < storeIndex.size(); n++)
         outField(out_i_index(n), out_j_index(n)) = stored(n) ;
   }

   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField)
   {
      for(int n = 0; n < storeIndex.size(); n++)
         outField(out_i_index(n), out_j_index(n), out_l_index(n)) = stored(n) ;
   }
} // namespace XMLIOSERVER


DECLARE_GROUP(Grid)



#endif // __GRID__