// basic windows and ogl headers
#include "standard.h"

#pragma once

class CEventList
{
public:

	// constructor and destructor
	CEventList();
	~CEventList();

	void Init();

	int Add(CEventList* eventList);
	int Delete(CEventList* eventList);
	int DeleteList();

	int		type;
	int		client;

	timer_s	time;

	CEventList*	prevItem;
	CEventList*	nextItem;

private:

	// allocate some work pointers
	CEventList*	listEntry;
	CEventList*	newItem;

};

#include "standard.h"

#include "CEventList.h"

//=========================================================================================
//
// Class Constructor
//
//=========================================================================================
CEventList::CEventList()
{
	prevItem = 0;
	nextItem = 0;

	type	= 0;
	client	= 0;

	memset(&time, 0x00, sizeof(timer_s));

	listEntry = 0;
	newItem   = 0;

}

//=========================================================================================
//
// Class Destructor
//
//=========================================================================================
CEventList::~CEventList()
{
}

//=========================================================================================
//
// Initialize the list
//
// Cannot put this in the constructor because of the new command.
// The class has not been allocated until the constructor has
// completed its execution.
//
//=========================================================================================
void CEventList::Init()
{

	// head points to nothing
	prevItem = 0;

	// head sequence variable
	time.startTime = 0;

	// make the tail for the list
	nextItem = new CEventList;

	// point the tail to the head
	nextItem->prevItem = this;

	// set the next pointer of the tail to null
	// marks the end of the list
	nextItem->nextItem = 0;

	// tail sequence variable
	// making a tail so it's the highest amount possible
	nextItem->time.startTime = 99999999;

}

//=========================================================================================
//
// Insert an event into the list
//
//=========================================================================================
int CEventList::Add(CEventList* eventIn)
{
	// start at the beginning of the list
	// skip the head of the list
	listEntry	= nextItem;

	// loop until the tail entry is found
	while(listEntry != 0)
	{
		// maintaining a sequenced order

		// if the current event's key being added is
		// less than or equal to the current entry's key
		// then it's a valid insertion point
		// because the two events happened at the same time

		if(eventIn->time.startTime <= listEntry->time.startTime)
		{
			// allocate the item
			newItem = new CEventList;

			// copy in the values
			//
			// trying to keep this simple
			// could use a structure to do one memcpy or
			// copy each variable from the incoming structure
			// to the class variables
			memcpy(&newItem->time, &eventIn->time, sizeof(timer_s));

			newItem->client = eventIn->client;

			newItem->prevItem = listEntry->prevItem;

			newItem->nextItem = listEntry;

			newItem->prevItem->nextItem = newItem;
			newItem->nextItem->prevItem = newItem;

			// item added
			return TRUE;
		}

		// jump to the next item in the list
		listEntry = listEntry->nextItem;
	}

	// item was not added
	return FALSE;
}

//=========================================================================================
//
// Delete an event from the list
//
//=========================================================================================
int CEventList::Delete(CEventList* eventIn)
{
	// start at the head of the list
	listEntry = nextItem;

	// while not at the end of the list
	while(listEntry->nextItem != 0)
	{
		// is this the item to be deleted?
		if(eventIn->time.startTime == listEntry->time.startTime)
		{
			// set the previous item's next pointer in the list
			// to point to the current list item's next pointer
			listEntry->prevItem->nextItem = listEntry->nextItem;

			// set the next item's previous pointer in the list
			// to point to the current list item's previous pointer
			listEntry->nextItem->prevItem = listEntry->prevItem;

			// delete the item
			// this sets the memory of the deleted item to (0xfeeefeee)
			//
			// I think the value means freefree but since there
			// is no "r" in hexadecimal feeefeee must have been deemed appropriate
			// 
			// :-)

			delete listEntry;

			// entry deleted
			return TRUE;
		}

		// jump to the next item in the list
		listEntry = listEntry->nextItem;
	}

	// exit the method
	return FALSE;
}

//=========================================================================================
//
// Delete all events from the list
//
// Source to delete a single item from the list is the same.
// Just remove the while and pass the entry to be deleted
// to Delete()
//=========================================================================================
int CEventList::DeleteList()
{
	listEntry = nextItem;

	while(listEntry->nextItem != 0)
	{
		// hang onto the next item in the list
		// otherwise you will loose this link
		CEventList* temp = listEntry->nextItem;

		// delete the entry
		Delete(listEntry);

		// iterate to the next item
		listEntry = temp;
	}

	return TRUE;

}