//	CTraceServer.cpp

//	defines the CTraceServer class

#include "stdafx.h"
#include <time.h>
#include <io.h>
#include <sys/types.h>
#include <sys/timeb.h>
#include <sys/stat.h>
#include "CTraceServer.h"

CTraceServer::CTraceServer() {
	traceFileName = "";
	traceFileNumber = 0;
	fpTraceFile = NULL;
	initialized = false;
	traceThreadStartedEvent = NULL;
	traceThread = NULL;
	traceThreadID = 0;
	traceThreadStartedEvent = CreateEvent(NULL, TRUE, FALSE, "TraceThreadEvent");
	InitializeCriticalSection(&m_csTraceMutex);
}

CTraceServer::~CTraceServer() {
	if (traceThreadStartedEvent)
		CloseHandle(traceThreadStartedEvent);
	traceThreadStartedEvent = NULL;
	DeleteCriticalSection(&m_csTraceMutex);
}

int
CTraceServer::initialize() {
	bool l_initialized;
	int returnCode = 0;
	EnterCriticalSection(&m_csTraceMutex);
	l_initialized = initialized;
	initialized = true;
	LeaveCriticalSection(&m_csTraceMutex);

	if (l_initialized) {
		WaitForSingleObject(traceThreadStartedEvent, INFINITE);
	}
	else {
		bufferMisses = 0;
		// open trace file
		if (!openFirstTraceFile()) {
			returnCode = -10;
		}
		else {
			// initialize trace buffers
			bufferQ.erase(bufferQ.begin(), bufferQ.end());
			for (int i=0; i<NUM_TRACE_BUFFERS; i++) {
				char *buffer = new char[TRACE_BUFFER_SIZE];
				if (buffer != NULL) {
					bufferQ.push_back(buffer);
				}
			}
			traceThread = CreateThread(NULL, 0, TraceThread, this, 0, &traceThreadID);
			WaitForSingleObject(traceThreadStartedEvent, INFINITE);
		}
	}
	return returnCode;
}

int
CTraceServer::uninitialize() {
	bool l_initialized;
	int returnCode = 0;
	EnterCriticalSection(&m_csTraceMutex);
	l_initialized = initialized;
	initialized = false;
	LeaveCriticalSection(&m_csTraceMutex);

	if (!l_initialized) {
		return 0;
	}

	// wait for the file print thread to stop. this way it will return all trace buffers to the free list
	ResetEvent(traceThreadStartedEvent);
	PostThreadMessage(traceThreadID, WM_QUIT, 1234, 5678);
	WaitForSingleObject(traceThreadStartedEvent, INFINITE);
	traceThreadID = 0;
	// free trace buffers
	int buffersFreed = 0;
	int nullBuffers  = 0;
	EnterCriticalSection(&m_csTraceMutex);
	while (bufferQ.size() > 0) {
		char *buffer = bufferQ.front();
		bufferQ.pop_front();
		if (buffer) {
			delete [] (buffer);
			buffersFreed++;
		}
		else
			nullBuffers++;
	}
	LeaveCriticalSection(&m_csTraceMutex);
	fprintf(fpTraceFile, "TRACER : freed %d buffers(%d null buffers) & %d buffer misses\n", buffersFreed, nullBuffers, bufferMisses);

	// close trace file
	if (fpTraceFile) {
		fflush(fpTraceFile);
		fclose(fpTraceFile);
		fpTraceFile = NULL;
	}
	_chmod(traceFileName.c_str(), _S_IREAD);
	CloseHandle(traceThread);
	traceThread = NULL;
	return 0;
}

DWORD
CTraceServer::getTraceThreadID() {
	WaitForSingleObject(traceThreadStartedEvent, INFINITE);
	return traceThreadID;
}

char *
CTraceServer::getTraceBuffer() {
	char *buffer = NULL;
	EnterCriticalSection(&m_csTraceMutex);
	if (bufferQ.size() > 0) {
		buffer = bufferQ.front();
		bufferQ.pop_front();
	}
	LeaveCriticalSection(&m_csTraceMutex);
	if (buffer) {
		buffer[TRACE_BUFFER_SIZE - 1] = '\n';
	}
	else {
		bufferMisses++;
	}
	return buffer;
}


void
CTraceServer::freeTraceBuffer(char *traceBuffer) {
	if (traceBuffer) {
		EnterCriticalSection(&m_csTraceMutex);
		bufferQ.push_back(traceBuffer);
		LeaveCriticalSection(&m_csTraceMutex);
	}
}


string
CTraceServer::makeTraceFileName(int traceFileNum) {
	char fileName[100];
	sprintf(fileName, "TraceFile_%04d.txt", traceFileNum);
	std::string newFile(fileName);
	return newFile;
}

