#ifndef _LOGITEM_H_
#define _LOGITEM_H_

// determine the number of elements in array (not bytes)
#ifndef countof
#define countof(array) (sizeof(array)/sizeof(array[0]))
#endif


#define LIF_NONE            0x80000000
#define LIF_DATE            0x00000001
#define LIF_TIME            0x00000002
#define LIF_DATETIME        0x00000003
#define LIF_MODULE          0x00000004
#define LIF_MODULEPATH      0x00000008
#define LIF_MODULE_ALL      0x0000000C
#define LIF_FILE            0x00000010
#define LIF_FILEPATH        0x00000020
#define LIF_FILE_ALL        0x00000030
#define LIF_CLASS           0x00000040
#define LIF_FUNCTION        0x00000080
#define LIF_LINE            0x00000100
#define LIF_DUPLICATEINODS  0x00000200
#define LIF_APPENDCRLF      0x00000400
#define LIF_DEFAULT         0x000005D0

// private for context switch from C to C++ and back again
#define LIF_CLASS2 0x01000000


/////////////////////////////////////////////////////////////////////////////
// Initialization

class  CLogItem;                                // forward declaration
extern CLogItem g_li;

#define MACRO_LI_Initialize()                                               \
    CLogItem g_li                                                           \

#define MACRO_LI_Initialize2(dwFlags)                                       \
    CLogItem g_li(dwFlags)                                                  \

#define MACRO_LI_InitializeEx(dwFlags, pfLevels, cLevels)                   \
    CLogItem g_li(dwFlags, pfLevels, cLevels)                               \


/////////////////////////////////////////////////////////////////////////////
// Helpers for individual CLogItem attributes

// file
#define MACRO_LI_SmartFile()                                                \
    CSmartItem<LPCTSTR> siFile(g_li.m_szFile, TEXT(__FILE__))               \

#define MACRO_LI_SmartFileEx(dwItems)                                       \
    CSmartItemEx<LPCTSTR> siFileEx(dwItems, LIF_FILE_ALL,                   \
        g_li.m_szFile, TEXT(__FILE__))                                      \

