#ifndef _SAMPLE_PURESAMPLEEX_HPP_
#define _SAMPLE_PURESAMPLEEX_HPP_
#ifndef _COMMON_EXCEPTION_HPP_
#include <common/except.hpp>
#endif
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_MEMFILE_HPP_
#include <common/memfile.hpp>
#endif
#ifndef _COMMON_OPENFILE_HPP_
#include <common/openfile.hpp>
#endif

typedef struct _SAMPLE_DATA
{
  union
	{
	  int b4:4;
		int b8:8;
		int b16:16;
		int b32:32;
	};
}SAMPLE_DATA;

typedef SAMPLE_DATA SampleData;

class PureSampleEx
{
public:  
  typedef enum InitOptions{ParamIsNumSamples,ParamIsSizeBytes};
  typedef enum BitsPerSample{Bit4=4,Bit8=8,Bit16=16,Bit32=32};
	enum{BitsPerByte=8};
	PureSampleEx();
	virtual ~PureSampleEx();
  PureSampleEx &operator=(const PureSampleEx &pureSampleEx);
	bool operator==(const PureSampleEx &pureSampleEx);
	PureSampleEx &operator+=(const PureSampleEx &pureSampleEx);
	bool write(MemFile &memFile)const;
	bool read(FileHandle &handle);
  bool convert(BitsPerSample bitsPerSample);
  bool convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample);
	bool initialize(BitsPerSample bitsPerSample,int param,InitOptions initOption);
	bool getAt(int sampleIndex,SampleData &sampleData);
	bool setAt(int sampleIndex,SampleData &sampleData);
	bool isOkay(void)const;
	DWORD getSizeBytes(void)const;
	DWORD getNumSamples(void)const;
	BitsPerSample getBitsPerSample(void)const;
	BYTE *getSampleData(void);
private:
  static int getRequiredLength(BitsPerSample bitsPerSample,int numSamples);
  static void translate(SampleData &srcData,BitsPerSample srcBitsPerSample,SampleData &dstData,BitsPerSample &dstBitsPerSample);
	static int getNumSamples(BitsPerSample bitsPerSample,int sizeBytes);

  Array<BYTE> mSampleData;
	BitsPerSample mBitsPerSample;
	DWORD mNumSamples;
};

inline
PureSampleEx::PureSampleEx()
: mBitsPerSample(Bit8), mNumSamples(0)
{
}

inline
PureSampleEx::~PureSampleEx()
{
}

inline
bool PureSampleEx::initialize(BitsPerSample bitsPerSample,int param,InitOptions initOption)
{
  if(ParamIsNumSamples==initOption)
	{
    mBitsPerSample=bitsPerSample;
	  mNumSamples=param;
	  mSampleData.size(getRequiredLength(bitsPerSample,mNumSamples));
	}
	else
	{
    mBitsPerSample=bitsPerSample;
	  mNumSamples=getNumSamples(bitsPerSample,param);
		mSampleData.size(param);
	}
	return true;
}

inline
int PureSampleEx::getRequiredLength(BitsPerSample bitsPerSample,int numSamples)
{
  return ((float)bitsPerSample/(float)BitsPerByte)*numSamples;
}

inline
PureSampleEx &PureSampleEx::operator=(const PureSampleEx &pureSampleEx)
{
  mSampleData=pureSampleEx.mSampleData;
	mBitsPerSample=pureSampleEx.mBitsPerSample;
  mNumSamples=pureSampleEx.mNumSamples;
	return *this;
}

inline
bool PureSampleEx::operator==(const PureSampleEx &pureSampleEx)
{
  if(mBitsPerSample!=pureSampleEx.mBitsPerSample || mNumSamples!=pureSampleEx.mNumSamples)return false;
	return mSampleData==pureSampleEx.mSampleData;
}

inline
PureSampleEx &PureSampleEx::operator+=(const PureSampleEx &pureSampleEx)
{
  throw Exception("PureSampleEx::operator+=() not implemented");
  return *this;
}

inline
bool PureSampleEx::convert(BitsPerSample bitsPerSample)
{
  PureSampleEx pureSampleEx;
  
	convert(pureSampleEx,bitsPerSample);
	*this=pureSampleEx;
	return true;
}

