// LogAPI.cpp : 6(Re DLL S&SC3LPr5D5<3v:/J}!#
//

#include "stdafx.h"

#include	"debug.h"
#include	<stdarg.h> 
#include	<windows.h>
#include	<stdio.h>
#include <iostream>
#include <vector>
#include <string.h>
using namespace std;



HANDLE dump_Mutex;
BOOL dum_log_file = FALSE;

char *g_log_abuff = NULL;
wchar_t *g_log_wbuff = NULL;

std::string g_logfile_path;
#define I_LOG_FILE ("drv_log.txt")

#pragma warning( push )
#pragma warning( disable : 4996 )

VOID GetLogFile(char *szDir)
{
	char csCurrentPath[MAX_PATH] = {0};

	if(g_logfile_path.size() == 0 || dum_log_file == FALSE)
	{
		return;
	}

	strcpy(csCurrentPath,g_logfile_path.c_str());

	if(csCurrentPath[strlen(csCurrentPath) - 1] != '\\')
	{
		strcat(csCurrentPath,"\\");
	}

	strcat(csCurrentPath,I_LOG_FILE);

	strcpy(szDir,csCurrentPath);

}
#pragma warning( pop )

std::string myformat(const char *fmt, ...) 
{ 
	std::string strResult="";
	if (NULL != fmt)
	{
		va_list marker = NULL;            
		va_start(marker, fmt);
		size_t nLength = _vscprintf(fmt, marker) + 1;
		std::vector<char> vBuffer(nLength, '\0');
		int nWritten = vsnprintf_s(&vBuffer[0], vBuffer.size(), nLength, fmt, marker); 
		if (nWritten > 0)
		{
			strResult = &vBuffer[0];
		}
		va_end(marker);
	}
	return strResult;
}

std::wstring myformatw(const wchar_t *fmt, ...) 
{ 
	std::wstring strResult=L"";
	if (NULL != fmt)
	{
		va_list marker = NULL;            
		va_start(marker, fmt);
		size_t nLength = _vscwprintf(fmt, marker) + 1;
		std::vector<wchar_t> vBuffer(nLength, L'\0');
		int nWritten = _vsnwprintf_s(&vBuffer[0], vBuffer.size(), nLength, fmt, marker); 
		if (nWritten > 0)
		{
			strResult = &vBuffer[0];
		}
		va_end(marker);
	}
	return strResult;
}

std::wstring  ConvU8ToWCHAR(char *pChar)
{
	std::wstring str;	
	std::wstring convwstr = L"";
	int uLen = MultiByteToWideChar(CP_UTF8,0,pChar,-1,NULL,0);

	if(uLen > 0)
	{
		str.resize(uLen);
		MultiByteToWideChar(CP_UTF8,0,pChar,-1, (LPWSTR )&str[0],uLen);
		convwstr = str;
	}

	return convwstr;


}

void ClearDumpFile()
{
	if(g_log_wbuff)
	{
		delete []g_log_wbuff;
		g_log_wbuff = NULL;
		g_log_abuff = NULL;
	}
}

bool InitDumpFile()
{
	if(g_log_wbuff == NULL)
	{
		g_log_wbuff = new wchar_t[ONE_LOG_MAX_SIZE];//512k buff
		if(g_log_wbuff == NULL)
		{
			return false;
		}
		g_log_abuff = (char *)g_log_wbuff;

	}

	return true;
}

BOOL WINAPI GetDebugPrintFlag()
{
	return dum_log_file;
}

void WINAPI SetLogFilePath(const char *pPath)
{
	g_logfile_path = pPath;
}

void WINAPI SetDebugPrintFlag(bool Enable)
{
	dum_log_file = Enable;
}

