//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1998
//
//  File:       dbg_.cpp
//
//--------------------------------------------------------------------------

// We want to continue using _vsnwprintf() below so we silence
// the deprecation warnings.
#define STRSAFE_NO_DEPRECATE
#include <strsafe.h>

/////////////////////////////////////////////////////////////////////
// debug helpers

#if defined(_USE_MTFRMWK_TRACE) || defined(_USE_MTFRMWK_ASSERT)

#ifndef _MTFRMWK_INI_FILE
#define _MTFRMWK_INI_FILE (L"\\system32\\mtfrmwk.ini")
#endif


UINT GetInfoFromIniFile(LPCWSTR lpszSection, LPCWSTR lpszKey, INT nDefault = 0)
{
  static LPCWSTR lpszFile = _MTFRMWK_INI_FILE;
  WCHAR szFilePath[2*MAX_PATH];
    UINT nLen = ::GetSystemWindowsDirectory(szFilePath, 2*MAX_PATH);
    if (nLen == 0)
        return nDefault;

  // NOTICE-2002/04/18-artm  Part of fix for ntraid#ntbug9-540061.
  // We need strsafe.h for this file, and there was a dangerous fctn
  // here that was flagged as deprecated (I've replaced with StringCchCat()).
  HRESULT hr = StringCchCat(szFilePath, 2*MAX_PATH, lpszFile);
  if (FAILED(hr))
  {
      return nDefault;
  }

  // ISSUE-2002/03/08-JeffJon-Since this function is deprecated we should move
  // to using the registry to turn on the debugging flags

  return ::GetPrivateProfileInt(lpszSection, lpszKey, nDefault, szFilePath);
}
#endif // defined(_USE_MTFRMWK_TRACE) || defined(_USE_MTFRMWK_ASSERT)



#if defined(_USE_MTFRMWK_TRACE)

DWORD g_dwTrace = ::GetInfoFromIniFile(L"Debug", L"Trace");


void MtFrmwkTrace(LPCTSTR lpszFormat, ...)
{
    if (g_dwTrace == 0)
        return;

    va_list args;
    va_start(args, lpszFormat);

    int nBuf;
    WCHAR szBuffer[512];

    ZeroMemory(szBuffer, sizeof(szBuffer));

    nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer)/sizeof(WCHAR) - 1, lpszFormat, args);
    // was there an error? was the expanded string too long?
    ASSERT(nBuf >= 0);

    ::OutputDebugString(szBuffer);

    va_end(args);
}

#endif

#if defined(DBG)

void MtFrmwkLogFile(LPCTSTR lpszFormat, ...)
{
    va_list args;
    va_start(args, lpszFormat);

    int nBuf;
    WCHAR szBuffer[512];

    ZeroMemory(szBuffer, sizeof(szBuffer));

    nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer)/sizeof(WCHAR) - 1, lpszFormat, args);


    // If the string is truncated, we should still show it.

  CLogFile* _dlog = CLogFile::GetInstance();            
  if (_dlog)                                            
  {                                                     
     _dlog->writeln(szBuffer);                               
  }                                                     

    va_end(args);
}

void MtFrmwkLogFileIfLog(BOOL bLog, LPCTSTR lpszFormat, ...)
{
  if (bLog)
  {
      va_list args;
      va_start(args, lpszFormat);

      int nBuf;
      WCHAR szBuffer[512];

      ZeroMemory(szBuffer, sizeof(szBuffer));

      nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer)/sizeof(WCHAR) - 1, lpszFormat, args);

      // If the string is truncated, we should still show it.

    CLogFile* _dlog = CLogFile::GetInstance();            
    if (_dlog)                                            
    {                                                     
       _dlog->writeln(szBuffer);                               
    }                                                     

      va_end(args);
  }
}

#endif

//
// Copied and modified from burnslib on 12-07-1999 by JeffJon
//  Needed file logging on DnsSetup call from DCPromo.
//  I wanted it to behave like the DCPromo log but including all of
//  burnslib required too many alterations in the debugging behavior
//  already in place.
//
extern CString LOGFILE_NAME = _T("");
static CLogFile* log_instance = 0;

//
// # of spaces per indentation level
//
static const int TAB = 2;
static int margin = 0;

//
// index to Thread Local Storage slot where the per-thread debug state is
// kept.  Initialized in Startup
//
static DWORD tls_index = 0;

CLogFile* CLogFile::GetInstance()
{
  if (!log_instance && !LOGFILE_NAME.IsEmpty())
  {
    log_instance = new CLogFile(LOGFILE_NAME);
  }
  return log_instance;
}

void CLogFile::KillInstance()
{
  delete log_instance;
  log_instance = 0;
}

BOOL PathExists(PCWSTR pszPath)
{
  DWORD attrs = GetFileAttributes(pszPath);
  if (attrs != 0xFFFFFFFF)
  {
    return TRUE;
  }
  return FALSE;
}

