#pragma once

#include <vector>
#include <list>

using namespace std;

/*
 *
 * hashtable.h
 *
 * hash()
 *  perl hashing function
 *
 * class hashtable
 *  A =SIMULATION= of a hash table using templates
 *  (c) 2006 Charles A. Morris
 *
 */

unsigned long hash( string key );

template <class T>
struct record
{
	unsigned long hashsum;
	string key;
	T value;
};

template <class T>
class hashtable
{

public:

	hashtable();
	~hashtable();

	bool empty() const; 
	bool insert( const string key, const T record );
	bool retreive( const string key, T & target ) const;

	void display() const;

private:

	vector <string> keys;

	vector < record<T> > data;	//cheating

//	record<T> * data;	//the memory where the records are stored
	long recordSize;	//the size of the records
	int numRecords;		//the amount of records currently stored
};

template <class T>
hashtable<T>::hashtable()
{
	recordSize = sizeof(record<T>);
//	data = new record<T>[];
	numRecords = 0;
}

template <class T>
hashtable<T>::~hashtable()
{
//	delete [] data;
}

template <class T>
bool hashtable<T>::empty() const
{
//	return data.empty();
return false;
}

//returns true if collision, false if OK
template <class T>
bool hashtable<T>::insert( const string key, const T value )
{
	const unsigned long sum = hash(key);

	//simulate collisions
	for( int i = 0; i < data.size(); i++ )
	{
		if( data.at(i).hashsum == sum )
		{
			data.at(i).value = value;
			return true;
		}
	}
	
	//simulate collisions
//	for( int i = 0; i < numRecords; i++ )
//	{
//		record * temprecord;
//		temprecord = *(data+(i*recordSize));
//
//
//		if( temprecord->hashsum == sum )
//		{
//			temprecord->value = value;
//			return true;
//		}
//	}

	/*
	    instead of using a vector here,
		you would seek to the location in
		memory calculated by

		long location = sum + sizeof(T);

		then memcpy() it directly there.
	*/


//	memcpy( data+sum, value, recordSize );

	//the vector cheating way
	record <T> mystruct;
	mystruct.key = key;
	mystruct.hashsum = sum;
	mystruct.value = value;
	data.push_back(mystruct);

return false;
}

template <class T>
bool hashtable<T>::retreive( const string key, T & target ) const
{
	unsigned long sum = hash(key);

return false;
}

template <class T>
void hashtable<T>::display() const
{
	cout<<"                /-------------------------------\\"<<endl;
	cout<<" \tkey\t|\tf(key)\t|\tvalue\t|"<<endl;
	cout<<"                |-------------------------------|"<<endl;

	for( int i = 0; i < data.size(); i++ )
	{
		cout<<"\t"<<data.at(i).key<<"\t|\t"<<data.at(i).hashsum<<"\t|\t"<<data.at(i).value<<"\t|"<<endl;
	}

	cout<<"                \\-------------------------------/"<<endl;
return;
}

// (Defined by the PERL_HASH macro in hv.h) 
// djb2 hashing algorithm
//
// ported by Charles Morris (me) for C++ programmers
unsigned long hash( string key )
{
	unsigned long fingerprint = 0;
	for( int j = 0; j < key.length(); j++)
	{
//		fingerprint = fingerprint * 33 + (int)key.at(j); //real
		fingerprint = fingerprint * 11 + (int)key.at(j);
	}
return fingerprint;
}