void __DebugPrintSimpleA(
	char*	format, 
	...
	)
{
	DWORD returnedLenth;
	va_list args = NULL;
	if(dum_log_file == TRUE)
	{
		WaitForSingleObject(dump_Mutex,INFINITE);

		if(InitDumpFile() == false)
		{
			ReleaseMutex(dump_Mutex);
			return;
		}


		va_start(args,format);



		memset(g_log_abuff,0,ONE_LOG_MAX_SIZE*sizeof(wchar_t));

		vsprintf_s(g_log_abuff, ONE_LOG_MAX_SIZE,
			format, args );

		if(dum_log_file == TRUE)
		{
			TCHAR szLogFile[MAX_PATH] = {0};
			GetLogFile(szLogFile);
			//OutputDebugStringW(L"start Log itam_log.txt \r\n");
			HANDLE filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
			if(filehandle == INVALID_HANDLE_VALUE)
			{
				//OutputDebugStringW(L"open itam_log.txt failed \r\n");

				ReleaseMutex(dump_Mutex);
				return;
			}

			INT64 filesize = 0;
			if(GetFileSizeEx(filehandle,(PLARGE_INTEGER)&filesize))
			{
				//bigger than 500M,then trim it to zero
				if(filesize > (524288000))
				{
					CloseHandle(filehandle);

					filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE ,0,0,OPEN_EXISTING | TRUNCATE_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
					if(filehandle == INVALID_HANDLE_VALUE)
					{
						//OutputDebugStringW(L"open itam_log.txt failed \r\n");

						ReleaseMutex(dump_Mutex);
						return;
					}
				}
			}

			if(SetFilePointer(filehandle,0,0,FILE_END) == INVALID_SET_FILE_POINTER)
			{
				//OutputDebugStringW(L"SetFilePointer itam_log.txt failed \r\n");
			}
			else
			{
				//char to wchar needed
				//std::wstring wbuff = ConvU8ToWCHAR(g_log_abuff);
				if(WriteFile(filehandle,g_log_abuff,sizeof(char)*strlen(g_log_abuff),&returnedLenth,0) == FALSE)
				{
					//OutputDebugStringW(L"write itam_log.txt failed \r\n");
				}

			}
			CloseHandle(filehandle);

		}

		//OutputDebugStringA(strTime.c_str());

		OutputDebugStringA(g_log_abuff);

#ifdef _CONSOLE
		printf(g_log_abuff);
#endif

		ReleaseMutex(dump_Mutex);

	}



} 

void __DebugPrintA(
				   char*	file,
				   int		line,
				   char*	function,
				   char*	format, 
				   ...
				   )
{
	char* strFileName;
	DWORD returnedLenth;
	va_list args = NULL;
	if(dum_log_file == TRUE)
	{
		WaitForSingleObject(dump_Mutex,INFINITE);


		if(InitDumpFile() == false)
		{
			ReleaseMutex(dump_Mutex);
			return;
		}

		va_start(args,format);

		strFileName = strrchr( file, '\\' );

		if( NULL == strFileName )
		{
			strFileName = file;
		}
		else
		{
			strFileName++;
		}

		memset(g_log_abuff,0,ONE_LOG_MAX_SIZE*sizeof(wchar_t));
		//add time

		SYSTEMTIME st;
		GetLocalTime(&st);
		std::string strTime;
		strTime = myformat("%04d/%02d/%02d %02d:%02d:%02d:%03d",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond,st.wMilliseconds);


		sprintf_s( g_log_abuff, ONE_LOG_MAX_SIZE*sizeof(wchar_t),  "[%s][%s]<%s>(%d), %s(): ",
			PROJECT_NAME,strTime.c_str(),strFileName, line, function );

		vsprintf_s( &g_log_abuff[strlen( g_log_abuff )], ONE_LOG_MAX_SIZE*sizeof(wchar_t) - strlen( g_log_abuff ),
			format, args );

		if(dum_log_file == TRUE)
		{
			TCHAR szLogFile[MAX_PATH] = {0};
			GetLogFile(szLogFile);
			//OutputDebugStringW(L"start Log itam_log.txt \r\n");
			HANDLE filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
			if(filehandle == INVALID_HANDLE_VALUE)
			{
				//OutputDebugStringW(L"open itam_log.txt failed \r\n");

				ReleaseMutex(dump_Mutex);
				return;
			}

			INT64 filesize = 0;
			if(GetFileSizeEx(filehandle,(PLARGE_INTEGER)&filesize))
			{
				//bigger than 500M,then trim it to zero
				if(filesize > (524288000))
				{
					CloseHandle(filehandle);

					filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE ,0,0,OPEN_EXISTING | TRUNCATE_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
					if(filehandle == INVALID_HANDLE_VALUE)
					{
						//OutputDebugStringW(L"open itam_log.txt failed \r\n");

						ReleaseMutex(dump_Mutex);
						return;
					}
				}
			}

			if(SetFilePointer(filehandle,0,0,FILE_END) == INVALID_SET_FILE_POINTER)
			{
				//OutputDebugStringW(L"SetFilePointer itam_log.txt failed \r\n");
			}
			else
			{
				//char to wchar needed
				//std::wstring wbuff = ConvU8ToWCHAR(g_log_abuff);
				if(WriteFile(filehandle,g_log_abuff,sizeof(char)*strlen(g_log_abuff),&returnedLenth,0) == FALSE)
				{
					//OutputDebugStringW(L"write itam_log.txt failed \r\n");
				}

			}
			CloseHandle(filehandle);

		}

		//OutputDebugStringA(strTime.c_str());

		OutputDebugStringA(g_log_abuff);

#ifdef _CONSOLE
		printf(g_log_abuff);
#endif

		ReleaseMutex(dump_Mutex);
	}


} 

