#ifndef __HASHPVS_H
#define __HASHPVS_H

#include <hash_map>
#include <vector>
#include "common.h"
#include <math.h>
#include "PvsBase.h"


using namespace std;

namespace GtpVisibilityPreprocessor {

class KdNode;
class BspNode;
class Ray;
class Intersectable;
class ViewCell;


/** Template class representing the Potentially Visible Set (PVS) 
	mainly from a view cell, but also e.g., from objects.
*/
template<typename T>
class HashPvs: public PvsBase<T>
{
	template<typename T>
		friend class PvsIterator2;

public:

	HashPvs() {};
	//virtual ~HashPvs() {};

	int GetSize() const;
	bool Empty() const;

	/** Adds sample to PVS.
		@returns contribution of sample (0 or 1)
	*/
	float AddSample(T sample);

	/** Adds sample to PVS without checking for presence of the sample
		warning: pvs remains unsorted!
	*/
	void AddSampleDirty(T sample);

	/** Adds sample dirty (on the end of the vector) but
		first checks if sample is already in clean part of the pvs.
	*/
	bool AddSampleDirtyCheck(T sample);

	/** Sort pvs entries - this should always be called after a
		sequence of AddSampleDirty calls 
	*/
	void Sort();

	/** Clears the pvs.
	*/
	void Clear(const bool trim = true);

	//static void Merge(PvsBase &mergedPvs, const PvsBase &a, const PvsBase &b);

	bool IsDirty() const;

	bool RequiresResort() const;

	//typename PvsIterator<T> GetIterator() const;

protected:

	/// vector of PVS entries
	vector<T> mEntries; 

	/// Number of samples used to create the PVS
	int mSamples;
};


template <typename T>
int HashPvs<T>::GetSize() const
{
	return 0;
}


template <typename T>
bool HashPvs<T>::Empty() const
{
	return false;
}


template <typename T>
float HashPvs<T>::AddSample(T sample)
{
	return 0;
}
	

template <typename T>
void HashPvs<T>::AddSampleDirty(T sample)
{
}


template <typename T>
bool HashPvs<T>::AddSampleDirtyCheck(T sample)
{
	return false;
}


template <typename T>
void HashPvs<T>::Sort()
{
}


template <typename T>
void HashPvs<T>::Clear(const bool trim = true)
{
}


template <typename T>
bool HashPvs<T>::IsDirty() const
{
	return false;
}


template <typename T>
bool HashPvs<T>::RequiresResort() const
{
	return false;
}

//typename PvsIterator<T> GetIterator() const;

}

#endif