/*@@
   @file      SetupGGrp.C
   @date      02/09/99
   @author  Manish Parashar
   @desc 
   @enddesc 
 @@*/

#define _cplusplus

#include "cctk.h"
#include "cctk_Flesh.h"
#include "cctk_Groups.h"
#include "GrACE_extension.h"
#include "GrACEDefs.h"

extern "C" 
int GrACE_SetupScalarGroup(GrACEGH* newGH, 
			   const int vtype, 
			   const int n_variables);

extern "C" 
int GrACE_SetupArrayGroup(GrACEGH* newGH, 
			  const int vtype, 
			  const int dim, 
			  const int n_variables);

extern "C" 
int GrACE_SetupGFGroup(GrACEGH* newGH, 
		       const int vtype, 
		       const int dim, 
		       const int n_variables);


#define f_gracerestrict3d FORTRAN_NAME(restrict3)
#define f_graceprolong3d FORTRAN_NAME(prolong3)

extern "C" 
void f_gracerestrict3d(FI(DOUBLE), FI(DOUBLE), BI, DOUBLE *, INTEGER *);
extern "C" 
void f_graceprolong3d(FI(DOUBLE), FI(DOUBLE), BI, DOUBLE *, INTEGER *);

#define f_gracerestrict2d FORTRAN_NAME(restrict2)
#define f_graceprolong2d FORTRAN_NAME(prolong2)

extern "C" 
void f_gracerestrict2d(FI(DOUBLE), FI(DOUBLE), BI, DOUBLE *, INTEGER *);
extern "C" 
void f_graceprolong2d(FI(DOUBLE), FI(DOUBLE), BI, DOUBLE *, INTEGER *);


// 1D Does not exist !
//#define f_gracerestrict1d FORTRAN_NAME(restrict1_, RESTRICT1, restrict1)
//#define f_graceprolong1d FORTRAN_NAME(prolong1_, PROLONG1, prolong1)

//void f_gracerestrict1d(FI(DOUBLE), FI(DOUBLE), BI, DOUBLE *, INTEGER *);
//void f_graceprolong1d(FI(DOUBLE), FI(DOUBLE), BI, DOUBLE *, INTEGER *);



int SetupGrACEGroup(GrACEGH* newGH, 
		    const int gtype, 
		    const int vtype, 
		    const int dim, 
		    const int n_variables) 
{
  int returncode;

  switch(gtype)
  {
    case GROUP_SCALAR : returncode = GrACE_SetupScalarGroup(newGH, 
							    vtype, 
							    n_variables); 
                        break;
    case GROUP_ARRAY  : returncode = GrACE_SetupArrayGroup(newGH, 
							   vtype,
							   dim,
							   n_variables); 
                        break;
    case GROUP_GF     : returncode = GrACE_SetupGFGroup(newGH, 
							vtype,
							dim,
							n_variables); 
                        break;
  default : fprintf(stderr, "Unknown group type in SetupGrACEGroup\n");
    returncode = 1;
  }
  
  return returncode;
}
  
int GrACE_SetupScalarGroup(GrACEGH* newGH, 
			   const int vtype, 
			   const int n_variables)
{
  GrACEGFGrp* thegrp; 

  const int startgfid = newGH->lastgfid+1;

  thegrp = new GrACEGFGrp(GROUP_SCALAR, vtype);
  thegrp->GH = newGH->theGH;
  thegrp->startgfid = startgfid;
  newGH->theGFS[newGH->numgfgrp++] = thegrp;

  GrACEScalarVoid* gsv = 0;

  for (register int i=0; i<n_variables;i++) {
    const char* gfname = CCTK_VarName(startgfid+i);

    GrACEScalar<char>* gschar;
    GrACEScalar<INTEGER>* gsint;
    GrACEScalar<DOUBLE>* gsdbl;

    switch(vtype) {
    case CCTK_VARIABLE_CHAR    : 
      gschar = new GrACEScalar<char>(gfname);
      gsv = gschar;
      break;
    case CCTK_VARIABLE_INT : 
      gsint = new GrACEScalar<INTEGER>(gfname);
      gsv = gsint;
      break;
    case CCTK_VARIABLE_REAL    : 
      gsdbl = new GrACEScalar<DOUBLE>(gfname);
      gsv = gsdbl;
      break;
    case CCTK_VARIABLE_COMPLEX : 
      cerr << "Not defined in GrACE !" << endl << flush;
      assert(0);
      break;
    default : 
      fprintf(stderr,"Unknown variable type in GrACE_SetupScalarGroup\n");
      break;
    }
    thegrp->scalarlist.add(gsv);
  }
  thegrp->numgf = thegrp->scalarlist.number();
  newGH->lastgfid += thegrp->numgf;
  
  return 0;
}

int GrACE_SetupArrayGroup(GrACEGH* newGH, 
			  const int vtype, 
			  const int dim, 
			  const int n_variables)
{
  return 0;
}