void __DebugPrintW(
				   char*	file,
				   int		line,
				   char*	function,
				   wchar_t*	format, 
				   ...
				   )
{
/*	char* strFileName;
	DWORD returnedLenth;
	va_list args = NULL;

	if(InitDumpFile() == false)
	{
		return;
	}

	va_start(args,format);

	strFileName = strrchr( file, '\\' );

	if( NULL == strFileName )
	{
		strFileName = file;
	}
	else
	{
		strFileName++;
	}

	memset(g_log_wbuff,0,ONE_LOG_MAX_SIZE*sizeof(wchar_t));
	//add time

	SYSTEMTIME st;
	GetLocalTime(&st);
	std::wstring strTime;
	strTime = myformat(L"[%04d/%02d/%02d %02d:%02d:%02d]  ",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);

	swprintf_s( g_log_wbuff, ONE_LOG_MAX_SIZE/sizeof(wchar_t),  L"[%S]<%S>(%d), %S(): ",
		PROJECT_NAME,strFileName, line, function );

	vswprintf_s( &g_log_wbuff[wcslen( g_log_wbuff )], ONE_LOG_MAX_SIZE/sizeof(wchar_t) - wcslen( g_log_wbuff ),
		format, args );

	if(dum_log_file == TRUE)
	{
		TCHAR szLogFile[MAX_PATH] = {0};
		GetLogFile(szLogFile);
		WaitForSingleObject(dump_Mutex,INFINITE);
		//OutputDebugStringW(L"start Log itam_log.txt \r\n");
		HANDLE filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
		if(filehandle == INVALID_HANDLE_VALUE)
		{
			//OutputDebugStringW(L"open itam_log.txt failed \r\n");

			ReleaseMutex(dump_Mutex);
			return;
		}
		if(SetFilePointer(filehandle,0,0,FILE_END) == INVALID_SET_FILE_POINTER)
		{
			//OutputDebugStringW(L"SetFilePointer itam_log.txt failed \r\n");
		}
		else
		{
			if(WriteFile(filehandle,g_log_wbuff,sizeof(WCHAR)*wcslen(g_log_wbuff),&returnedLenth,0) == FALSE)
			{
				//OutputDebugStringW(L"write itam_log.txt failed \r\n");
			}

		}
		CloseHandle(filehandle);
		ReleaseMutex(dump_Mutex);

	}

	OutputDebugStringW(strTime.c_str());

	OutputDebugStringW(g_log_wbuff);

#ifdef CONSOLE_OUTPUT
	printf(g_log_wbuff);
#endif
	*/
} 


