// Copyright (c) 1997-1999 Microsoft Corporation
// 
// debug logging tools
//
// 8-13-97 sburns



#ifndef LOG_HPP_INCLUDED
#define LOG_HPP_INCLUDED



// Log provides an interface to a singleton application logging facility.

namespace Burnslib
{

class Log
{
   public:
   
   // use these to set DEFAULT_LOGGING_OPTIONS
   //
   // During CRT startup of our module (i.e. before main, WinMain, or
   // DllMain), the debug code examines the DWORD LogFlags value under the
   // registry key named by REG_ADMIN_RUNTIME_OPTIONS\LOGFILE_NAME.  If the
   // value is not present, it is created and DEFAULT_LOGGING_OPTIONS is
   // written there. If the value is present, it is read.
   //
   // The HIWORD is a bit mask specifying the destination of the logging
   // output.
   //
   // The LOWORD of that value contains a bitmask of the various debug
   // message types to be output:


   // cause LOG output to go to a log file named RUNTIME_NAME.log

   static const DWORD OUTPUT_TO_FILE = (1 << 16);

   // cause LOG output to go to OutputDebugString

   static const DWORD OUTPUT_TO_DEBUGGER = (1 << 17);

   // cause LOG output to go to SpewView application

   static const DWORD OUTPUT_TO_SPEWVIEW = (1 << 18);

   // cause LOG output to be appended to a log file named RUNTIME_NAME.log

   static const DWORD OUTPUT_APPEND_TO_FILE = (1 << 19);


   // output object construction/destruction

   static const DWORD OUTPUT_CTORS = (1 << 0);

   // output calls to AddRef/Release   

   static const DWORD OUTPUT_ADDREFS = (1 << 1);

   // output function call entry

   static const DWORD OUTPUT_FUNCCALLS = (1 << 2);

   // output trace messages

   static const DWORD OUTPUT_LOGS = (1 << 3);

   // output log header

   static const DWORD OUTPUT_HEADER = (1 << 4);

   // output error messages

   static const DWORD OUTPUT_ERRORS = (1 << 5);

   // output time-of-day on each log line

   static const DWORD OUTPUT_TIME_OF_DAY = (1 << 6);

   // output time-since-start on each log line

   static const DWORD OUTPUT_RUN_TIME = (1 << 7);

   // output function/scope exits 

   static const DWORD OUTPUT_SCOPE_EXIT = (1 << 8);



   static const DWORD OUTPUT_MUTE = 0;

   static const DWORD OUTPUT_FULL_VOLUME =
         Log::OUTPUT_TO_FILE
      |  Log::OUTPUT_TO_DEBUGGER
      |  Log::OUTPUT_TO_SPEWVIEW
      |  Log::OUTPUT_CTORS
      |  Log::OUTPUT_ADDREFS
      |  Log::OUTPUT_FUNCCALLS
      |  Log::OUTPUT_LOGS
      |  Log::OUTPUT_HEADER
      |  Log::OUTPUT_ERRORS
      |  Log::OUTPUT_TIME_OF_DAY
      |  Log::OUTPUT_RUN_TIME
      |  Log::OUTPUT_SCOPE_EXIT;

   static const DWORD OUTPUT_TYPICAL =
         Log::OUTPUT_TO_FILE
      |  Log::OUTPUT_TO_DEBUGGER
      |  Log::OUTPUT_FUNCCALLS
      |  Log::OUTPUT_LOGS
      |  Log::OUTPUT_HEADER
      |  Log::OUTPUT_ERRORS;


   // Returns a pointer to the single Burnslib::Log instance.

   static
   Log*
   GetInstance();



   // Called by the initialization machinery to tear down the debugging setup.
   // This takes place during static de-initialization, after
   // main/WinMain/DllMain(DLL_PROCESS_DETACH) has returned.

   static
   void
   Cleanup();



   // Dumps text to the log for the given logging type.
   //
   // type - log type of text.
   // 
   // text - text to dump.
   // 
   // file - filename of source file producing text.
   // 
   // line - line number in source file producing text.

   void
   WriteLn(
      WORD           type,
      const String&  text);
      // const String&  file,
      // unsigned       line);



   // A ScopeTracer object emits text to the log upon construction and
   // destruction.  Place one at the beggining of a lexical scope, and it
   // will log when the scope is entered and exited.
   
