#include "GridSpace.hh"

namespace RVL {

  template<> ostream & writeMeta<Grid>(Grid const & g, ostream & e) {
    g.write(e);
  }
  
  template<> size_t getDataSize<Grid>(Grid const & g) {
    if (g.isInit()) {
      size_t nnn = 1;
      for (size_t i=0; i<g.getDimension(); i++) 
	nnn *= g.getAxis(i).getLength();
      return nnn;
    }
    else {
      RVLException e;
      e<<"Error: Grid::getDataSize()\n";
      e<<"  object not initialized - lacking "
       <<g.getDimension()-g.getNumAxes()
       <<" axes\n";
      throw e;
    }
  }

  template<> size_t getMetaSize<Grid>(Grid const & g) {
    if (g.isInit()) {
      size_t nnn = g.getDimension()*(Axis::getAxisSize());
      return nnn;
    }
    else {
      RVLException e;
      e<<"Error: Grid::getMetaSize()\n";
      e<<"  object not initialized - lacking "
       <<g.getDimension()-g.getNumAxes()
       <<" axes\n";
      throw e;
    }
  }

  template<> char * serialize<Axis>(Axis const & a, size_t & len) {
    len = Axis::getAxisSize();
    size_t loc=0;
    size_t n = a.getLength();
    float d = a.getStep();
    float o = a.getOrigin();
    int id = a.getID();
    char * cbuf = new char[len];
    memcpy((&(cbuf[loc])),(char *)(&n),sizeof(size_t)); loc += sizeof(size_t);
    memcpy((&(cbuf[loc])),(char *)(&d),sizeof(float)); loc += sizeof(float);
    memcpy((&(cbuf[loc])),(char *)(&o),sizeof(float)); loc += sizeof(float);
    memcpy((&(cbuf[loc])),(char *)(&id),sizeof(int)); loc += sizeof(int);
    return cbuf;
  }

  template<> Axis * deserialize<Axis>(char * cbuf, size_t len) {
    if (len != Axis::getAxisSize()) {
      RVLException e;
      e<<"Error: deserialize<Axis>\n";
      e<<"  2nd param must = axis size = "<<Axis::getAxisSize()<<"\n";
      e<<"  you passed "<<len<<"\n";
      throw e;
    }
    size_t loc=0;
    size_t n;
    float d;
    float o;
    int id;
    memcpy((char *)(&n),(&(cbuf[loc])),sizeof(size_t)); loc += sizeof(size_t);
    memcpy((char *)(&d),(&(cbuf[loc])),sizeof(float)); loc += sizeof(float);
    memcpy((char *)(&o),(&(cbuf[loc])),sizeof(float)); loc += sizeof(float);
    memcpy((char *)(&id),(&(cbuf[loc])),sizeof(int)); loc += sizeof(int);
    Axis * a = new Axis(n,d,o,id);
    return a;
  }

  template<> char * serialize<Grid>(Grid const & g, size_t & len) {
    len = getMetaSize<Grid>(g);
    char * c = new char[len];
    size_t loc=0;
    size_t tmp;
    for (size_t i=0; i< g.getDimension(); i++) {
      memcpy(&(c[loc]),serialize<Axis>(g.getAxis(i),tmp),Axis::getAxisSize());
      if (tmp != Axis::getAxisSize()) {
	RVLException e;
	e<<"Error: serialize<Grid>\n";
	e<<"  wrong number of bytes read on axis "<<i<<"\n";
	throw e;
      }
      loc += Axis::getAxisSize();
    }
  }
  
  template<> Grid * deserialize<Grid>(char * cbuf, size_t len) {
    // first check that the length is divisible by axis length, and compute
    // number of axes

  }

}