// class
#define MACRO_LI_SmartClass(Class)                                          \
    CSmartItem<LPCTSTR> siClass(g_li.m_szClass, TEXT(#Class))               \

#define MACRO_LI_SmartClassEx(dwItems, Class)                               \
    CSmartItemEx<LPCTSTR> siClassEx(dwItems, LIF_CLASS,                     \
        g_li.m_szClass, TEXT(#Class))                                       \

// function
#define MACRO_LI_SmartFunction(Function)                                    \
    CSmartItem<LPCTSTR> siFunction(g_li.m_szFunction, TEXT(#Function))      \

#define MACRO_LI_SmartFunctionEx(dwItems, Function)                         \
    CSmartItemEx<LPCTSTR> siFunctionEx(dwItems, LIF_FUNCTION,               \
        g_li.m_szFunction, TEXT(#Function))                                 \

// level, indent and flags
#define MACRO_LI_SmartLevel()                                               \
    CSmartItem<UINT> siLevel(g_li.m_nLevel, g_li.m_nLevel+1)                \

#define MACRO_LI_SmartIndent()                                              \
    CSmartItem<UINT> siIndent(g_li.m_nAbsOffset, g_li.m_nAbsOffset+1)       \

#define MACRO_LI_SmartFlags(dwFlags)                                        \
    CSmartItem<DWORD> siFlags(g_li.m_dwFlags, dwFlags)                      \

// wrappers to manipulate flags, offset and relative offset
#define MACRO_LI_SmartAddFlags(dwFlag)                                      \
    CSmartItem<DWORD> siAddFlags(g_li.m_dwFlags, g_li.m_dwFlags |  (dwFlag))\

#define MACRO_LI_SmartRemoveFlags(dwFlag)                                   \
    CSmartItem<DWORD> siRemFlags(g_li.m_dwFlags, g_li.m_dwFlags & ~(dwFlag))\

#define MACRO_LI_Offset(iOffset)                                            \
    CSmartItem<int> siOffset(g_li.m_iRelOffset, g_li.m_iRelOffset + iOffset)\

#define MACRO_LI_SmartRelativeOffset(iRelOffset)                            \
    CSmartItem<int> siRelOffset(g_li.m_iRelOffset, iRelOffset)              \

// private for context switch from C to C++ and back again
#define MACRO_LI_AddClass2()                                                \
    CSmartItem<DWORD> siAddClass2(g_li.m_dwFlags,                           \
        g_li.m_dwFlags | (LIF_CLASS2))                                      \

#define MACRO_LI_RemClass2()                                                \
    CSmartItem<DWORD> siRemClass2(g_li.m_dwFlags,                           \
        g_li.m_dwFlags & ~(LIF_CLASS2))                                     \


/////////////////////////////////////////////////////////////////////////////
// Prologs

// rarely used standalone, is the foundation for the rest
#define MACRO_LI_PrologSameFunction()                                       \
    MACRO_LI_SmartIndent();                                                 \
    MACRO_LI_SmartLevel();                                                  \

//----- More macros, a little more lean -------------------------------------

// for protected or private functions in the same file as caller
#define MACRO_LI_PrologSameClass(Function)                                  \
    MACRO_LI_SmartFunction(Function);                                       \
    MACRO_LI_PrologSameFunction();                                          \

// for protected or private functions in a different file than caller
#define MACRO_LI_PrologSameClass2(Function)                                 \
    MACRO_LI_SmartFile();                                                   \
    MACRO_LI_SmartFunction(Function);                                       \
    MACRO_LI_PrologSameFunction();                                          \

// for C APIs across files
#define MACRO_LI_PrologC(Function)                                          \
    MACRO_LI_RemClass2();                                                   \
                                                                            \
    MACRO_LI_SmartFile();                                                   \
    MACRO_LI_SmartFunction(Function);                                       \
    MACRO_LI_PrologSameFunction();                                          \

// for C APIs with no prototype in the (respective) *.h file
#define MACRO_LI_PrologSameFileC(Function)                                  \
    MACRO_LI_RemClass2();                                                   \
                                                                            \
    MACRO_LI_SmartFunction(Function);                                       \
    MACRO_LI_PrologSameFunction();                                          \

// for things like friends (two friend classes in one file and methods
// of one class are calling private or protected methods of the other, so
// these private or protected methods can have this prolog)
#define MACRO_LI_PrologSameFile(Class, Function)                            \
    MACRO_LI_AddClass2();                                                   \
                                                                            \
    MACRO_LI_SmartClass(Class);                                             \
    MACRO_LI_PrologSameClass(Function);                                     \

// general version, common case
#define MACRO_LI_Prolog(Class, Function)                                    \
    MACRO_LI_SmartFile();                                                   \
    MACRO_LI_PrologSameFile(Class, Function);                               \

//----- Less macros, a little more overhead ---------------------------------

#define PIF_SAMEFUNC   0x00000000
#define PIF_SAMECLASS  0x00000080
#define PIF_SAMECLASS2 0x000000B0
#define PIF_STD_C      0x00000090
#define PIF_SAMEFILE_C 0x000000B0
#define PIF_SAMEFILE   0x000000C0
#define PIF_STD        0x000000F0

#define MACRO_LI_PrologEx(dwItems, Class, Function)                         \
    MACRO_LI_AddClass2();                                                   \
                                                                            \
    MACRO_LI_SmartFileEx(dwItems);                                          \
    MACRO_LI_SmartClassEx(dwItems, Class);                                  \
    MACRO_LI_SmartFunctionEx(dwItems, Function);                            \
    MACRO_LI_PrologSameFunction();                                          \

#define MACRO_LI_PrologSameClassEx(dwItems, Function)                       \
    MACRO_LI_AddClass2();                                                   \
                                                                            \
    MACRO_LI_SmartFileEx(dwItems);                                          \
    MACRO_LI_SmartFunctionEx(dwItems, Function);                            \
    MACRO_LI_PrologSameFunction();                                          \

#define MACRO_LI_PrologEx_C(dwItems, Function)                              \
    MACRO_LI_RemClass2();                                                   \
                                                                            \
    MACRO_LI_SmartFileEx(dwItems);                                          \
    MACRO_LI_SmartFunctionEx(dwItems, Function);                            \
    MACRO_LI_PrologSameFunction();                                          \


/////////////////////////////////////////////////////////////////////////////
// Logging

#define LI0(pszFormat)                                                      \
    g_li.Log(__LINE__, pszFormat)                                           \

#define LI1(pszFormat, arg1)                                                \
    g_li.Log(__LINE__, pszFormat, arg1)                                     \

#define LI2(pszFormat, arg1, arg2)                                          \
    g_li.Log(__LINE__, pszFormat, arg1, arg2)                               \

#define LI3(pszFormat, arg1, arg2, arg3)                                    \
    g_li.Log(__LINE__, pszFormat, arg1, arg2, arg3)                         \


/////////////////////////////////////////////////////////////////////////////
// Additional helpers

#define MACRO_LI_GetFlags()                                                 \
    g_li.GetFlags()                                                         \

#define MACRO_LI_SetFlags(dwFlags)                                          \
    g_li.SetFlags(dwFlags)                                                  \

#define MACRO_LI_GetRelativeOffset()                                        \
    (const int&)g_li.m_iRelOffset                                           \

#define MACRO_LI_SetRelativeOffset(iRelOffset)                              \
    g_li.m_iRelOffset = iRelOffset                                          \


/////////////////////////////////////////////////////////////////////////////
// CLogItem declaration

class CLogItem
{
// Constructors
public:
    CLogItem(DWORD dwFlags = LIF_DEFAULT, LPBOOL pfLogLevels = NULL, UINT cLogLevels = 0);

// Attributes
public:
    TCHAR m_szMessage[3 * MAX_PATH];

    // offset management
    UINT        m_nAbsOffset;
    int         m_iRelOffset;
    static BYTE m_bStep;

    // module, path, file, class, function, line of code
    LPCTSTR m_szFile;
    LPCTSTR m_szClass;
    LPCTSTR m_szFunction;
    UINT    m_nLine;

    // customization
    DWORD m_dwFlags;
    UINT  m_nLevel;

// Operations
public:
    void  SetFlags(DWORD dwFlags)
        { m_dwFlags = dwFlags; }
    DWORD GetFlags() const
        { return m_dwFlags; }

    virtual LPCTSTR WINAPIV Log(int iLine, LPCTSTR pszFormat ...);

// Overridables
public:
    virtual operator LPCTSTR() const;

// Implementation
public:
    virtual ~CLogItem();

protected:
    // implementation data helpers
    static TCHAR m_szModule[MAX_PATH];

    PBOOL m_rgfLogLevels;
    UINT  m_cLogLevels;

    // implementation helper routines
    LPCTSTR makeRawFileName(LPCTSTR pszPath, LPTSTR pszFile, UINT cchFile);

    BOOL setFlag(DWORD dwMask, BOOL fSet = TRUE);
    BOOL hasFlag(DWORD dwMask) const
        { return hasFlag(m_dwFlags, dwMask); }
    static BOOL hasFlag(DWORD dwFlags, DWORD dwMask)
        { return ((dwFlags & dwMask) != 0L); }
};


// Note. (andrewgu) Right now there seems to be no need to create a special
//       CSmartItem<TCHAR> and CSmartItemEx<TCHAR> classes that would
//       store internally the string passed into it. Also, the parameter
//       isn't necessary TCHAR it's just a placeholder for an idea.
/////////////////////////////////////////////////////////////////////////////
// CSmartItem definition

template <class T> class CSmartItem
{
public:
    CSmartItem(T& tOld, const T& tNew)
    {
        m_pitem = NULL;

        if (tOld == tNew)
            return;

        m_item = tOld; m_pitem = &tOld; tOld = tNew;
    }

    ~CSmartItem()
    {
        if (m_pitem == NULL)
            return;

        *m_pitem = m_item; m_pitem = NULL;
    }

    // Attributes
    T *m_pitem,
       m_item;

protected:
    // disable the copy constructor and assignment operator
    CSmartItem(const CSmartItem&)
        {}
    const CSmartItem& operator=(const CSmartItem&)
        { return *this; }
};

/////////////////////////////////////////////////////////////////////////////
// CSmartItemEx definition

template <class T> class CSmartItemEx
{
public:
    CSmartItemEx(DWORD dwAllItems, DWORD dwThisItem, T& tOld, const T& tNew)
    {
        m_pitem   = NULL;
        m_fNoSwap = ((dwAllItems & dwThisItem) == 0);

        if (m_fNoSwap)
            return;

        if (tOld == tNew)
            return;

        m_item = tOld; m_pitem = &tOld; tOld = tNew;
    }

    ~CSmartItemEx()
    {
        if (m_fNoSwap)
            return;

        if (m_pitem == NULL)
            return;

        *m_pitem = m_item; m_pitem = NULL;
    }

    // Attributes
    T *m_pitem,
       m_item;

protected:
    // disable the copy constructor and assignment operator
    CSmartItemEx(const CSmartItem<T>&)
        {}
    const CSmartItemEx<T>& operator=(const CSmartItemEx<T>&)
        { return *this; }

    // implementation data helpers
    BOOL m_fNoSwap;
};
#endif