HANDLE OpenFile(PCWSTR pszPath)
{
  //
  // remove the last element of the path to form the parent directory
  //

    HANDLE handle = ::CreateFile(pszPath,
                               GENERIC_WRITE,
                               0,
                               0,
                               OPEN_ALWAYS,
                               FILE_ATTRIBUTE_NORMAL,
                               0);

  return handle;
}

PCWSTR GetSystemRootDirectory()
{
  static CString SYSTEMROOT;

  WCHAR buf[MAX_PATH + 1];

  DWORD result = ::GetWindowsDirectory(buf, MAX_PATH + 1);

  ASSERT(result != 0 && result <= MAX_PATH);
  if (result == 0 || result > MAX_PATH)
  {
    return NULL;
  }
  
  SYSTEMROOT = buf;
  return (PCWSTR)SYSTEMROOT;
}

// locate the log file with the highest-numbered extension, then add 1 and
// return the result.

int DetermineNextLogNumber(PCWSTR logDir, PCWSTR logBaseName)
{
  ASSERT(logDir != NULL);
  ASSERT(logBaseName != NULL);

  int largest = 0;

  CString filespec = CString(logDir) + L"\\" + CString(logBaseName) + L".*.log";

  WIN32_FIND_DATA findData;
  HANDLE ff = ::FindFirstFile(filespec, &findData);

  if (ff != INVALID_HANDLE_VALUE)
  {
    for (;;)
    {
      CString current = findData.cFileName;

      // grab the text between the dots: "nnn" in foo.nnn.ext

      // first dot

      int pos = current.Find(L".");
      if (pos == -1)
      {
        continue;
      }

      CString extension = current.Right(current.GetLength() - pos - 1);

      // second dot

      pos = extension.Find(L".");
      if (pos == -1)
      {
        continue;
      }

      extension = extension.Left(pos);

      long i = 0;
      i = wcstol(extension, L'\0', 10);
      largest = max(i, largest);

      if (!::FindNextFile(ff, &findData))
      {
        ::FindClose(ff);
        break;
      }
    }
  }

  // roll over after 255 
  return (++largest & 0xFF);
}

// Determine the name of the log file.  If a log file of that name already
// exists, rename the existing file to a numbered backup.  Create the new
// log file, return a handle to it.
// 
HANDLE OpenNewLogFile(PCWSTR pszLogBaseName, CString& logName)
{
  CString logDir = CString(GetSystemRootDirectory()) + L"\\debug";
  int i = DetermineNextLogNumber(logDir, pszLogBaseName);

  CString szCount;
  szCount.Format(L"%d", i);
  logName = logDir + L"\\" + pszLogBaseName + L"." + szCount + L".log";

  HANDLE result = OpenFile(logName);
  return result;
}

   

// Create a new log.
//
// logBaseName - base name of the log.  If logging-to-file is active, then a
// file in the %windir%\debug folder will be created/used.  The name of the
// file is of the form %windir%\debug\logBaseName.log.  If a file by that name
// already exists, then the existing file will be renamed
// %windir%\debug\logBaseName.xxx.log, where xxx is an integer 1 greater than
// the last so-numbered file in that directory.

CLogFile::CLogFile(PCWSTR pszLogBaseName)
   :
   szBase_name(pszLogBaseName),
   file_handle(INVALID_HANDLE_VALUE),
   trace_line_number(0)
{
  ASSERT(pszLogBaseName != NULL);

  if (pszLogBaseName != NULL)
  {
    CString logName;
    file_handle = OpenNewLogFile(pszLogBaseName, logName);

    if (file_handle != INVALID_HANDLE_VALUE)
    {
      CString szOpeningFile = L"opening log file ";
      szOpeningFile += logName;
      writeln(szOpeningFile);
    }
  }

  SYSTEMTIME localtime;
  ::GetLocalTime(&localtime);
  CString szTime;
  szTime.Format(L"%d/%d/%d %d:%d:%d.%d",
                 localtime.wMonth,
                 localtime.wDay,
                 localtime.wYear,
                 localtime.wHour,
                 localtime.wMinute,
                 localtime.wSecond,
                 localtime.wMilliseconds);

  writeln(szTime);
}



CLogFile::~CLogFile()
{
  if (IsOpen())
  {
    writeln(L"closing log file");
    ::CloseHandle(file_handle);
    file_handle = INVALID_HANDLE_VALUE;
  }
}

// guarded by caller

void CLogFile::indent()
{
  //
  // indent by adding to the margin
  //
  margin += TAB;
}

BOOL CLogFile::IsOpen() const
{
  return file_handle != INVALID_HANDLE_VALUE;
}



// guarded by caller

void CLogFile::outdent()
{
  //
  // outdent by subtracting from the margin
  //
  ASSERT(margin >= TAB);
  margin = max(0, margin - TAB);
}

