// $Id: WaveletUDT.cc,v 0.1 2001/08/10 19:10:00 klimenko Exp $

#define WAVELETUDT_CC

#include <stdexcept>

#include "ilwd/ldascontainer.hh"
#include "ilwd/ldasarray.hh"

#include "WaveletUDT.hh"

// WAT headers
#include "Haar.hh"
#include "Biorthogonal.hh"
//#include "Daubechies.hh"
//#include "Meyer.hh"

namespace datacondAPI
{

// constructors

template<class DataType_t>
WaveletUDT<DataType_t>::WaveletUDT()
{
   pWavelet = NULL;
   datacondAPIwat::Wavelet *p = new datacondAPIwat::Wavelet();
   setWavelet(*p);
   delete p;
}

template<class DataType_t>
WaveletUDT<DataType_t>::WaveletUDT(const datacondAPIwat::Wavelet &w) 
{ 
   pWavelet = NULL;
   setWavelet(w);
}  

template<class DataType_t>
WaveletUDT<DataType_t>::
WaveletUDT(const Sequence<DataType_t>& value, const datacondAPIwat::Wavelet &w) : 
TimeSeries<DataType_t>(value, 1.)
{   
   pWavelet = NULL;
   setWavelet(w);
   std::valarray<DataType_t> *p = (std::valarray<DataType_t>*) this;
   pWavelet->allocate(p->size(),(DataType_t*)&(p[0]));
}

template<class DataType_t>
WaveletUDT<DataType_t>::
WaveletUDT(const TimeSeries<DataType_t>& value, const datacondAPIwat::Wavelet &w) : 
TimeSeries<DataType_t>(value)
{   
   pWavelet = NULL;
   setWavelet(w);
   std::valarray<DataType_t> *p = (std::valarray<DataType_t>*) this;
   pWavelet->allocate(p->size(),(DataType_t*)&(p[0]));
}

template<class DataType_t>
WaveletUDT<DataType_t>::
WaveletUDT(const WaveletUDT<DataType_t>& value) : 
TimeSeries<DataType_t>(value)
{
   pWavelet = NULL;
   setWavelet((datacondAPIwat::Wavelet) *(value.pWavelet));
   std::valarray<DataType_t> *p = (std::valarray<DataType_t>*) this;
   pWavelet->allocate(p->size(),(DataType_t*)&(p[0]));
}

// destructor

template<class DataType_t>
WaveletUDT<DataType_t>::~WaveletUDT()
{
   if(pWavelet){
     pWavelet->release();
     delete pWavelet;
   }
}

// UDT required methods

template<class DataType_t>
WaveletUDT<DataType_t>* WaveletUDT<DataType_t>::Clone() const
{
  return new WaveletUDT<DataType_t>(*this);
}

template<class DataType_t>
ILwd::LdasElement* WaveletUDT<DataType_t>::
ConvertToIlwd( const CallChain& Chain,
               datacondAPI::udt::target_t Target) const
{
   ILwd::LdasContainer* container = new ILwd::LdasContainer;

   container->push_back(TimeSeries<DataType_t>::ConvertToIlwd(Chain, Target));

   container->push_back(new ILwd::LdasArray<int>
		       (int(pWavelet->m_WaveType), "WaveletType"));

   container->push_back(new ILwd::LdasArray<int>
		       (pWavelet->m_TreeType, "WaveletTreeType"));

   container->push_back(new ILwd::LdasArray<int>
		       (pWavelet->m_Level, "WaveletLevel"));

   container->push_back(new ILwd::LdasArray<int>
		       (int(pWavelet->m_Border), "WaveletBorder")); 

   container->push_back(new ILwd::LdasArray<int>
		       (pWavelet->m_H, "WaveletHPFilterLength"));

   container->push_back(new ILwd::LdasArray<int>
		       (pWavelet->m_L, "WaveletLPFilterLength"));
   return container;
}


// accessors


// metadata methods

template<class DataType_t>
int WaveletUDT<DataType_t>::
getMaxLevel()
{ 
   int maxlevel = 0;

   if(pWavelet->allocate())
      maxlevel = pWavelet->getMaxLevel();

   return maxlevel;
}

// Accessors

// access to data in wavelet domain
// get wavelet coefficients from a layer with specified frequency index
// if index<0 - get coefficients from the layer = |index|
template<class DataType_t>
size_t WaveletUDT<DataType_t>::
getLayer(Sequence<DataType_t> &value, int index=0)
{
   std::valarray<DataType_t> *w = (std::valarray<DataType_t>*) this;
   slice s = pWavelet->getSlice(index);
   size_t last = s.start()+(s.size()-1)*s.stride();

   if(last < w->size()){
      value.resize(s.size());
      value = (*w)[s];               // get slice of wavelet valarray
      return s.size();
   }
   else{
      throw std::invalid_argument
      ("WaveletUDT::getLayer(): data length mismatch");
      return 0;
   }
}

// access to data in wavelet domain
// put wavelet coefficients into layer with specified frequency index
// if index<0 - put coefficients into layer = |index|
template<class DataType_t>
void WaveletUDT<DataType_t>::
putLayer(const Sequence<DataType_t> &value, int index=0)
{
   std::valarray<DataType_t> *w = (std::valarray<DataType_t>*) this;
   slice s = pWavelet->getSlice(index);
   size_t last = s.start()+(s.size()-1)*s.stride();

   if( (s.size() < value.size()) || (last >= w->size()) ){
      std::ostrstream oss;
      oss << "WaveDWT::putLayer(): invalid array size. "
	  << "Expected size: " << s.size() << endl;
  
      std::invalid_argument exception(oss.str());
      oss.freeze(0);
      throw exception;
   }      
   else{
      (*w)[s] = value;    // put slice into wavelet valarray
   }
}

// mutators

template<class DataType_t>
void WaveletUDT<DataType_t>::
setWavelet(const datacondAPIwat::Wavelet &w)
{ 
   if(pWavelet){ delete pWavelet; }      // delete old wavelet object

   switch (w.m_WaveType){

      case datacondAPIwat::HAAR:
	 pWavelet = new datacondAPIwat::Haar<DataType_t>(w);
	 break;

      case datacondAPIwat::BIORTHOGONAL:
	 pWavelet = new datacondAPIwat::Biorthogonal<DataType_t>(w);
	 break;
/* ------------------- not in place yet --------------
      case DAUBECHIES:
	 pWavelet = new datacondAPIwat::Daubechies<DataType_t>(w);
	 break;

      case MEYER:
	 pWavelet = new datacondAPIwat::DMeyer<DataType_t>(w);
	 break;
*  ---------------------------------------------------*/
      default:
	 throw std::invalid_argument
	 ("WaveletUDT::setWavelet(): Invalid wavelet type");
	 break;
   }
}

template<class DataType_t>
void WaveletUDT<DataType_t>::
Forward(int k)
{
   if(pWavelet->allocate()){
      pWavelet->t2w(k);
   }
   else{
      throw std::invalid_argument
      ("WaveletUDT::Forward(): data is not allocated");
   }
}

template<class DataType_t>
void WaveletUDT<DataType_t>::
Inverse(int k)
{ 
   if(pWavelet->allocate()){
      pWavelet->w2t(k); 
   }
   else{
      throw std::invalid_argument
      ("WaveletUDT::Inverse(): data is not allocated");
   }
}

} // namespace datacondAPI


// instantiations

#define CLASS_INSTANTIATION(class_) \
template class datacondAPI::WaveletUDT< class_ >; \
UDT_CLASS_INSTANTIATION(datacondAPI::WaveletUDT< class_ >)

CLASS_INSTANTIATION(float)
CLASS_INSTANTIATION(double)
//CLASS_INSTANTIATION(std::complex<float>)
//CLASS_INSTANTIATION(std::complex<double>)

#undef CLASS_INSTANTIATION

/*
template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::Sequence<int> &, datacondAPIwat::Wavelet &);

template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::Sequence<short> &, datacondAPIwat::Wavelet &);

template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::Sequence<std::complex<int>> &, datacondAPIwat::Wavelet &);

template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::Sequence<std::complex<short>> &, datacondAPIwat::Wavelet &);

template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::TimeSeries<int> &, datacondAPIwat::Wavelet &);

template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::TimeSeries<short> &, datacondAPIwat::Wavelet &);

template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::TimeSeries<std::complex<int>> &, datacondAPIwat::Wavelet &);

template datacondAPI::WaveletUDT<float>::
WaveletUDT(const datacondAPI::TimeSeries<std::complex<short>> &, datacondAPIwat::Wavelet &);
*/