bool
CTraceServer::openFirstTraceFile() {
	// find out the last trace file that was created. open the one after that
	int lastTraceFileNumber = -1;
	struct _stat lastTraceFileStats;
	lastTraceFileStats.st_mtime = 0;
	for (int i=0; i<NUM_TRACE_FILES; i++) {
		string fileName = makeTraceFileName(i);
		struct _stat fileStats;
		if (_stat(fileName.c_str(), &fileStats) == 0) {
			if (fileStats.st_mtime >= lastTraceFileStats.st_mtime) {
				lastTraceFileStats = fileStats;
				lastTraceFileNumber	= i;
			}
		}
	}
	if (lastTraceFileNumber < 0)
		traceFileNumber = 1;
	else
		traceFileNumber	= lastTraceFileNumber;
	traceFileName	= makeTraceFileName(traceFileNumber);
	_chmod(traceFileName.c_str(), _S_IREAD | _S_IWRITE);	// in case the file exists and is read-only, change perms
	fpTraceFile		= fopen(traceFileName.c_str(), "ac");
	if (fpTraceFile == NULL)
		return false;
	return true;
}

bool
CTraceServer::changeTraceFile() {
	bool result = true;
	if (fpTraceFile) 
		fclose(fpTraceFile);
	_chmod(traceFileName.c_str(), _S_IREAD);
	traceFileNumber = (traceFileNumber + 1) % NUM_TRACE_FILES;
	traceFileName = makeTraceFileName(traceFileNumber);
	_chmod(traceFileName.c_str(), _S_IREAD | _S_IWRITE);	// in case the file exists and is read-only, change perms
	fpTraceFile = fopen(traceFileName.c_str(), "wc");
	if (!fpTraceFile)
		result = false;
	return result;
}

int
CTraceServer::trace(char *traceBuffer) {
	int returnValue(0);
	if (PostThreadMessage(traceThreadID, WM_USER, (WPARAM)traceBuffer, 0) == 0) { // that means error happened
		returnValue = (int)GetLastError();
		freeTraceBuffer(traceBuffer);
	}
	return returnValue;
}


DWORD WINAPI
CTraceServer::TraceThread(LPVOID pParams) {
	CTraceServer *traceServer = (CTraceServer *)pParams;
	return traceServer->doTraceThread();
}


void
CTraceServer::printTime() 
{
	time_t currentTime_t;
	time(&currentTime_t);
	struct tm *currentTm = localtime(&currentTime_t);
	fprintf(fpTraceFile, "\n------------ %s", asctime(currentTm));
}

DWORD
CTraceServer::doTraceThread() {
	DWORD resultCode = 0;
	int cnt = 0;
	MSG traceMsg;
	DWORD lastTime = 0;
	BOOL postResult;
	HANDLE thisThread = GetCurrentThread();
	SetThreadPriority(thisThread, THREAD_PRIORITY_IDLE);
	PeekMessage(&traceMsg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
	while(true) {
		postResult = PostThreadMessage(traceThreadID, WM_USER, 0, 0);
		if (postResult != 0)
			break;
		DWORD lastError = GetLastError();
		Sleep(100);
	}
	GetMessage(&traceMsg, NULL, 0, WM_USER);
	printTime();
	SetEvent(traceThreadStartedEvent);
	int flushTimer(0);
	bool needsFlush(false);
	while(true) {
		BOOL result = PeekMessage(&traceMsg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
		if (result != 0 || !needsFlush) {	// there are messages, or we do not need flush. so wait for next message
			result = GetMessage(&traceMsg, NULL, 0, WM_USER);
			if (result == 0) {
				// means WM_QUIT message received
				if ((int)(traceMsg.wParam) == 1234 && (int)(traceMsg.lParam) == 5678) {
					fprintf(fpTraceFile, "Got WM_QUIT message : stopping thread\n");
					printTime();
					fflush(fpTraceFile);
					SetEvent(traceThreadStartedEvent);
					resultCode = 0;
					break;
				}
				else
					fprintf(fpTraceFile, "Got WM_QUIT message\n");
			}
			else if (result == -1) {	// error happened in GetMessage
				printTime();
				fprintf(fpTraceFile, "Error in GetMessage in the tracer thread. Return value 0x%x %d\n", result, result);
			}
			else {	// normal trace message
				char *buffer = (char *)(traceMsg.wParam);
				if (abs(traceMsg.time - lastTime) > TIMESTAMP_INTERVAL) {
					lastTime = traceMsg.time;
					printTime();
				}
				struct timeb currentTime_b;
				ftime(&currentTime_b);
				time_t currentTime_t = currentTime_b.time;
				struct tm *currentTm = localtime(&currentTime_t);
				fprintf(fpTraceFile, "%02u:%02u:%02u.%03u : %s", currentTm->tm_hour, currentTm->tm_min, currentTm->tm_sec, currentTime_b.millitm, buffer);
				needsFlush = true;
				freeTraceBuffer(buffer);
				cnt = (cnt + 1)%10;
				if (!cnt) {
					if (ftell(fpTraceFile) > MAX_TRACEFILE_SIZE) {
						printTime();
						if (!changeTraceFile()) {
							resultCode = -20;
							break;
						}
					}
				}
			}
		}
		else {	// no messages in queue and we need flush
			fflush(fpTraceFile);
			needsFlush = false;
		}
	}
	return resultCode;
}