void __ReleasePrintSimpleA(
	char*	format, 
	...
	)
{


	if(dum_log_file == TRUE)
	{

		TCHAR szLogFile[MAX_PATH] = {0};

		DWORD returnedLenth;
		va_list args = NULL;

		WaitForSingleObject(dump_Mutex,INFINITE);

		if(InitDumpFile() == false)
		{
			ReleaseMutex(dump_Mutex);
			return;
		}

		va_start(args,format);


		memset(g_log_wbuff,0,ONE_LOG_MAX_SIZE*sizeof(wchar_t));

		//add time

		vsprintf_s(g_log_abuff, ONE_LOG_MAX_SIZE,
			format, args );

		GetLogFile(szLogFile);
		//OutputDebugStringW(L"start Log itam_log.txt \r\n");
		HANDLE filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
		if(filehandle == INVALID_HANDLE_VALUE)
		{
			//OutputDebugStringW(L"open itam_log.txt failed \r\n");

			ReleaseMutex(dump_Mutex);
			return;
		}

		INT64 filesize = 0;
		if(GetFileSizeEx(filehandle,(PLARGE_INTEGER)&filesize))
		{
			//bigger than 500M,then trim it to zero
			if(filesize > (524288000))
			{
				CloseHandle(filehandle);

				filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE ,0,0,OPEN_EXISTING | TRUNCATE_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
				if(filehandle == INVALID_HANDLE_VALUE)
				{
					//OutputDebugStringW(L"open itam_log.txt failed \r\n");

					ReleaseMutex(dump_Mutex);
					return;
				}
			}
		}


		if(SetFilePointer(filehandle,0,0,FILE_END) == INVALID_SET_FILE_POINTER)
		{
			//OutputDebugStringW(L"SetFilePointer itam_log.txt failed \r\n");
		}
		else
		{
			//char to wchar needed
			//if(WriteFile(filehandle,strTime.c_str(),sizeof(char)*strTime.length(),&returnedLenth,0) == FALSE)
			//{
			//	//OutputDebugStringW(L"write itam_log.txt failed \r\n");
			//}

			if(WriteFile(filehandle,g_log_abuff,sizeof(char)*strlen(g_log_abuff),&returnedLenth,0) == FALSE)
			{
				//OutputDebugStringW(L"write itam_log.txt failed \r\n");
			}

		}
		CloseHandle(filehandle);

#ifdef _CONSOLE
		printf(g_log_abuff);
#endif

		ReleaseMutex(dump_Mutex);

	}


} 

void __ReleasePrintA(
					 char*	file,
					 int		line,
					 char*	function,
					 char*	format, 
					 ...
					 )
{
	if(dum_log_file == TRUE)
	{
		TCHAR szLogFile[MAX_PATH] = {0};

		char* strFileName;
		DWORD returnedLenth;
		va_list args = NULL;

		WaitForSingleObject(dump_Mutex,INFINITE);

		if(InitDumpFile() == false)
		{
			ReleaseMutex(dump_Mutex);
			return;
		}

		va_start(args,format);

		strFileName = strrchr( file, '\\' );

		if( NULL == strFileName )
		{
			strFileName = file;
		}
		else
		{
			strFileName++;
		}

		if(g_log_wbuff == NULL)
		{
			ReleaseMutex(dump_Mutex);
			return;
		}


		memset(g_log_wbuff,0,ONE_LOG_MAX_SIZE*sizeof(wchar_t));

		//add time
		SYSTEMTIME st;
		GetLocalTime(&st);
		std::string strTime;
		strTime = myformat("%04d/%02d/%02d %02d:%02d:%02d:%03d",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond,st.wMilliseconds);


		sprintf_s( g_log_abuff, ONE_LOG_MAX_SIZE*sizeof(wchar_t),  "[%s][%s]: ",
			PROJECT_NAME,strTime.c_str());

		vsprintf_s( &g_log_abuff[strlen( g_log_abuff )], ONE_LOG_MAX_SIZE*sizeof(wchar_t) - strlen( g_log_abuff ),
			format, args );

		//sprintf_s(g_log_abuff, ONE_LOG_MAX_SIZE,  "[%s]<%s>(%d), %s(): ",
		//	PROJECT_NAME,strFileName, line, function );

		//vsprintf_s(g_log_abuff, ONE_LOG_MAX_SIZE,
		//	format, args );

		GetLogFile(szLogFile);
		//OutputDebugStringW(L"start Log itam_log.txt \r\n");
		HANDLE filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
		if(filehandle == INVALID_HANDLE_VALUE)
		{
			//OutputDebugStringW(L"open itam_log.txt failed \r\n");

			ReleaseMutex(dump_Mutex);
			return;
		}

		INT64 filesize = 0;
		if(GetFileSizeEx(filehandle,(PLARGE_INTEGER)&filesize))
		{
			//bigger than 500M,then trim it to zero
			if(filesize > (524288000))
			{
				CloseHandle(filehandle);

				filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE ,0,0,OPEN_EXISTING | TRUNCATE_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
				if(filehandle == INVALID_HANDLE_VALUE)
				{
					//OutputDebugStringW(L"open itam_log.txt failed \r\n");

					ReleaseMutex(dump_Mutex);
					return;
				}
			}
		}

		if(SetFilePointer(filehandle,0,0,FILE_END) == INVALID_SET_FILE_POINTER)
		{
			//OutputDebugStringW(L"SetFilePointer itam_log.txt failed \r\n");
		}
		else
		{
			//char to wchar needed
			//if(WriteFile(filehandle,strTime.c_str(),sizeof(char)*strTime.length(),&returnedLenth,0) == FALSE)
			//{
			//	//OutputDebugStringW(L"write itam_log.txt failed \r\n");
			//}

			if(WriteFile(filehandle,g_log_abuff,sizeof(char)*strlen(g_log_abuff),&returnedLenth,0) == FALSE)
			{
				//OutputDebugStringW(L"write itam_log.txt failed \r\n");
			}

		}
		CloseHandle(filehandle);

#ifdef _CONSOLE
		printf(g_log_abuff);
#endif

		ReleaseMutex(dump_Mutex);

	}


} 

