/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

// MessageFile.cpp: implementation of the CMessageFile class.

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "ServerClient.h"

#include "MessageFile.h"

#include "ServerManager.h"

#include "TCErrorConstants.h"

#include <stdio.h>

#include <sys/stat.h>

//#define USE_TEXT_FILE

#ifdef USE_TEXT_FILE

#define WRITE_MODE		"w+t"

#define APPEND_MODE		"a+t"

#else

#define WRITE_MODE		"w+b"

#define APPEND_MODE		"a+b"

#endif

#define FLUSH_FREQ	2000	// # messages to write between flushing (if buffered)

#ifdef _DEBUG

extern BOOL gDoLogging;

#endif

//#define LOG_MESSAGEFILE

#if defined(LOG_MESSAGEFILE) && defined(_DEBUG)

extern CServerManager* gManager;

#define TCDEBUGOPEN() if (gDoLogging) { gManager->m_DebugLog->WaitForAccess(); }

#define TCDEBUGLOGS(s) if (gDoLogging) { sprintf(TCDebugMsg,"%s", s); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA1(s, a1) if (gDoLogging) { sprintf(TCDebugMsg, s, a1); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA2(s, a1, a2) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA3(s, a1, a2, a3) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2, a3); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGCLOSE() if (gDoLogging) { gManager->m_DebugLog->ReleaseAccess(); }

#else

#define TCDEBUGOPEN()

#define TCDEBUGLOGS(s)

#define TCDEBUGLOGA1(s, a1)

#define TCDEBUGLOGA2(s, a1, a2)

#define TCDEBUGLOGA3(s, a1, a2, a3)

#define TCDEBUGCLOSE()

#endif

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CMessageFile::CMessageFile(CHAR* pFilePath, long inClientID)

{

	m_ClientID = inClientID;

	m_FileLocked = FALSE;

	strncpy(m_FilePath, pFilePath, MAX_FILEPATH);

	char toString[30];

	sprintf(toString, "%s%04.4d", MESSAGEFILE_MUTEX_BASENAME, m_ClientID);

	m_Mutex.Open(toString, MESSAGEFILE_MUTEX_TIMEOUT);

	m_hFile = NULL;

	m_numWritten = 0;

	m_numWrittenSinceLastFlush = 0;

	m_Open = FALSE;

#ifdef LOG_FILE_PERFORMANCE

	perfFileName="c:\\tcf\\serverfileperf.txt";

	fpLog = NULL;

	numLogged=0;

#endif

	OPENFILEPERF();

}

CMessageFile::~CMessageFile()

{

	CLOSEFILEPERF();

	Close();

	m_Mutex.Close();

}

long CMessageFile::AddMessage(DWORD inLength, BYTE* inMessage)

{

	long err = TCAPI_ERR_NONE;

	BOOL gotIt = WaitForAccess(); // will lock on first access only

	size_t lenWritten = 0;

#ifdef USE_TEXT_FILE

	lenWritten = inLength;

	int textStart = 20;

	if (inMessage[9] == 0x5a) textStart = 64;

	for (int i = 0; i < textStart; i++)

		fprintf(m_hFile, "%02.2X ", inMessage[i]);

	for (i = textStart; i < (int)inLength; i++)

	{

		if (isprint(inMessage[i]))

			fprintf(m_hFile, "%c", inMessage[i]);

		else

			fprintf(m_hFile, "%02.2X ", inMessage[i]);

	}

	fprintf(m_hFile,"\n");

#else

	lenWritten = fwrite(inMessage, 1, inLength, m_hFile);

#endif

	if (lenWritten < inLength)

	{

		err = TCAPI_ERR_WRITING_FILE;

	}

	else

	{

		m_numWrittenSinceLastFlush++;

		m_numWritten++;

		if ((m_numWrittenSinceLastFlush % FLUSH_FREQ) == 0)

		{

			FlushFile(TRUE);

		}

	}

	LOGFILEPERF("AddMessage\n");

	// no ReleaseAccess this is done by Connection when all bytes processed in buffer and

	//   calls all clients unlock method

	return err;

}

long CMessageFile::Open()

{

	TCDEBUGOPEN();

	long err = TCAPI_ERR_NONE;

	TCDEBUGLOGS("CMessageFile::Open\n");

	WaitForAccess();

	if (m_hFile)

		fclose(m_hFile);

	m_hFile = _fsopen(m_FilePath, APPEND_MODE, _SH_DENYNO);

	if (m_hFile == NULL)

	{

		err = TCAPI_ERR_FILE_DOES_NOT_EXIST;

	}

	else

		m_Open = TRUE;

	ReleaseAccess();

	TCDEBUGCLOSE();

	return err;

}

long CMessageFile::Close()

{

	TCDEBUGOPEN();

	long err = TCAPI_ERR_NONE;

	TCDEBUGLOGA1("CMessageFile::Close numWritten=%d\n", m_numWritten);

	WaitForAccess();

	if (m_hFile)

	{

		fclose(m_hFile);

		m_hFile = NULL;

	}

	ReleaseAccess();

	TCDEBUGCLOSE();

	return err;

}

long CMessageFile::ClearFile()

{

	TCDEBUGOPEN();

	long err = TCAPI_ERR_NONE;

	TCDEBUGLOGA2("CMessageFile::ClearFile m_hFile=%x numWritten=%d\n", m_hFile, m_numWritten);

	WaitForAccess();

	if (m_hFile)

	{

		fclose(m_hFile);

		m_hFile = NULL;

		m_Open = FALSE;

	}

	m_numWritten = 0;

	m_numWrittenSinceLastFlush = 0;

	m_hFile = _fsopen(m_FilePath, WRITE_MODE, _SH_DENYNO);

	if (m_hFile == NULL)

	{

		err = TCAPI_ERR_FILE_DOES_NOT_EXIST;

	}

	else

		m_Open = TRUE;

	LOGFILEPERF("ClearFile\n");

	TCDEBUGLOGA1("CMessageFile::ClearFile m_hFile=%x\n", m_hFile);

	ReleaseAccess();

	TCDEBUGCLOSE();

	return err;

}

void CMessageFile::FlushFile(BOOL numberTimeOut)

{

	if (m_hFile && m_numWrittenSinceLastFlush > 0)

	{

		fflush(m_hFile);

		m_numWrittenSinceLastFlush = 0;

		if (numberTimeOut)

			LOGFILEPERF("FlushFile <number>\n");

		else

			LOGFILEPERF("FlushFile <time>\n");

	}

}

#ifdef LOG_FILE_PERFORMANCE

void CMessageFile::logPerf(char* msg)

{

	if (fpLog)

	{

		SYSTEMTIME sTime;

		GetLocalTime(&sTime);

		fprintf(fpLog, 

			"%02.2d%02.2d-%02.2d:%02.2d:%02.2d.%03.3d: %s",

			sTime.wDay, sTime.wMonth, sTime.wHour, sTime.wMinute, sTime.wSecond, sTime.wMilliseconds,

			msg);

		numLogged++;

		if ((numLogged % 1000) == 0)

			fflush(fpLog);

	}

}

void CMessageFile::openPerf()

{

	struct _stat buf;

	char* dirname = "c:\\tcf";

	int result = _stat(dirname, &buf);

	if (result == 0) // exists

	{

		if (fpLog == NULL)

			fpLog = _fsopen(perfFileName, "at", _SH_DENYNO);

	}

	else

	{

		fpLog = NULL;

	}

}

void CMessageFile::closePerf()

{

	if (fpLog)

	{

		fflush(fpLog);

		fclose(fpLog);

	}

	fpLog = NULL;

}

#endif