// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ==  http://www.amdis-fem.org                                              ==
// ==                                                                        ==
// ============================================================================
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.



/** \file FeSpaceMapping.h */

#include <map>
#include "parallel/MpiHelper.h"
#include "parallel/ParallelTypes.h"

#ifndef AMDIS_FE_SPACE_MAPPING_H
#define AMDIS_FE_SPACE_MAPPING_H

namespace AMDiS {
  using namespace std;

  class GlobalDofMap
  {
  public:
    GlobalDofMap(MPI::Intracomm* m)
      : mpiComm(m),
	nRankDofs(0),
	nOverallDofs(0),
	rStartDofs(0)
    {}
    
    void clear()
    {
      dofMap.clear();
      nRankDofs = 0;
      nOverallDofs = 0;
      rStartDofs = 0;
    }
    
    DegreeOfFreedom operator[](DegreeOfFreedom d)
    {
      TEST_EXIT_DBG(dofMap.count(d))("Should not happen!\n");

      return dofMap[d];
    }
    
    void insertRankDof(DegreeOfFreedom dof0, DegreeOfFreedom dof1 = -1)
    {
      FUNCNAME("GlobalDofMap::insertRankDof()");
      
      TEST_EXIT_DBG(dofMap.count(dof0) == 0)("Should not happen!\n");
      
      dofMap[dof0] = (dof1 >= 0 ? dof1 : nRankDofs);
      nRankDofs++;
    }
    
    void insert(DegreeOfFreedom dof0, DegreeOfFreedom dof1)
    {
      FUNCNAME("GlobalDofMap::insert()");
      
      TEST_EXIT_DBG(dofMap.count(dof0) == 0)("Should not happen!\n");
      
      dofMap[dof0] = dof1;
    }
    
    bool isSet(DegreeOfFreedom dof)
    {
      return static_cast<bool>(dofMap.count(dof));
    }
    
    unsigned int size()
    {
      return dofMap.size();
    }
    
    DofMapping& getMap()
    {
      return dofMap;
    }
    
    void update(bool add = true)
    {
      nOverallDofs = 0;
      rStartDofs = 0;
      mpi::getDofNumbering(*mpiComm, nRankDofs, rStartDofs, nOverallDofs);

      if (add)
	addOffset(rStartDofs);
    }

    void addOffset(int offset)
    {
      for (DofMapping::iterator it = dofMap.begin(); it != dofMap.end(); ++it)
	it->second += offset;
    }

  private:
    MPI::Intracomm* mpiComm;
    
    /// 
    DofMapping dofMap;    

  public:
    /// 
    int nRankDofs, nOverallDofs, rStartDofs;   
  };
  

  template<typename T>
  class FeSpaceData
  {
  public:
    FeSpaceData() {} 

    void setMpiComm(MPI::Intracomm *m)
    {
      mpiComm = m;
    }

    T& operator[](const FiniteElemSpace* feSpace)
    {
      FUNCNAME("FeSpaceData::operator[]()");

      TEST_EXIT_DBG(data.count(feSpace))("Should not happen!\n");

      return data.find(feSpace)->second;
    }

    void addFeSpace(const FiniteElemSpace* feSpace)
    {
      FUNCNAME("FeSpaceData::addFeSpace()");
      
      if (data.count(feSpace))
	data.find(feSpace)->second.clear();
      else
	data.insert(make_pair(feSpace, T(mpiComm)));
    }    

  private:
    MPI::Intracomm* mpiComm;
    
    map<const FiniteElemSpace*, T> data;
  };

}

#endif