// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_osc_streamers
#define tools_osc_streamers

#include "iobj_const_visitor"
#include "iobj_visitor"

#include "histo/h1d"
#include "histo/h2d"
#include "histo/h3d"
#include "histo/p1d"
#include "histo/p2d"
#include "vmanip"
#include "sto"

namespace tools {
namespace osc {

inline bool Axis_visit(iobj_const_visitor& a_v,
                       const std::string& /*a_field*/,
                       const histo::axis<double>& a_axis){
  //SLASH_STORE_BEGIN(BatchLab::Axis)

  int version = 1;
  if(!a_v.visit("fVersion",version)) return false;

  if(!a_v.visit("fOffset",a_axis.m_offset)) return false;
  if(!a_v.visit("fNumberOfBins",(int)a_axis.m_number_of_bins)) return false;
  if(!a_v.visit("fMinimumValue",a_axis.m_minimum_value)) return false;
  if(!a_v.visit("fMaximumValue",a_axis.m_maximum_value)) return false;
  if(!a_v.visit("fFixed",a_axis.m_fixed)) return false;
  if(!a_v.visit("fBinWidth",a_axis.m_bin_width)) return false;
  if(!a_v.visit("fEdges",a_axis.m_edges)) return false;

  //if(!a_v.end(*this)) return false;
  return true;
}

inline bool Axis_read(iobj_visitor& a_visitor,
                      histo::axis<double>& a_axis){
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  if(!a_visitor.visit(a_axis.m_offset)) return false;

 {int nbin;
  if(!a_visitor.visit(nbin)) return false;
  a_axis.m_number_of_bins = nbin;}

  if(!a_visitor.visit(a_axis.m_minimum_value)) return false;
  if(!a_visitor.visit(a_axis.m_maximum_value)) return false;
  if(!a_visitor.visit(a_axis.m_fixed)) return false;
  if(!a_visitor.visit(a_axis.m_bin_width)) return false;
  if(!a_visitor.visit(a_axis.m_edges)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

class Item : public virtual istorable {
public:
  virtual bool visit(iobj_const_visitor& a_visitor) const {
    //if(!a_visitor.begin(*this,Item::s_class(),Item::s_visit)) return false;
  
    int version = 1;
    if(!a_visitor.visit("fVersion",version)) return false;
  
    if(!a_visitor.visit("fKey",fKey)) return false;
    if(!a_visitor.visit("fValue",fValue)) return false;
    if(!a_visitor.visit("fSticky",fSticky)) return false;
  
    //if(!a_visitor.end(*this)) return false;
    return true;
  }
public:
  virtual bool read(iobj_visitor& a_visitor) {
    //if(!a_visitor.begin(*this)) return false;
  
    int version;
    if(!a_visitor.visit(version)) return false;
  
    if(!a_visitor.visit(fKey)) return false;
    if(!a_visitor.visit(fValue)) return false;
    if(!a_visitor.visit(fSticky)) return false;
  
    //if(!a_visitor.end(*this)) return false;
    return true;
  }
public:
  Item(){}
  Item(const std::string& aKey,const std::string& aValue,bool aSticky)
  :fKey(aKey),fValue(aValue),fSticky(aSticky){}
  virtual ~Item(){}
public:
  Item(const Item& aFrom)
  :istorable(aFrom)
  ,fKey(aFrom.fKey)
  ,fValue(aFrom.fValue)
  ,fSticky(aFrom.fSticky)
  {}
  Item& operator=(const Item& aFrom) {
    fKey = aFrom.fKey;
    fValue = aFrom.fValue;
    fSticky = aFrom.fSticky;
    return *this;
  }
public:
  std::string fKey;
  std::string fValue;
  bool fSticky;
};

template <class T> //T must inherit istorable.
inline bool std_vector_visit(iobj_const_visitor& a_visitor,
                             const std::string& /*a_field*/,
                             const std::vector<T>& a_vec) {
  //if(!a_visitor.begin(*this,"BatchLab::Vector<"+a_field+">",Vector<T>::visit)) 
  //  return false;

  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;

  unsigned int number = a_vec.size();
  if(!a_visitor.visit("fSize",number)) return false;

  for(unsigned int index=0;index<number;index++) {
    const T& elem = a_vec[index];
    if(!a_visitor.visit(to<int>(index),elem)) return false;
  }

  //if(!a_visitor.end(*this)) return false;
  return true;
}

template <class T>
inline bool std_vector_read(iobj_visitor& a_visitor,
                            std::vector<T>& a_vec) {
  a_vec.clear();
    
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  unsigned int number;
  if(!a_visitor.visit(number)) return false;

  a_vec.resize(number);
  for(unsigned int index=0;index<number;index++) {
    T& elem = a_vec[index];
    if(!elem.read(a_visitor)) return false;
  }

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool Annotation_visit(iobj_const_visitor& a_visitor,
                             const std::vector<Item>& a_items) {
  //if(!a_visitor.begin(*this,Annotation::s_class(),Annotation::s_visit))
  //  return false;
  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;  
  if(!std_vector_visit<Item>(a_visitor,"fItems",a_items)) return false;  
  //if(!a_visitor.end(*this)) return false;
  return true;
}
  
inline bool Annotation_read(iobj_visitor& a_visitor) {
  //if(!a_visitor.begin(*this)) return false;
  int version;
  if(!a_visitor.visit(version)) return false;  
  std::vector<Item> fItems;
  if(!std_vector_read<Item>(a_visitor,fItems)) return false;  
  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline void map2vec(const std::map<std::string,std::string>& a_in,
                    std::vector<Item>& a_out) {
  a_out.clear();
  std::map<std::string,std::string>::const_iterator it;
  for(it=a_in.begin();it!=a_in.end();++it) {
    a_out.push_back(Item((*it).first,(*it).second,false));
  }
}

typedef histo::histo_data<double,unsigned int,double> hd_data;

inline bool BaseHistogram_visit(const hd_data& aData,
                                iobj_const_visitor& a_visitor) {
  //SLASH_STORE_BEGIN(BatchLab::BaseHistogram)
  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;

  //if(!a_visitor.visit("fAnnotation",fAnnotation)) return false;
  std::vector<Item> items;
  map2vec(aData.m_annotations,items);
  if(!Annotation_visit(a_visitor,items)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool BaseHistogram_read(iobj_visitor& a_visitor){
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  if(!Annotation_read(a_visitor)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool visitHistogram(const hd_data& aData,
                           iobj_const_visitor& a_visitor){
  if(!a_visitor.visit("fTitle",aData.m_title)) return false;
  if(!a_visitor.visit("fDimension",(int)aData.m_dimension)) return false;
  if(!a_visitor.visit("fBinNumber",(int)aData.m_bin_number)) return false;

  if(!a_visitor.visit("fBinEntries",
    convert<unsigned int,int>(aData.m_bin_entries))) return false;

  if(!a_visitor.visit("fBinSw",aData.m_bin_Sw)) return false;
  if(!a_visitor.visit("fBinSw2",aData.m_bin_Sw2)) return false;
  if(!a_visitor.visit("fBinSxw",aData.m_bin_Sxw)) return false;
  if(!a_visitor.visit("fBinSx2w",aData.m_bin_Sx2w)) return false;
 {for(unsigned int iaxis=0;iaxis<aData.m_dimension;iaxis++) {
    std::string name = "fAxes_" + to<int>(iaxis);   
    //BatchLab::Axis axis;
    //axis.copy(aData.m_axes[iaxis]);
    //if(!a_visitor.visit(name,axis)) return false;
    if(!Axis_visit(a_visitor,name,aData.m_axes[iaxis])) return false;
  }}
 {int dummy = 0;
  if(!a_visitor.visit("fMode",dummy)) return false;} //m_mode
  if(!a_visitor.visit("fProfile",false)) return false;
 {std::vector<double> dummy;
  if(!a_visitor.visit("fBinSvw",dummy)) return false;
  if(!a_visitor.visit("fBinSv2w",dummy)) return false;}
  if(!a_visitor.visit("fCutV",false)) return false;
 {double dummy = 0;
  if(!a_visitor.visit("fMinV",dummy)) return false;
  if(!a_visitor.visit("fMaxV",dummy)) return false;}
  // Not written :
  //aData.fDoubles
  //aData.fInts
  return true;
}

inline bool readHistogram(hd_data& aData,iobj_visitor& a_visitor){
  if(!a_visitor.visit(aData.m_title)) return false;
 {int dim;
  if(!a_visitor.visit(dim)) return false;
  aData.m_dimension = dim;}

 {int nbin;
  if(!a_visitor.visit(nbin)) return false;
  aData.m_bin_number = nbin;}

 {std::vector<int> vec;
  if(!a_visitor.visit(vec)) return false;
  aData.m_bin_entries = convert<int,unsigned int>(vec);}

  if(!a_visitor.visit(aData.m_bin_Sw)) return false;
  if(!a_visitor.visit(aData.m_bin_Sw2)) return false;
  if(!a_visitor.visit(aData.m_bin_Sxw)) return false;
  if(!a_visitor.visit(aData.m_bin_Sx2w)) return false;
  aData.m_axes.clear();
  for(unsigned int iaxis=0;iaxis<aData.m_dimension;iaxis++) {
    histo::axis<double> baxis;
    if(!Axis_read(a_visitor,baxis)) return false;
    aData.m_axes.push_back(baxis);
  }
 {int dummy;
  if(!a_visitor.visit(dummy)) return false;} //m_mode

 {bool dummy;
  if(!a_visitor.visit(dummy)) return false;} //m_is_profile

 {std::vector<double> dummy;
  if(!a_visitor.visit(dummy)) return false;} //m_bin_Svw

 {std::vector<double> dummy;
  if(!a_visitor.visit(dummy)) return false;} //m_bin_Sv2w

 {bool dummy;
  if(!a_visitor.visit(dummy)) return false;} //m_cut_v

 {double dummy;
  if(!a_visitor.visit(dummy)) return false;} //aData.m_min_v

 {double dummy;
  if(!a_visitor.visit(dummy)) return false;} //aData.m_max_v

  //aData.fDoubles
  //aData.fInts
  //aData.m_coords.resize(aData.m_dimension,0);
  //aData.m_ints.resize(aData.m_dimension,0);

  return true;
}

inline bool visit(iobj_const_visitor& a_visitor,
                  const histo::h1d& a_histo) {
  //SLASH_STORE_BEGIN(BatchLab::Histogram1D)

  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;

  if(!BaseHistogram_visit(a_histo.get_histo_data(),a_visitor)) return false;

  if(!visitHistogram(a_histo.get_histo_data(),a_visitor)) return false;

  //if(!a_visitor.visit("fAxis",fAxis)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool read(iobj_visitor& a_visitor,histo::h1d& a_histo){
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  if(version!=1) {
    //this may come from an unexpected byteswap.
    a_visitor.out() << "tools::osc::read :"
                    << " unexpected version " << version
                    << std::endl;
    return false;
  }

  if(!BaseHistogram_read(a_visitor)) return false;

  hd_data hdata;
  if(!readHistogram(hdata,a_visitor)) return false;

  a_histo.copy_from_data(hdata);

  //fAxis.copy(fHistogram.get_axis(0));

  //if(!a_visitor.end(*this)) return false;

  a_histo.update_fast_getters();

  return true;
}

inline bool visit(iobj_const_visitor& a_visitor,
                  const histo::h2d& a_histo) {
  //SLASH_STORE_BEGIN(BatchLab::Histogram2D)

  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;

  if(!BaseHistogram_visit(a_histo.get_histo_data(),a_visitor)) return false;

  if(!visitHistogram(a_histo.get_histo_data(),a_visitor)) return false;

  //if(!a_visitor.visit("fAxisX",fAxisX)) return false;
  //if(!a_visitor.visit("fAxisY",fAxisY)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool read(iobj_visitor& a_visitor,histo::h2d& a_histo){
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  if(version!=1) {
    //this may come from an unexpected byteswap.
    a_visitor.out() << "tools::osc::read :"
                    << " unexpected version " << version
                    << std::endl;
    return false;
  }

  if(!BaseHistogram_read(a_visitor)) return false;

  hd_data hdata;
  if(!readHistogram(hdata,a_visitor)) return false;
  a_histo.copy_from_data(hdata);

  //fAxisX.copy(fHistogram.get_axis(0));
  //fAxisY.copy(fHistogram.get_axis(1));

  //if(!a_visitor.end(*this)) return false;

  a_histo.update_fast_getters();

  return true;
}

inline bool visit(iobj_const_visitor& a_visitor,
                  const histo::h3d& a_histo) {
  //SLASH_STORE_BEGIN(BatchLab::Histogram3D)

  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;

  if(!BaseHistogram_visit(a_histo.get_histo_data(),a_visitor)) return false;

  if(!visitHistogram(a_histo.get_histo_data(),a_visitor)) return false;

  //if(!a_visitor.visit("fAxisX",fAxisX)) return false;
  //if(!a_visitor.visit("fAxisY",fAxisY)) return false;
  //if(!a_visitor.visit("fAxisZ",fAxisY)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool read(iobj_visitor& a_visitor,histo::h3d& a_histo){
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  if(version!=1) {
    //this may come from an unexpected byteswap.
    a_visitor.out() << "tools::osc::read :"
                    << " unexpected version " << version
                    << std::endl;
    return false;
  }

  if(!BaseHistogram_read(a_visitor)) return false;

  hd_data hdata;
  if(!readHistogram(hdata,a_visitor)) return false;
  a_histo.copy_from_data(hdata);

  //fAxisX.copy(fHistogram.get_axis(0));
  //fAxisY.copy(fHistogram.get_axis(1));
  //fAxisZ.copy(fHistogram.get_axis(2));

  //if(!a_visitor.end(*this)) return false;

  a_histo.update_fast_getters();

  return true;
}

typedef histo::profile_data<double,unsigned int,double,double> pd_data;

inline bool visitProfile(const pd_data& aData,
                         iobj_const_visitor& a_visitor){
  if(!a_visitor.visit("fTitle",aData.m_title)) return false;
  if(!a_visitor.visit("fDimension",(int)aData.m_dimension)) return false;
  if(!a_visitor.visit("fBinNumber",(int)aData.m_bin_number)) return false;

  if(!a_visitor.visit("fBinEntries",
    convert<unsigned int,int>(aData.m_bin_entries))) return false;

  if(!a_visitor.visit("fBinSw",aData.m_bin_Sw)) return false;
  if(!a_visitor.visit("fBinSw2",aData.m_bin_Sw2)) return false;
  if(!a_visitor.visit("fBinSxw",aData.m_bin_Sxw)) return false;
  if(!a_visitor.visit("fBinSx2w",aData.m_bin_Sx2w)) return false;
  for(unsigned int iaxis=0;iaxis<aData.m_dimension;iaxis++) {
    std::string name = "fAxes_" + to<int>(iaxis);   
    //BatchLab::Axis axis;
    //axis.copy(aData.m_axes[iaxis]);
    //if(!a_visitor.visit(name,axis)) return false;
    if(!Axis_visit(a_visitor,name,aData.m_axes[iaxis])) return false;
  }
 {int dummy = 0;
  if(!a_visitor.visit("fMode",dummy)) return false;} //m_mode
  if(!a_visitor.visit("fProfile",true)) return false;
  if(!a_visitor.visit("fBinSvw",aData.m_bin_Svw)) return false;
  if(!a_visitor.visit("fBinSv2w",aData.m_bin_Sv2w)) return false;
  if(!a_visitor.visit("fCutV",aData.m_cut_v)) return false;
  if(!a_visitor.visit("fMinV",aData.m_min_v)) return false;
  if(!a_visitor.visit("fMaxV",aData.m_max_v)) return false;
  // Not written :
  //aData.fDoubles
  //aData.fInts
  return true;
}

inline bool readProfile(pd_data& aData,iobj_visitor& a_visitor){
  if(!a_visitor.visit(aData.m_title)) return false;

 {int dim;
  if(!a_visitor.visit(dim)) return false;
  aData.m_dimension = dim;}

 {int nbin;
  if(!a_visitor.visit(nbin)) return false;
  aData.m_bin_number = nbin;}

 {std::vector<int> vec;
  if(!a_visitor.visit(vec)) return false;
  aData.m_bin_entries = convert<int,unsigned int>(vec);}

  if(!a_visitor.visit(aData.m_bin_Sw)) return false;
  if(!a_visitor.visit(aData.m_bin_Sw2)) return false;
  if(!a_visitor.visit(aData.m_bin_Sxw)) return false;
  if(!a_visitor.visit(aData.m_bin_Sx2w)) return false;
  aData.m_axes.clear();
  for(unsigned int iaxis=0;iaxis<aData.m_dimension;iaxis++) {
    histo::axis<double> baxis;
    if(!Axis_read(a_visitor,baxis)) return false;
    aData.m_axes.push_back(baxis);
  }
 {int dummy;
  if(!a_visitor.visit(dummy)) return false;} //m_mode
  if(!a_visitor.visit(aData.m_is_profile)) return false;
  if(!a_visitor.visit(aData.m_bin_Svw)) return false;
  if(!a_visitor.visit(aData.m_bin_Sv2w)) return false;
  if(!a_visitor.visit(aData.m_cut_v)) return false;
  if(!a_visitor.visit(aData.m_min_v)) return false;
  if(!a_visitor.visit(aData.m_max_v)) return false;

  // Not written :
  //aData.fDoubles
  //aData.fInts
  //aData.m_coords.resize(aData.m_dimension,0);
  //aData.m_ints.resize(aData.m_dimension,0);

  return true;
}

inline bool visit(iobj_const_visitor& a_visitor,
                  const histo::p1d& a_histo) {
  //SLASH_STORE_BEGIN(BatchLab::Profile1D)

  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;

  if(!BaseHistogram_visit(a_histo.get_histo_data(),a_visitor)) return false;

  if(!visitProfile(a_histo.get_histo_data(),a_visitor)) return false;

  //if(!a_visitor.visit("fAxis",fAxis)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool read(iobj_visitor& a_visitor,histo::p1d& a_histo){
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  if(version!=1) {
    //this may come from an unexpected byteswap.
    a_visitor.out() << "tools::osc::read :"
                    << " unexpected version " << version
                    << std::endl;
    return false;
  }


  if(!BaseHistogram_read(a_visitor)) return false;

  pd_data hdata;
  if(!readProfile(hdata,a_visitor)) return false;
  a_histo.copy_from_data(hdata);

  //fAxis.copy(fHistogram.get_axis(0));

  //if(!a_visitor.end(*this)) return false;

  a_histo.update_fast_getters();

  return true;
}

inline bool visit(iobj_const_visitor& a_visitor,
                  const histo::p2d& a_histo) {
  //SLASH_STORE_BEGIN(BatchLab::Profile2D)

  int version = 1;
  if(!a_visitor.visit("fVersion",version)) return false;

  if(!BaseHistogram_visit(a_histo.get_histo_data(),a_visitor)) return false;

  if(!visitProfile(a_histo.get_histo_data(),a_visitor)) return false;

  //if(!a_visitor.visit("fAxisX",fAxisX)) return false;
  //if(!a_visitor.visit("fAxisY",fAxisY)) return false;

  //if(!a_visitor.end(*this)) return false;
  return true;
}

inline bool read(iobj_visitor& a_visitor,histo::p2d& a_histo){
  //if(!a_visitor.begin(*this)) return false;

  int version;
  if(!a_visitor.visit(version)) return false;

  if(version!=1) {
    //this may come from an unexpected byteswap.
    a_visitor.out() << "tools::osc::read :"
                    << " unexpected version " << version
                    << std::endl;
    return false;
  }


  if(!BaseHistogram_read(a_visitor)) return false;

  pd_data hdata;
  if(!readProfile(hdata,a_visitor)) return false;
  a_histo.copy_from_data(hdata);

  //fAxisX.copy(a_histo.get_axis(0));
  //fAxisY.copy(a_histo.get_axis(1));

  //if(!a_visitor.end(*this)) return false;

  a_histo.update_fast_getters();

  return true;
}

inline const std::string& s_h1d() {
  static const std::string s_v("BatchLab::Histogram1D");
  return s_v;
}

inline const std::string& s_h2d() {
  static const std::string s_v("BatchLab::Histogram2D");
  return s_v;
}

inline const std::string& s_h3d() {
  static const std::string s_v("BatchLab::Histogram3D");
  return s_v;
}

inline const std::string& s_p1d() {
  static const std::string s_v("BatchLab::Profile1D");
  return s_v;
}

inline const std::string& s_p2d() {
  static const std::string s_v("BatchLab::Profile2D");
  return s_v;
}

}}

#endif