   // See LOG_SCOPE, LOG_CTOR, LOG_DTOR, LOG_FUNCTION,
   // LOG_FUNCTION2

   class ScopeTracer
   {
      public:

      // Constructs a new instance, and logs it's creation.
      // 
      // type - the logging type for the log output
      // 
      // message - the text to be emited on construction and destruction

      ScopeTracer(
         DWORD          type,
         const String&  message);

      ~ScopeTracer();

      private:

      String message;
      DWORD   type;
   };


   friend class ScopeTracer;



   private:



   explicit Log(const String& logBaseName);
   ~Log();



   HRESULT
   AdjustLogMargin(int delta);



   String
   ComposeSpewLine(const String& text);



   // Closes and deletes the single Burnslib::Log instance.  If GetInstance
   // is called after this point, then a new instance will be created.

   static
   void
   KillInstance();



   size_t
   GetLogMargin();



   void
   Indent();



   // Returns true if the log file is open, false if not.

   bool
   IsOpen() const
   {
      return fileHandle != INVALID_HANDLE_VALUE;
   }



   void
   Outdent();



   void
   ReadLogFlags();



   // This does all the work, really.

   void
   UnguardedWriteLn(DWORD type, const String& text);



   DWORD
   DebugType()
   {
      // mask off the HIWORD for now.

      return LOWORD(flags);
   }



   bool
   ShouldLogToFile()
   {
      return (flags & OUTPUT_TO_FILE) ? true : false;
   }


   bool
   ShouldAppendLogToFile()
   {
      return (flags & OUTPUT_APPEND_TO_FILE) ? true : false;
   }

   bool
   ShouldLogToDebugger()
   {
      return (flags & OUTPUT_TO_DEBUGGER) ? true : false;
   }



   bool
   ShouldLogToSpewView()
   {
      return (flags & OUTPUT_TO_SPEWVIEW) ? true : false;
   }



   bool
   ShouldLogTimeOfDay()
   {
      return (flags & OUTPUT_TIME_OF_DAY) ? true : false;
   }



   bool
   ShouldLogRunTime()
   {
      return (flags & OUTPUT_RUN_TIME) ? true : false;
   }



   void
   WriteHeader();


   void
   WriteHeaderModule(HMODULE moduleHandle);



   String           baseName;             
   HANDLE           fileHandle;           
   DWORD            flags;                
   HANDLE           spewviewHandle;
   String           spewviewPipeName;
   unsigned         traceLineNumber;      
   CRITICAL_SECTION critsec;              
   DWORD            logfileMarginTlsIndex;

   // not implemented; no instance copying allowed.
   Log(const Log&);
   const Log& operator=(const Log&);
};



// CODEWORK: purge these aliases

const DWORD OUTPUT_MUTE = Log::OUTPUT_MUTE;

const DWORD OUTPUT_FULL_VOLUME = Log::OUTPUT_FULL_VOLUME;

const DWORD OUTPUT_TYPICAL = Log::OUTPUT_TYPICAL;



} // namespace Burnslib
   


#ifdef LOGGING_BUILD


