/***************************************************************************
 *   Copyright (C) 2006 by Nicolas PASCAL                                  *
 *   nicolas.pascal@icare.univ-lille1.fr                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "Hdf_vd.hpp"

void Hdf_vd::init_fields( const int32 &id, const char *field_name_list, const int32 & nb_field )
{
  // read the field names
  string s_field_name_list(field_name_list);
  int previous_comma_idx=-1;
  int next_comma_idx=0;
  int32 type, order, size;
  // initialize new field infos
  Hdf_vd_field new_field;

  // read the fields infos
  for (int32 i=0;i<nb_field;++i) {
    // read the field names string and split it using the comma separator
    next_comma_idx=s_field_name_list.find_first_of(',',previous_comma_idx+1);
    if (next_comma_idx==(int32)string::npos)
      next_comma_idx=s_field_name_list.size();
    new_field.set_name(s_field_name_list.substr(previous_comma_idx+1,next_comma_idx-previous_comma_idx-1));
    previous_comma_idx=next_comma_idx;
    // read the field type
    type=VFfieldtype(id,i);
    if (type==FAIL) {
      bad_field_type e(name,new_field.get_name()); 
      throw e;
    }
    new_field.set_type(type);
    // read the order
    order=VFfieldorder(id,i);
    if (order==FAIL) {
      bad_field_order e(name,new_field.get_name()); 
      throw e;
    }
    new_field.set_order(order);
    // read the size of the type
    size=VFfieldisize(id,i);
    if (size==FAIL) {
      bad_field_size e(name,new_field.get_name()); 
      throw e;
    }
    new_field.set_size(size);
    fields.push_back(new_field);
  }
}
void Hdf_vd::init_attributes( const int32 &id )
{
  // read the attributes
  intn status_n;
  int32 field_idx=_HDF_VDATA; // to know the number of the attributes attached to the vdata
  int32 nb_attr=VSfnattrs(id,field_idx);
  if (nb_attr==FAIL) {
    bad_vs_fnattrs e(name,field_idx);
    throw e;
  }
  // read all the attributes infos
  field_idx=_HDF_VDATA; // to access the attributes of the VData (by oppopsition to the fields attributes TODO treat them)
  char attr_name[VSNAMELENMAX];
  int32 attr_type,attr_nvalues,size;
  Hdf_attr attr;
  for (intn iattr=0;iattr<nb_attr;++iattr) {
    status_n=VSattrinfo(id, field_idx, iattr, attr_name, &attr_type, &attr_nvalues, &size);
    if (status_n==FAIL) {
      bad_vs_attr_info e(name,field_idx,iattr); 
      throw e;
    }
    attr=Hdf_attr(id, iattr, attr_name, attr_type, attr_nvalues,Hdf_attr::VDATA);
    attrs.push_back( attr );
  }
}
Hdf_vd::Hdf_vd( const int32 & vd_id, const int32 & vd_ref, const char * filename ) : ref(vd_ref)
{
  // initialize the member attributes
  name="";
  cls="";
  fields.clear();
  attrs.clear();
  interlace=-1;
  nb_record=-1;

  char vd_name[VSNAMELENMAX]; /* buffer to retrieve the vdata name */
  char vd_class[VSNAMELENMAX];/* buffer to retrieve the vdata class */
  int32 vd_nb_record,vd_nb_field;
  int32 vd_size;
  int32 vd_interlace_mode;
  char fieldname_list[MAX_FIELD_SIZE]; /* buffer to retrieve the vdata data */
  intn status_n;

  // read the informations
  status_n = VSinquire (vd_id, &vd_nb_record, &vd_interlace_mode, fieldname_list, &vd_size, vd_name);
  if (status_n==FAIL) {
    bad_vs_inquire e(filename,vd_id);
    throw e;
  }
  // read the class
  status_n = VSgetclass(vd_id,vd_class);
  if (status_n==FAIL) {
    bad_vs_getclass e(filename,vd_id);
    throw e;
  }
  // read the number of fields
  vd_nb_field = VFnfields(vd_id);
  if (vd_nb_field==FAIL) {
    bad_vf_nfields e(filename,vd_name);
    throw e;
  }
  // stores the read informations
  name=vd_name;
  cls=vd_class;
  nb_record=vd_nb_record;
  interlace=vd_interlace_mode;

  init_fields(vd_id,fieldname_list,vd_nb_field);
  init_attributes(vd_id);
}
void Hdf_vd::init_member( )
{
  ref=-1;
  name="";
  cls="";
  fields.clear();
  attrs.clear();
  interlace=-1;
  nb_record=-1;
}
Hdf_vd::Hdf_vd( )
{
  init_member();
}
Hdf_vd & Hdf_vd::operator =( const Hdf_vd & hdf_vd )
{
  if (&hdf_vd == this) return *this; // protect against self assignation

  ref=hdf_vd.ref;
  name=hdf_vd.name;
  cls=hdf_vd.cls;
  interlace=hdf_vd.interlace;
  nb_record=hdf_vd.nb_record;
  fields=hdf_vd.fields;
  attrs=hdf_vd.attrs;

  return *this;
}
Hdf_vd::Hdf_vd( const Hdf_vd & hdf_vd ):  ref(hdf_vd.ref),name(hdf_vd.name),cls(hdf_vd.cls),interlace(hdf_vd.interlace),nb_record(hdf_vd.nb_record),fields(hdf_vd.fields),attrs(hdf_vd.attrs)
{
}
Hdf_vd::~Hdf_vd( )
{
}
int32 Hdf_vd::get_attr_idx( const char * attr_name ) const
{
  int32 i=0;
  int32 end=attrs.size();
  while (i<end && attrs[i].get_name()!=attr_name)
    ++i;
  if (i<end) // found
    return i;
  else
    return -1;
}
Hdf_attr Hdf_vd::get_attribute( const char * attr_name ) const
{
  int32 idx=get_attr_idx(attr_name);
  if (idx==-1){
    bad_attribute_name e(name,attr_name,VDATA);
    throw e;
  }
  return get_attribute(idx);
}
Hdf_attr Hdf_vd::get_attribute( const int32 & attr_idx ) const
{
  if (attr_idx==-1 || attr_idx>=(int32)attrs.size()) {
    bad_attribute_index e(name,attr_idx,VDATA);
    throw e;
  }
  return attrs[attr_idx];
}
const bool Hdf_vd::has_attr( const char * attr_name ) const
{
  return ( get_attr_idx(attr_name)!=-1 );
}

