#ifndef MXHASHTABLE_H
#define MXHASHTABLE_H

#include "mxcollection.h"
#include "mxcore.h"
#include "mxtypes.h"

#define HASH_TABLE_INIT_SIZE 128

template <class T>
class MxHashTableCursor;

template <class T>
class MxHashTableNode {
public:
	MxHashTableNode<T>(T p_obj, MxU32 p_hash, MxHashTableNode* p_prev, MxHashTableNode* p_next)
	{
		m_obj = p_obj;
		m_hash = p_hash;
		m_prev = p_prev;
		m_next = p_next;
	}

	// DECOMP: Should use getter and setter methods here per the style guide.
	// However, LEGO1D (with no functions inlined) does not use them.
	T m_obj;
	MxU32 m_hash;
	MxHashTableNode* m_prev;
	MxHashTableNode* m_next;
};

template <class T>
class MxHashTable : protected MxCollection<T> {
public:
	enum Option {
		e_noExpand = 0,
		e_expandAll,
		e_expandMultiply,
	};

	MxHashTable()
	{
		m_numSlots = HASH_TABLE_INIT_SIZE;
		MxU32 unused = 0;
		m_slots = new MxHashTableNode<T>*[m_numSlots];
		memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
		m_resizeOption = e_noExpand;
	}

	~MxHashTable() override;

	void Resize();
	void Add(T);
	void DeleteAll();

	virtual MxU32 Hash(T) { return 0; }

	friend class MxHashTableCursor<T>;

protected:
	void NodeInsert(MxHashTableNode<T>*);

	MxHashTableNode<T>** m_slots; // 0x10
	MxU32 m_numSlots;             // 0x14
	MxU32 m_autoResizeRatio;      // 0x18
	Option m_resizeOption;        // 0x1c
	// FIXME: or FIXME? This qword is used as an integer or double depending
	// on the value of m_resizeOption. Hard to say whether this is how the devs
	// did it, but a simple cast in either direction doesn't match.
	union {
		MxU32 m_increaseAmount;  // 0x20
		double m_increaseFactor; // 0x20
	};
};

template <class T>
class MxHashTableCursor : public MxCore {
public:
	MxHashTableCursor(MxHashTable<T>* p_table)
	{
		m_table = p_table;
		m_match = NULL;
	}

	MxBool Find(T p_obj);
	MxBool Current(T& p_obj);
	void DeleteMatch();

private:
	MxHashTable<T>* m_table;
	MxHashTableNode<T>* m_match;
};

template <class T>
MxBool MxHashTableCursor<T>::Find(T p_obj)
{
	MxU32 hash = m_table->Hash(p_obj);

	for (MxHashTableNode<T>* t = m_table->m_slots[hash % m_table->m_numSlots]; t; t = t->m_next) {
		if (t->m_hash == hash && !m_table->Compare(t->m_obj, p_obj)) {
			m_match = t;
		}
	}

	return m_match != NULL;
}

template <class T>
MxBool MxHashTableCursor<T>::Current(T& p_obj)
{
	if (m_match) {
		p_obj = m_match->m_obj;
	}

	return m_match != NULL;
}

template <class T>
void MxHashTableCursor<T>::DeleteMatch()
{
	// Cut the matching node out of the linked list
	// by updating pointer references.
	if (m_match) {
		if (m_match->m_prev) {
			m_match->m_prev->m_next = m_match->m_next;
		}
		else {
			// No "prev" node, so move "next" to the head of the list.
			m_table->m_slots[m_match->m_hash % m_table->m_numSlots] = m_match->m_next;
		}

		if (m_match->m_next) {
			m_match->m_next->m_prev = m_match->m_prev;
		}

		m_table->m_customDestructor(m_match->m_obj);
		delete m_match;
		m_table->m_count--;
	}
}

template <class T>
MxHashTable<T>::~MxHashTable()
{
	DeleteAll();
	delete[] m_slots;
}

template <class T>
void MxHashTable<T>::DeleteAll()
{
	for (MxS32 i = 0; i < m_numSlots; i++) {
		MxHashTableNode<T>* next;
		for (MxHashTableNode<T>* t = m_slots[i]; t != NULL; t = next) {
			next = t->m_next;
			this->m_customDestructor(t->m_obj);
			delete t;
		}
	}

	this->m_count = 0;
	memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
}

template <class T>
inline void MxHashTable<T>::Resize()
{
	// Save a reference to the current table
	// so we can walk nodes and re-insert
	MxU32 oldSize = m_numSlots;
	MxHashTableNode<T>** oldTable = m_slots;

	switch (m_resizeOption) {
	case e_expandAll:
		m_numSlots += m_increaseAmount;
		break;
	case e_expandMultiply:
		m_numSlots *= m_increaseFactor;
		break;
	}

	MxU32 unused = 0;
	m_slots = new MxHashTableNode<T>*[m_numSlots];
	memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
	this->m_count = 0;

	for (MxS32 i = 0; i < oldSize; i++) {
		MxHashTableNode<T>* next;
		for (MxHashTableNode<T>* t = oldTable[i]; t != NULL; t = next) {
			next = t->m_next;
			NodeInsert(t);
		}
	}

	delete[] oldTable;
}

template <class T>
inline void MxHashTable<T>::NodeInsert(MxHashTableNode<T>* p_node)
{
	MxS32 bucket = p_node->m_hash % m_numSlots;

	p_node->m_next = m_slots[bucket];

	if (m_slots[bucket]) {
		m_slots[bucket]->m_prev = p_node;
	}

	m_slots[bucket] = p_node;
	this->m_count++;
}

template <class T>
inline void MxHashTable<T>::Add(T p_newobj)
{
	if (m_resizeOption && ((this->m_count + 1) / m_numSlots) > m_autoResizeRatio) {
		MxHashTable<T>::Resize();
	}

	MxU32 hash = Hash(p_newobj);
	MxU32 unused = 0;

	MxHashTableNode<T>* node = new MxHashTableNode<T>(p_newobj, hash, NULL, NULL);

	MxHashTable<T>::NodeInsert(node);
}

#undef HASH_TABLE_INIT_SIZE

#endif // MXHASHTABLE_H