/////////////////////////////////////////////////////////////////////////////
// File name:      STLogFile.h
// Author:         Nicholas Tsipanov (nicholas@spbteam.com)
// Created:        March 2001
// Last changed:   September, 04, 2002
// Version:        3.2
// Description:    Debug tracing to file 
//
//
/////////////////////////////////////////////////////////////////////////////
// LICENSE
// 
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name is included.
//
// This code can be compiled, modified and distributed freely, providing
// that this copyright information remains intact in the distribution.
//
// This code may be compiled in original or modified form in any private 
// or commercial application.
//
// THIS CODE IS DISTRIBUTED "AS IS".  NO WARRANTY OF ANY
// KIND IS EXPRESSED OR IMPLIED.  YOU USE AT YOUR OWN RISK.
// THE AUTHOR WILL NOT BE LIABLE FOR DATA LOSS, DAMAGES, LOSS
// OF PROFITS OR ANY OTHER KIND OF LOSS WHILE USING OR MISUSING
// THIS SOFTWARE.

#ifndef ___LOGFILE_H__INCLUDED___
#define ___LOGFILE_H__INCLUDED___

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <wtypes.h>
//  Comment the line below if you don't want logging
#define STLOG_DEBUG 1

//  If STLOG_CREATE_NEW is defined then every time your program starts it will create 
//  a new log file named <Executable>00.log, <Executable>01_log.txt, etc. Otherwise it will 
//  overwrite the old <Executable>_log.txt file.
//#define STLOG_CREATE_NEW 1

//Every time the program starts the program will delete the previous file if it uses the 
// single log (sometime it is not needed, for example you want to have all logs of all program runs)
#define STLOG_DELETE_OLD

//  By default the logfile is created in the root folder, but you 
// may want to create a log in the directory where the executable is located
//#define STLOG_CREATE_FILE_IN_THE_SAME_DIRECTORY

//  Undef this if you don't want compile time info (file name and line number 
//  where the logging has been called) included in the log
//#define STLOG_PRINT_COMPILE_INFO 1

//override standard TRACE macro behaviour
#define STLOG_USE_FOR_TRACE

//You can specify your log file name if you want to. In most cases 
// it can be done automatically : Logfile determines where the executable is located
// and creates an <executable>_log.txt file, but if you want a custom file, then 
//unocomment the #define below and somewhere in you .cpp files (stdafx.cpp most appropriate)
// add the line  LPCTSTR cszLogFileName = _T("C:\\LogFile");
//#define STLOG_FILENAME extern LPCTSTR cszLogFileName;


#define STLOG_MAXCOUNTERS 30

/*USAGE::
#include this file into any header that will be included in all files.
For VC projects using precompiled headers the ideal place would be stdafx.h
You can either insert this file into the project or not, in the latter case 
the log classes won't litter your project workspace. This won't affect
usage of logs.

The primary usage of this code is to have a simple way to output debugging
information into the log file, which could be easiliy turned off or on during 
the compile time.
Example :

STLOG_WRITE(_T("saving %d transactions"), nTransactions); 

Another STLogFile feature, marker: 

void MyFunction()
{
	STLOG_MARKER(_T("MyFunction"));
	if (somethingbad())
		return FALSE;
	if (somethinggood())
		return TRUE;

	return FALSE; 
}

If you want to output some binary data (buffer contents) you should use a STLOG_WRITE_DATA macro:

  {
  ...
  char buffer[125];
  // .. fill the buffer with data 

  STLOG_WRITE_DATA(buffer, 125);
  }

This code will write a >>[MyFunction] line on entering the function and <<[MyFunction] 
on exit wherever the program leaves your function.

To find out the problem of the wrong function execution simply add STLOG_LASTERROR:

  HANDLE hFile = CreateFile(....);
  if (INVALID_HANDLE == hFile)
  {
	STLOG_WRITE("Cannot open file");
	STLOG_LASTERROR;
  }
This will print the last textual description of error returned by GetLastError() funciton.

And .. profiling. Before describing log file profiling features it would be appropriate 
to say that all measured timing includes the time for file operation, which slightly 
increases the execution time, therefore this method could only help to *estimate* and 
compare execution times to find bottlenecks of your code.


  ....
  STLOG_PROFILE_FUNCTION(Calculate());
  ..
This code will estimate time needed for function execution. Simple. When the 
logging is turned off this will be transformed to straight call to Calculate().


  {
	STLOG_PROFILE_BLOCK;
	.. code here ...

  }
  This sample of code will print to log file the time when the execution entered the
  profiled block, when the execution leaves it and the time interval between the two points.
  When your program finishes, this macro will print profiling statistics, like how many 
  times this code has been executed, how much time did it take in total, in average, 
  maximium and minimum timings.


  Sometime you want to have intermediate timings and STLogFile has a solution for this case:
  {
	STLOG_PROFILE_BLOCK;
	Phase0();
	STLOG_PROFILE_CHECKPOINT
	Phase1();
	STLOG_PROFILE_CHECKPOINT
	Phase2();
  }
  This will print timings between the check points and the time from beginning of the block 
  every time execution reaches any check point.

There are some options, which can be used for fine tuning like where to create log file,
how to create it and others. 




*/

//---------------  Don't touch anything below this line. 
//---------------  Of all changes and improvements please notify authors via email. 