inline
bool PureSampleEx::convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample)
{
	SampleData srcData;
	SampleData dstData;

	if(!isOkay())return false;
	pureSampleEx.initialize(bitsPerSample,getNumSamples(),PureSampleEx::ParamIsNumSamples);
	for(int index=0;index<getNumSamples();index++)
	{
	  getAt(index,srcData);
		translate(srcData,mBitsPerSample,dstData,bitsPerSample);
		pureSampleEx.setAt(index,dstData);
	}
	return pureSampleEx.isOkay();
}

inline
void PureSampleEx::translate(SampleData &srcData,BitsPerSample srcBitsPerSample,SampleData &dstData,BitsPerSample &dstBitsPerSample)
{
  if(Bit4==srcBitsPerSample)
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b4;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b4;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b4;
		else dstData.b32=srcData.b4;
	}
	else if(Bit8==srcBitsPerSample)
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b8;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b8;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b8;
		else dstData.b32=srcData.b8;
	}
	else if(Bit16==srcBitsPerSample)
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b16;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b16;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b16;
		else dstData.b32=srcData.b16;
	}
	else
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b32;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b32;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b32;
		else dstData.b32=srcData.b32;
	}
}

inline
bool PureSampleEx::getAt(int sampleIndex,SampleData &sampleData)
{
  float index;
	int byteIndex;

  if(sampleIndex>=mNumSamples)return false;
	index=((float)mBitsPerSample/(float)BitsPerByte)*(float)sampleIndex;
  byteIndex=index;
	if(Bit4==mBitsPerSample)
	{
	  BYTE b=mSampleData[byteIndex];
		if(0.00==(float)byteIndex-index)sampleData.b4=b;
		else sampleData.b4=(b>>4);
	}
	else if(Bit8==mBitsPerSample)
	{
	  sampleData.b8=mSampleData[byteIndex];
	}
	else if(Bit16==mBitsPerSample)
	{
	  sampleData.b16=*((WORD*)&mSampleData[byteIndex]);
	}
	else if(Bit32==mBitsPerSample)
	{
	  sampleData.b32=*((DWORD*)&mSampleData[byteIndex]);
	}
	return true;
}

inline
bool PureSampleEx::setAt(int sampleIndex,SampleData &sampleData)
{
  float index;
	int byteIndex;

  if(sampleIndex>=mNumSamples)return false;
	index=((float)mBitsPerSample/(float)BitsPerByte)*(float)sampleIndex;
  byteIndex=index;
	if(Bit4==mBitsPerSample)
	{
	  BYTE b=mSampleData[byteIndex];
		if(0.00==(float)byteIndex-index)mSampleData[byteIndex]=(b&0xF0)|sampleData.b4;
		else mSampleData[byteIndex]=(b&0x0F)|(((BYTE)sampleData.b4)<<4);
	}
	else if(Bit8==mBitsPerSample)
	{
	  mSampleData[byteIndex]=sampleData.b8;
	}
	else if(Bit16==mBitsPerSample)
	{
	  *((WORD*)&mSampleData[byteIndex])=sampleData.b16;
	}
	else if(Bit32==mBitsPerSample)
	{
	  *((DWORD*)&mSampleData[byteIndex])=sampleData.b32;
	}
	return true;
}

inline
bool PureSampleEx::write(MemFile &memFile)const
{
  if(!isOkay())return false;
	if(!memFile.write((char*)&((Array<BYTE>&)mSampleData)[0],mSampleData.size()))return false;
	return true;
}

inline
bool PureSampleEx::read(FileHandle &handle)
{
  if(!isOkay())return false;
	if(!handle.read(&mSampleData[0],mSampleData.size()))return false;
	return true;
}

inline
DWORD PureSampleEx::getSizeBytes(void)const
{
  return getRequiredLength(mBitsPerSample,getNumSamples());
}

inline
DWORD PureSampleEx::getNumSamples(void)const
{
  return mNumSamples;
}

inline
PureSampleEx::BitsPerSample PureSampleEx::getBitsPerSample(void)const
{
  return mBitsPerSample;
}

inline
int PureSampleEx::getNumSamples(BitsPerSample bitsPerSample,int sizeBytes)
{
  return ((float)BitsPerByte/(float)bitsPerSample)*(float)sizeBytes;
}

inline
BYTE *PureSampleEx::getSampleData(void)
{
  return &mSampleData[0];
}

inline
bool PureSampleEx::isOkay(void)const
{
  return mNumSamples?true:false;
}
#endif