// DataSource.h: interface for the CDataSource class.
//
//////////////////////////////////////////////////////////////////////

#ifndef __MY_DATA_SOURCE_
#define __MY_DATA_SOURCE_

#include <vector>
#include <cmath>

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

template<typename T>
class CDataSource  
{
public:
	int m_Dim;
	int m_nSamples;
	CDataSource(int nSamples, int dim):m_Dim(dim),m_nSamples(nSamples) {}
	virtual ~CDataSource(){}

	virtual void getData(int idx, T *const dst) const = 0;
	virtual double squareDist(int idx1, int idx2) const
	{
		std::vector<T> p1(m_Dim), p2(m_Dim);
		getData(idx1, &p1.front());
		getData(idx2, &p2.front());
		double dist=0;
		for(int i=0; i<m_Dim; i++)
			dist += (p1[i]-p2[i])*(p1[i]-p2[i]);
		
		return dist;
	}
	virtual double weightedSquareDist(const T *const p1, const T *const  p2, const int *const weight) const
	{
		double dist=0;
		for(int i=0; i<m_Dim; i++)
			dist += (p1[i]-p2[i])*(p1[i]-p2[i])*(1<<weight[i]);

		return dist;
	}
	virtual double weightedSquareDist(int idx, const T *const  p2, const int *const weight) const
	{
		std::vector<T> p(m_Dim);
		getData(idx, &p.front());

		return weightedSquareDist(&p.front(), p2, weight);
	}
	virtual double squareDist(const T *const p1, const T *const  p2) const
	{
		double dist=0;
		for(int i=0; i<m_Dim; i++)
			dist += (p1[i]-p2[i])*(p1[i]-p2[i]);

		return dist;
	}
	virtual double squareDist(int idx, const T *const  pp) const
	{
		std::vector<T> p(m_Dim);
		getData(idx, &p.front());

		return squareDist(&p.front(), pp);
	}
};

template<typename T>
class CSimDataSource: public CDataSource<T>
{
private:
	T *const *const m_pSource;
public:
	~CSimDataSource(){ }
	CSimDataSource(T *const *const pSource, int nSamples, int dim):m_pSource(pSource),CDataSource<T>(nSamples, dim){	}
	void getData(int idx, T *const dst) const
	{
		std::copy(m_pSource[idx], m_pSource[idx]+m_Dim, dst);
	}
};

template<typename T>
class CImgDataSource: public CDataSource<T>
{
private:
	const T *const *const m_pSource;
	int m_ImgDim;
	int m_Width, m_Height;
	int m_nPtsX, m_nPtsY;
	bool m_Tileable;
	std::vector<int> m_Mask;
public:
	CImgDataSource(T **pSouce, int nSamples, int dim, 
		int width, int height, int imgDim, bool tileable, 
		int nPtsx, int nPtsy, const std::vector<int> &mask)
		:m_pSource(pSouce), m_ImgDim(imgDim), m_Width(width), m_Height(height), m_Tileable(tileable),
		m_nPtsX(nPtsx),m_nPtsY(nPtsy),m_Mask(mask), CDataSource(nSamples, dim)
	{
		assert(m_nPtsX*m_nPtsY == m_nSamples);
		assert(m_Mask.size()*m_ImgDim == m_Dim*2 && m_Dim>0);
		if(m_Width*m_Height != m_nSamples || m_Dim<=0 || m_Mask.size()*m_ImgDim == m_Dim*2)
			throw std::invalid_argument("Invalid argument!");
	}

	void getData(int idx, T *const dst) const
	{
		const int x0 = idx%m_nPtsX;
		const int y0 = idx/m_nPtsX;
		const int nMaskPts = m_Mask.size()/2;
		for(int i=0; i<nMaskPts; i++){
			int idx = (y+m_Mask[i*2+1])%m_Height*m_Width + (x+m_Mask[x+i*2])%m_Width;
			std::copy(dst[idx], dst[idx]+m_ImgDim, dst+idx*m_ImgDim);
		}
	}

/*	double squareDist(int p1, int p2) const
	{
		std::vector<T> p(m_Dim);
		getData(idx, &p.front());

		return squareDist(&p.front(), pp);
	}
*/
};
#endif