int GrACE_SetupGFGroup(GrACEGH* newGH, 
		       const int vtype, 
		       const int dim, 
		       const int n_variables)
{
  GridHierarchy* theGH = newGH->theGH;
  GrACEGFGrp* thegrp; 

  const int time_stencil = newGH->time_stencil_width;
  const int space_stencil = newGH->stencil_width;
  const int startgfid = newGH->lastgfid+1;

  // Hard code for now....
  const int cflag = newGH->cflag;
  const int shflag = newGH->shflag;

  thegrp = new GrACEGFGrp(GROUP_GF, vtype);
  thegrp->GH = theGH;
  thegrp->startgfid = startgfid;
  newGH->theGFS[newGH->numgfgrp++] = thegrp;

  GridFunctionVoid* gfv = 0;

  for (register int i=0; i<n_variables;i++) {
    const char* gfname = CCTK_VarName(startgfid+i);
    if (dim == 3) {
      GridFunction(3)<char>* gf3char;
      GridFunction(3)<INTEGER>* gf3int;
      GridFunction(3)<DOUBLE>* gf3dbl;

      switch(vtype) {
      case CCTK_VARIABLE_CHAR    : 
	gf3char = new GridFunction(3)<char>(gfname,
					    time_stencil,
					    space_stencil,
					    *theGH,
					    cflag,
					    shflag);
	gfv = gf3char;
	break;
      case CCTK_VARIABLE_INT : 
	gf3int = new GridFunction(3)<INTEGER>(gfname,
					      time_stencil,
					      space_stencil,
					      *theGH,
					      cflag,
					      shflag);
	gfv = gf3int;
	break;
      case CCTK_VARIABLE_REAL    : 
	gf3dbl = new GridFunction(3)<DOUBLE>(gfname,
					     time_stencil,
					     space_stencil,
					     *theGH,
					     cflag,
					     shflag);
	gf3dbl->GF_SetProlongFunc((void *)&f_graceprolong3d);
	gf3dbl->GF_SetRestrictFunc((void *)&f_gracerestrict3d);
	gfv = gf3dbl;
	break;
      case CCTK_VARIABLE_COMPLEX : 
	cerr << "Not defined in GrACE !" << endl << flush;
	assert(0);
	break;
      default : 
	fprintf(stderr,"Unknown variable type in GrACE_SetupGFGroup\n");
	break;
      }
    }
    if (dim == 2) {
      GridFunction(2)<char>* gf2char;
      GridFunction(2)<INTEGER>* gf2int;
      GridFunction(2)<DOUBLE>* gf2dbl;

      switch(vtype) {
      case CCTK_VARIABLE_CHAR    : 
	gf2char = new GridFunction(2)<char>(gfname,
					    time_stencil,
					    space_stencil,
					    *theGH,
					    cflag,
					    shflag);
	gfv = gf2char;
	break;
      case CCTK_VARIABLE_INT : 
	gf2int = new GridFunction(2)<INTEGER>(gfname,
					      time_stencil,
					      space_stencil,
					      *theGH,
					      cflag,
					      shflag);
	gfv = gf2int;
	break;
      case CCTK_VARIABLE_REAL    : 
	gf2dbl = new GridFunction(2)<DOUBLE>(gfname,
					     time_stencil,
					     space_stencil,
					     *theGH,
					     cflag,
					     shflag);
	gf2dbl->GF_SetProlongFunc((void *)&f_graceprolong2d);
	gf2dbl->GF_SetRestrictFunc((void *)&f_gracerestrict2d);
	gfv = gf2dbl;
	break;
      case CCTK_VARIABLE_COMPLEX : 
	cerr << "Not defined in GrACE !" << endl << flush;
	assert(0);
	break;
      default : 
	fprintf(stderr,"Unknown variable type in  GrACE_SetupGFGroup\n");
	break;
      }
    }
    if (dim == 1) {
      switch(vtype) {
	GridFunction(1)<char>* gf1char;
	GridFunction(1)<INTEGER>* gf1int;
	GridFunction(1)<DOUBLE>* gf1dbl;

      case CCTK_VARIABLE_CHAR    : 
	gf1char = new GridFunction(1)<char>(gfname,
					    time_stencil,
					    space_stencil,
					    *theGH,
					    cflag,
					    shflag);
	gfv = gf1char;
	break;
      case CCTK_VARIABLE_INT : 
	gf1int = new GridFunction(1)<INTEGER>(gfname,
					      time_stencil,
					      space_stencil,
					      *theGH,
					      cflag,
					      shflag);
	gfv = gf1int;
	break;
      case CCTK_VARIABLE_REAL    : 
	gf1dbl = new GridFunction(1)<DOUBLE>(gfname,
					     time_stencil,
					     space_stencil,
					     *theGH,
					     cflag,
					     shflag);
	gfv = gf1dbl;
	break;
      case CCTK_VARIABLE_COMPLEX : 
	cerr << "Not defined in GrACE !" << endl << flush;
	assert(0);
	break;
      default : 
	fprintf(stderr,"Unknown variable type in GrACE_SetupGFGroup\n");
	break;
      }
    }
    thegrp->gflist.add(gfv);
  }
  thegrp->numgf = thegrp->gflist.number();
  newGH->lastgfid += thegrp->numgf;
  
  return 0;
}