#ifdef STLOG_DEBUG

	#ifdef STLOG_PRINT_COMPILE_INFO
		static CHAR *CURRENT_FILE;
		static DWORD CURRENT_LINE;
	#endif

	#ifdef STLOG_FILENAME
		STLOG_FILENAME;
	#endif
	static int ___g_nCounterIndex___ = 0;
	class CSTLogFile  
	{
	public:
		static CSTLogFile *GetLogFile() 
		{
			static CSTLogFile LogFile;
			if (!LogFile.m_bIsStarted) 
				LogFile.Start();
			return &LogFile;
		}

		inline void Write0(LPCSTR szEntry)
		{
			::EnterCriticalSection(&m_crit);
			BOOL bOk = TRUE;
			char szTimeString[200];
			bOk = GetTimeString(szTimeString, sizeof(szTimeString));
			char buffer[1024];
#ifdef STLOG_PRINT_COMPILE_INFO
			int nBytes = _snprintf(buffer, sizeof(buffer), "%s : %s\t(from %s,%d)\r\n", szTimeString, szEntry, CURRENT_FILE, CURRENT_LINE);
#else
			int nBytes = _snprintf(buffer, sizeof(buffer), "%s : %s\r\n", szTimeString, szEntry);
#endif
			bOk = (nBytes > 0);
			if (!bOk) goto exit_function;
			DWORD dwWrittenBytes;
			::SetFilePointer(m_hFile, 0, 0, FILE_END);
			::WriteFile(m_hFile, buffer, nBytes, &dwWrittenBytes, NULL);
			bOk = (dwWrittenBytes != (DWORD)nBytes);
			if (!bOk) goto exit_function;
			::FlushFileBuffers(m_hFile);
		exit_function:
			::LeaveCriticalSection(&m_crit);
		}

		void WriteData(LPCVOID pBytes, DWORD dwSize) 
		{
			Write("***Binary data (%d bytes)",  dwSize);
			DWORD dwWrittenBytes;
			::SetFilePointer(m_hFile, 0, 0, FILE_END);
			::WriteFile(m_hFile, pBytes, dwSize, &dwWrittenBytes, NULL);
			::WriteFile(m_hFile, "\r\n", 2, &dwWrittenBytes, NULL);
			Write("***End binary data");
		}
		void Write(LPCSTR szEntry, ...)
		{
			BOOL bOk = TRUE;
			if (m_bIsStarted) 
			{
				char buffer[1024];
				va_list args;
				va_start(args, szEntry);
				bOk = (-1 != _vsnprintf(buffer, sizeof(buffer), szEntry, args));
				va_end(args);
				if (!bOk) return;
				Write0(buffer);
			}
		}

		void Write(LPCWSTR szEntry, ...) 
		{
			BOOL bOk = TRUE;
			if (m_bIsStarted) 
			{
				WCHAR buffer[1024];
				va_list args;
				va_start(args, szEntry);
				int nSize = _vsnwprintf(buffer, sizeof(buffer) / sizeof(WCHAR), szEntry, args);
				bOk = (-1 != nSize);
				va_end(args);
				if (!bOk) return;
				char *pAnsiString = new char[nSize+1];
				wcstombs(pAnsiString, buffer, nSize+1);
				Write0(pAnsiString);
				delete pAnsiString;
			}
		}

		void WriteGUID(REFGUID rguid)
		{
			OLECHAR szBuffer[40];
			StringFromGUID2(rguid, szBuffer, 40);
			Write(_T("GUID: %s"), szBuffer);

		}

		void WriteCLSID(REFCLSID rclsid)
		{
			LPOLESTR lpszBuffer;
			StringFromCLSID(rclsid, &lpszBuffer);
			Write(_T("CLSID: %s"), lpszBuffer);
			CoTaskMemFree(lpszBuffer);
		}

		void WriteIID(REFIID  rclsid)
		{
			LPOLESTR lpszBuffer;
			StringFromIID(rclsid, &lpszBuffer);
			Write(_T("CLSID: %s"), lpszBuffer);
			CoTaskMemFree(lpszBuffer);
		}

		void WriteLastError() 
		{ 
			DWORD dwError = GetLastError(); 
			LPVOID lpMsgBuf;                 
			if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
				NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL ))
			{
				Write(_T("GetLastError returned : %d (no further information)"), dwError);
			} else {
				TCHAR *ret;
				while (ret = _tcsrchr((LPTSTR)lpMsgBuf, _T('\n'))) *ret = _T(' ');
				while (ret = _tcsrchr((LPTSTR)lpMsgBuf, _T('\r'))) *ret = _T(' ');
				CSTLogFile::GetLogFile()->Write(_T("GetLastError returned : 0x%08x: %s)"), dwError, lpMsgBuf);
				LocalFree( lpMsgBuf ); 
			}
		}


		void Start() 
		{
#ifdef STLOG_FILENAME
			Start(cszLogFileName);
#else
			TCHAR wszFileName[MAX_PATH];
			GetLogFileName(wszFileName);
			Start(wszFileName);
#endif
		}

		void Start(LPCTSTR szFilePath) 
		{
			if (m_bIsStarted) return;
			::EnterCriticalSection(&m_crit);
#ifdef STLOG_DELETE_OLD
			::DeleteFile(szFilePath);
#endif
			m_hFile = ::CreateFile(szFilePath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
							OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
			HRESULT hr = GetLastError();
			if (m_hFile != INVALID_HANDLE_VALUE)
			{