void __ReleasePrintW(
					 char*	file,
					 int		line,
					 char*	function,
					 wchar_t*	format, 
					 ...
					 )
{
/*	if(dum_log_file == TRUE)
	{

		char* strFileName;
		DWORD returnedLenth;
		TCHAR szLogFile[MAX_PATH] = {0};
		va_list args = NULL;

		if(InitDumpFile() == false)
		{
			return;
		}

		va_start(args,format);

		strFileName = strrchr( file, '\\' );

		if( NULL == strFileName )
		{
			strFileName = file;
		}
		else
		{
			strFileName++;
		}

		if(g_log_wbuff == NULL)
		{
			return;
		}

		WaitForSingleObject(dump_Mutex,INFINITE);

		memset(g_log_wbuff,0,ONE_LOG_MAX_SIZE*sizeof(wchar_t));

		//add time

		SYSTEMTIME st;
		GetLocalTime(&st);
		std::wstring strTime;
		strTime = myformat(L"[%04d/%02d/%02d %02d:%02d:%02d]  ",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);

		//swprintf_s( g_log_wbuff, ONE_LOG_MAX_SIZE,  L"[%S]<%S>(%d), %S(): ",
		//	PROJECT_NAME,strFileName, line, function );

		vswprintf_s( g_log_wbuff, ONE_LOG_MAX_SIZE,
			format, args );

		GetLogFile(szLogFile);
		//OutputDebugStringW(L"start Log itam_log.txt \r\n");
		HANDLE filehandle = CreateFile(szLogFile,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
		if(filehandle == INVALID_HANDLE_VALUE)
		{
			//OutputDebugStringW(L"open itam_log.txt failed \r\n");

			ReleaseMutex(dump_Mutex);
			return;
		}
		if(SetFilePointer(filehandle,0,0,FILE_END) == INVALID_SET_FILE_POINTER)
		{
			//OutputDebugStringW(L"SetFilePointer itam_log.txt failed \r\n");
		}
		else
		{
			if(WriteFile(filehandle,strTime.c_str(),sizeof(WCHAR)*strTime.length(),&returnedLenth,0) == FALSE)
			{
				//OutputDebugStringW(L"write itam_log.txt failed \r\n");
			}

			if(WriteFile(filehandle,g_log_wbuff,sizeof(WCHAR)*wcslen(g_log_wbuff),&returnedLenth,0) == FALSE)
			{
				//OutputDebugStringW(L"write itam_log.txt failed \r\n");
			}


		}
		CloseHandle(filehandle);
		ReleaseMutex(dump_Mutex);

	}
*/
} 



debug_funcs::debug_funcs(void)
{
	dump_Mutex = CreateMutex(0,0,0);

	InitDumpFile();
}


debug_funcs::~debug_funcs(void)
{
	CloseHandle(dump_Mutex);
	ClearDumpFile();
}


debug_funcs g_d_b_g_f_u_n_c_s;

//new line here------------------------