// The logging feature offers the ability to cause output spew at the opening
// and closing of a lexical scope.  This can be done at arbitrary scope with
// the LOG_SCOPE macro, or (more commonly) at function scope with the
// LOG_FUNCTION/2 macros.  Specializations of LOG_FUNCTION include LOG_CTOR/2,
// LOG_DTOR/2, LOG_ADDREF, and LOG_RELEASE.  Refer to the following table:
//    
// Spew macro				      Output spewed (spewn?) when this flag is set
//
// LOG_SCOPE				      OUTPUT_LOGS
// LOG_FUNCTION 			      OUTPUT_FUNCCALLS
// LOG_FUNCTION2			      OUTPUT_FUNCCALLS
// LOG_CTOR				         OUTPUT_CTORS	
// LOG_CTOR2				      OUTPUT_CTORS
// LOG_DTOR				         OUTPUT_CTORS
// LOG_DTOR2				      OUTPUT_CTORS
// LOG_ADDREF				      OUTPUT_ADDREFS
// LOG_RELEASE				      OUTPUT_ADDREFS
// LOG_LOG_EGGS_AND_SPAM_LOG	To be implemented
//       
// At the point where the LOG macro is executed, if the corresponding flag
// is set, a line starting with "Enter " is output.  Subsequent output is then
// indented.  At the point where the lexical scope enclosing the macro ends,
// if the OUTPUT_SCOPE_EXIT flag is set, a line starting with "Exit" is
// output.  Subsequent output is aligned with the next most recent Enter, i.e.
// outdented.
//          
// If the flag corresponding to a LOG macro is not set, then no "Enter" or
// "Exit" lines are output.


   #define LOGT(type, msg)                                                \
   {  /* open scope */                                                    \
      Burnslib::Log* _dlog = Burnslib::Log::GetInstance();                \
      if (_dlog)                                                          \
      {                                                                   \
         _dlog->WriteLn(type, msg);                                       \
      }                                                                   \
   }  /* close scope */                                                   \



   #define LOG(msg) LOGT(Burnslib::Log::OUTPUT_LOGS, msg)



   #define LOG_LAST_WINERROR()                                            \
      LOGT(                                                               \
         Burnslib::Log::OUTPUT_ERRORS,                                    \
         String::format(                                                  \
            L"GetLastError = 0x%1!08X!",                                  \
            ::GetLastError()))                                            \
                                                                          \


   #define LOG_SCOPET(type, msg)                                          \
   Burnslib::Log::ScopeTracer __tracer(type, msg)                  



   #define LOG_SCOPE(msg)                                                 \
   LOG_SCOPET(                                                            \
      Burnslib::Log::OUTPUT_LOGS,                                         \
      msg)



   #define LOG_CTOR(classname)                                            \
   LOG_SCOPET(Burnslib::Log::OUTPUT_CTORS, L"ctor: " TEXT(#classname))



   #define LOG_CTOR2(classname, msg)                                      \
   LOG_SCOPET(                                                            \
      Burnslib::Log::OUTPUT_CTORS,                                        \
         String(L"ctor: " TEXT(#classname) L" ")                          \
      +  String(msg))



   #define LOG_DTOR(classname)                                            \
   LOG_SCOPET(Burnslib::Log::OUTPUT_CTORS, L"dtor: " TEXT(#classname))



   #define LOG_DTOR2(classname, msg)                                      \
   LOG_SCOPET(                                                            \
      Burnslib::Log::OUTPUT_CTORS,                                        \
         String(L"dtor: " TEXT(#classname) L" ")                          \
      +  String(msg))



   #define LOG_ADDREF(classname)                                          \
   LOGT(                                                                  \
      Burnslib::Log::OUTPUT_ADDREFS,                                      \
      L"AddRef: " TEXT(#classname))



   #define LOG_RELEASE(classname)                                         \
   LOGT(                                                                  \
      Burnslib::Log::OUTPUT_ADDREFS,                                      \
      L"Release: " TEXT(#classname))



   #define LOG_FUNCTION(func)                                             \
   LOG_SCOPET(                                                            \
      Burnslib::Log::OUTPUT_FUNCCALLS,                                    \
      TEXT(#func))                                                        



   #define LOG_FUNCTION2(func, s)                                         \
   LOG_SCOPET(                                                            \
      Burnslib::Log::OUTPUT_FUNCCALLS,                                    \
      String(TEXT(#func) L" ").append(s))                                 



   #define LOG_HRESULT(hr)                                                \
   LOGT(                                                                  \
      Burnslib::Log::OUTPUT_ERRORS,                                       \
      String::format(L"HRESULT = 0x%1!08X!", hr))



   #define LOG_BOOL(boolexpr)                                             \
   LOGT(                                                                  \
      Burnslib::Log::OUTPUT_LOGS,                                         \
      String::format(                                                     \
         L"%1 = %2",                                                      \
         TEXT(#boolexpr),                                                 \
         (boolexpr) ? L"true" : L"false"))                                
      


#else    // LOGGING_BUILD

   #define LOGL(type, msg)
   #define LOG(msg)
   #define LOG_LAST_WINERROR()

   #define LOG_SCOPEL(type, msg)
   #define LOG_SCOPE(msg)

   #define LOG_CTOR(classname)
   #define LOG_CTOR2(classname, msg)
   #define LOG_DTOR(classname)
   #define LOG_DTOR2(classname, msg)

   #define LOG_ADDREF(classname)
   #define LOG_RELEASE(classname)

   #define LOG_FUNCTION(func)

   #define LOG_FUNCTION2(func, s)

   #define LOG_HRESULT(hr)
   #define LOG_BOOL(boolexpr)

#endif   // LOGGING_BUILD



#endif   // LOG_HPP_INCLUDED