int32 Hdf_vd::get_field_idx( const char * field_name ) const
{
  int32 i=0;
  int32 end=fields.size();
  while (i<end && fields[i].get_name()!=field_name)
    ++i;
  if (i<end) // found
    return i;
  else
    return -1;
}
Hdf_vd_field Hdf_vd::get_field( const char * field_name ) const
{
  int32 idx=get_field_idx(field_name);
  if (idx==-1){
    bad_field_name e(name,field_name);
    throw e;
  }
  return get_field(idx);
}
Hdf_vd_field Hdf_vd::get_field( const int32 & field_idx ) const
{
  if (field_idx==-1 || field_idx>=(int32)fields.size()) {
    bad_field_index e(name,field_idx);
    throw e;
  }
  return fields[field_idx];
}
const bool Hdf_vd::has_field( const char * field_name ) const
{
  return ( get_field_idx(field_name)!=-1 );
}
void Hdf_vd::get_attr_value( const char * attr_name, void * value, int32 ival ) const
{
  Hdf_attr attr = get_attribute(attr_name); // throw a bad_attribute_name if the attribute doesn't exist
  attr.get_value(value,ival);
}
std::string
Hdf_vd::to_string() const {
  using namespace std;
  ostringstream s;
  s << name 
  << ", class: " << cls 
  << ", interlace: " << interlace 
  <<", nb_record: " <<nb_record
  <<", nb_field: " <<fields.size()<<endl;
  int nb_fields=fields.size();
  if (nb_fields>0) {
    s<<"***** VDATA Fields *****"<<endl;
    for (int i=0;i<nb_fields;++i)
      s<<fields[i].to_string();
    s<<endl;
  }
  int nb_attr=attrs.size();
  if (nb_attr>0) {
    cout<<"***** VDATA Attributes *****"<<endl;
    for (int i=0;i<nb_attr;++i)
      s<<attrs[i].to_string();
    s<<endl;
  }
  return s.str();
}
Hdf_vd_field Hdf_vd::read_field_data( const int32 & file_id, const string &filename, const string &field_name, void* data, int32 start, int32 edges ) {
  /* read the field index */
  int32 vd_field_idx=get_field_idx(field_name.c_str());
  if (vd_field_idx==-1){
    bad_field_name e(name,field_name);
    throw e;
  }
  /* Attach to the vdata for reading. */
  int32 vd_id = VSattach (file_id, ref, "r");
  if (vd_id == FAIL){
    bad_vs_attach e(filename,vd_id,"r");
    throw e;
  }

  Hdf_vd_field vd_field=get_field(vd_field_idx);
  int32 order=vd_field.get_order();
  int32 size=vd_field.get_size();
  int32 type=vd_field.get_type();
  /* Specify the field that will be read. Only one field at this time*/

  intn status_n = VSsetfields (vd_id, field_name.c_str());
  if (status_n==FAIL) {
    bad_vs_setfields e(filename,name,field_name);
    throw e;
  }
  /* Place the current point to the position specified in start */
  int32 record_pos = VSseek (vd_id, start);
  if (record_pos==FAIL) {
    bad_vs_seek e(filename,name,start);
    throw e;
  }
  if (edges==-1) // if -1 read all records from the start
    edges=get_nb_record()-start;
  /* Read the next 'edge' records from the start and store the data in a packed buffer */
  int32 field_size=size*order;

  int32 data_size=field_size*edges; // one data size in byte
  uint8 packed_data[data_size]; // [nb_records][nval_per_record]
  int32 num_of_records = VSread (vd_id, packed_data, edges,interlace);
  if (num_of_records==FAIL) {
    bad_vs_read e(filename,name,edges);
    throw e;
  }
  /*
  * Build an array of pointers each of which points to an array that
  * will hold all values of a field after being unpacked.
  * Stores the the values of each order sequentially in data : all the values of the first order, then the one of the second one, etc
  */
  VOIDP unpacked_buf_ptrs[order];

  // need to deal with the void* type here
  if (type==DFNT_FLOAT64) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((float64*)data)[i*(size*edges)];
  } else if (type==DFNT_FLOAT32) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((float32*)data)[i*(size*edges)];
  } else if (type==DFNT_INT32) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((int32*)data)[i*(size*edges)];
  } else if (type==DFNT_UINT32) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((uint32*)data)[i*(size*edges)];
  } else if (type==DFNT_UINT16) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((uint16*)data)[i*(size*edges)];
  } else if (type==DFNT_INT16) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((int16*)data)[i*(size*edges)];
  } else if (type==DFNT_UINT8) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((uint8*)data)[i*(size*edges)];
  } else if (type==DFNT_INT8) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((int8*)data)[i*(size*edges)];
  } else if (type==DFNT_UCHAR8) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((uchar8*)data)[i*(size*edges)];
  } else if (type==DFNT_CHAR8) {
    for (int i=0 ; i<order ; ++i)
      unpacked_buf_ptrs[i]=&((char8*)data)[i*(size*edges)];
  } else { // should never be the case
      cerr<<"In "<<__FILE__<<" at "<<__LINE__<<" : unknown HDF type code "<<type<<endl;
      abort();
  }

  /*
  * Unpack the data from the buffer databuf and store the values into the
  * appropriate field buffers pointed to by the set of pointers fldbufptrs.
  * Note that the second parameter is _HDF_VSUNPACK for unpacking and the
  * number of records is the one returned by VSread.
  */
  status_n = VSfpack (vd_id,_HDF_VSUNPACK,field_name.c_str(),(VOIDP)packed_data,data_size, num_of_records,NULL,unpacked_buf_ptrs);
  if (status_n==FAIL) {
    bad_vs_fpack e(filename,name,field_name);
    throw e;
  }
  return vd_field;
}