void ConvertStringToANSI(PCWSTR pszWide, PSTR* ppAnsi)
{
  ASSERT(ppAnsi);
  ASSERT(pszWide);
  if (!pszWide || !ppAnsi)
  {
      return;
  }

  *ppAnsi = NULL;

  //
  // determine the size of the buffer required to hold the ANSI string
  //

  // This function assumes pszWide is NULL terminated.

  // REVIEWED-2002/03/08-JeffJon-This is proper usage

  int bufsize = 
     ::WideCharToMultiByte(
        CP_ACP, 
        0, 
        pszWide, 
        -1,     // Let WCtoMB determine length of pszWide.
        0, 0, 0, 0);

  if (bufsize > 0)
  {
    *ppAnsi = new CHAR[bufsize];
    if (*ppAnsi == NULL)
    {
      return;
    }
    memset(*ppAnsi, 0, bufsize);

    // We need to pass the size of the buffer *including* space for NULL
    // to WideCharToMultiByte().
    size_t result = ::WideCharToMultiByte(CP_ACP, 
                                          0, 
                                          pszWide, 
                                          -1,   // Let WCtoMB determine length of pszWide.
                                          *ppAnsi, 
                                          bufsize,
                                          0,
                                          0);
    ASSERT(result);

    if (!result)
    {
      *ppAnsi = NULL;
    }
  }
  
}

//
// Spews output to the log according to the current logging type and
// output options in effect.
//
// type - log output type of this output spewage.
//
// text - the spewage.  This is prefaced with the log name, thread id, spewage
// line number, and current indentation.
//
void CLogFile::writeln(PCWSTR pszText)
{
  CString white(L' ',margin);

  // Format the line with thread ID, line number, whitespace, and the text

  CString t = LOGFILE_NAME;
  t.Format(L" t:0x%x %3d ", ::GetCurrentThreadId(), trace_line_number);
  t += white;
  t += pszText;

  if (IsOpen())
  {
    ASSERT(file_handle != INVALID_HANDLE_VALUE);
    ASSERT(!t.IsEmpty());

    PSTR pAnsi;
    ConvertStringToANSI(t, &pAnsi);

    if (pAnsi)
    {
       // NTRAID#NTBUG9-657626-2002/07/11-sburns
       
       size_t bytesToWrite = sizeof(CHAR) * strlen(pAnsi);

       DWORD bytes_written = 0;
       BOOL  success =::WriteFile(file_handle,
                                  pAnsi,
                                  static_cast<ULONG>(bytesToWrite),
                                  &bytes_written,
                                  0);
       ASSERT(success);
       ASSERT(bytes_written == bytesToWrite);
       delete[] pAnsi;
    }
  }
  trace_line_number++;
}

CScopeTracer::CScopeTracer(BOOL bLog, PCWSTR pszMessage_)
  :
  szMessage(pszMessage_),
  m_bLog(bLog)
{
  // build this string once, instead of using the string literal in the
  // below expression (which would implicitly build the string on each
  // evaluation of that expression) as a slight performance gain.
  static const CString ENTER(L"Enter ");

  if (m_bLog)
  {
    CLogFile* li = CLogFile::GetInstance();
    li->writeln(ENTER + szMessage);
    li->indent();
  }
}

CScopeTracer::~CScopeTracer()
{
  // build this string once, instead of using the string literal in the
  // below expression (which would implicitly build the string on each
  // evaluation of that expression) as a slight performance gain.
  static const CString EXIT(L"Exit  ");

  if (m_bLog)
  {
    CLogFile* li = CLogFile::GetInstance();
    li->outdent();
    li->writeln(EXIT + szMessage);
  }
}



#if defined(_USE_MTFRMWK_ASSERT)

DWORD g_dwAssert = ::GetInfoFromIniFile(L"Debug", L"Assert");

BOOL MtFrmwkAssertFailedLine(LPCSTR lpszFileName, int nLine)
{
  if (g_dwAssert == 0)
    return FALSE;

  WCHAR szMessage[_MAX_PATH*2];

    // assume the debugger or auxiliary port

    // NOTICE-2002/04/18-artm  Part of fix for ntraid#ntbug9-540061.
    HRESULT hr = StringCchPrintfW(
        szMessage,          // destination buffer,
        _MAX_PATH*2,        // size of dest. buffer, including null
        _T("Assertion Failed: File %hs, Line %d\n"),
        lpszFileName,
        nLine);

    // If the string is truncated, we should still show it.

    OutputDebugString(szMessage);

    // display the assert
    int nCode = ::MessageBox(NULL, szMessage, _T("Assertion Failed!"),
        MB_TASKMODAL|MB_ICONHAND|MB_ABORTRETRYIGNORE|MB_SETFOREGROUND);

  OutputDebugString(L"after message box\n");
    if (nCode == IDIGNORE)
  {
        return FALSE;   // ignore
  }

    if (nCode == IDRETRY)
  {
        return TRUE;    // will cause DebugBreak
  }

    abort();     // should not return 
    return TRUE;

}
#endif // _USE_MTFRMWK_ASSERT