#pragma once
#include <stdio.h>
#include <Windows.h>

#define MAX_BUFFSIZE 8192
namespace Logger
{
    enum LOGMODE
    {
        CONSOLE = 0x1,
        LOGFILE = 0x2,
        CONSOLE_FILE=0x3
    };

    enum LOGLEVEL
    {
        INFO = 0,
        DEBUG
    };

    class CLogging
    {
    public:
        explicit CLogging();
        explicit CLogging(const int LogMode, char *pFileName=NULL, char *pFileMode=NULL);
        ~CLogging(void);
        void LogPrintf(char* pFormat, ...);

    private:
        inline void OutputLoginfo(const char *pBuff);

    private:
        TCHAR *m_pLogFileName;
        TCHAR *m_pLogFileMode;
        int m_LogMode;
        FILE *m_pFile;
        HANDLE m_hMuex;
    };
}

#include "Logging.h"
#include <time.h>

namespace Logger
{
    CLogging::CLogging(void)
    {
        m_pLogFileName = NULL;
        m_pLogFileMode = NULL;
        m_pFile = NULL;
        m_hMuex = NULL;
    }

    CLogging::CLogging( const int LogMode, char *pFileName, char *pFileMode ):
        m_LogMode(LogMode),m_pLogFileName(pFileName),m_pLogFileMode(pFileMode)
    {
        m_hMuex = CreateMutex(NULL, 0, NULL);
        m_pFile = NULL;

        switch (LogMode)
        {
        case CONSOLE:
            break;
        case LOGFILE:
        case CONSOLE_FILE:
            {
                m_pFile = fopen(m_pLogFileName, pFileMode);
                if (!m_pFile)
                {
                    throw ("Open LogFile Error!");
                }
            }
            break;
        }
    }

    CLogging::~CLogging(void)
    {
        if (m_pFile)
        {
            fclose(m_pFile);
        }
        if (m_hMuex!=NULL)
        {
            CloseHandle(m_hMuex);
        }
    }

    void CLogging::LogPrintf(char* pFormat, ... )
    {   
        DWORD nRet = WaitForSingleObject(m_hMuex, 5000);
        switch (nRet)
        {
        case WAIT_OBJECT_0:
            {
                va_list args; 
                char cText[MAX_BUFFSIZE] = {0}; 
                va_start(args, pFormat); 
                vsprintf(cText, pFormat, args); 
                OutputLoginfo(cText); 
                va_end(args); 
                ReleaseMutex(m_hMuex);
            }
            break;
        case WAIT_TIMEOUT:
            break;
        case WAIT_FAILED:
            break;
        }
    }

    inline void CLogging::OutputLoginfo( const char *pBuff )
    {
        time_t CurrentTime;
        time(&CurrentTime);
        char TimeBuff[MAX_PATH] = {0};
        char cBuff[MAX_BUFFSIZE] = {0};
        // 根据日志级别的不同配置不同的显示信息
        strftime(TimeBuff, sizeof(TimeBuff), "%H:%M:%S",localtime(&CurrentTime) );
        //sprintf_s(cBuff, MAX_BUFFSIZE, "[%s] [%s: %s] %d entered\n %s", TimeBuff, __FILE__, __FUNCTION__, __LINE__, pBuff);
        sprintf_s(cBuff, MAX_BUFFSIZE, "[%s] [%s:] %d entered\n %s", TimeBuff, __FUNCTION__, __LINE__, pBuff);
        switch (m_LogMode)
        {
        case CONSOLE:
            printf(cBuff);
            break;
        case LOGFILE:
            fputs(cBuff, m_pFile);
            break;
        case CONSOLE_FILE:
            printf(cBuff);
            fputs(cBuff, m_pFile);
            break;
        }
    }
}

#pragma once

namespace Logger
{
    class CStopwatch
    {
    private:
        // 64位有符号整数可以用INT64 _int64 LARGE_INTEGER表示
        LARGE_INTEGER m_nPerfFrequency;
        LARGE_INTEGER m_nPerFrefStart;

    public:
        CStopwatch(){QueryPerformanceFrequency(&m_nPerfFrequency); Start();}
        inline void Start(){QueryPerformanceCounter(&m_nPerFrefStart);}

        inline INT64 Now() const
        {
            LARGE_INTEGER nPerfNow;
            QueryPerformanceCounter(&nPerfNow);
            return ((nPerfNow.QuadPart - m_nPerFrefStart.QuadPart) * 1000) / m_nPerfFrequency.QuadPart;
        }

        inline INT64 NowInMicro() const
        {
            LARGE_INTEGER nPerfNow;
            QueryPerformanceCounter(&nPerfNow);
            return ((nPerfNow.QuadPart - m_nPerFrefStart.QuadPart) * 1000000) / m_nPerfFrequency.QuadPart;
        }
    };
}

#include "stdio.h"
#include "Logging.h"
#include "StopWatch.h"
using namespace Logger;

#include <iostream>
using namespace std;


bool bThead1 = false;
bool bThead2 = false;
void TestFun1()
{
    CLogging log(CONSOLE|LOGFILE, "D:\\testlog.txt", "a+");
    for (int i = 0 ; i < 100; i ++)
    {
        log.LogPrintf("%s 0x%0x\n", "hello", i);
    }
}

void TestFun2()
{
    CLogging log(CONSOLE|LOGFILE, "D:\\testlog.txt", "a+");
    for (int i = 101 ; i < 200; i ++)
    {
        log.LogPrintf("%s %0x\n", "hello", i);
    }
}

DWORD WINAPI ThreadFun1(LPVOID lparam)
{
    TestFun1();
    cout << "thread1 end" << endl;
    bThead1 = true;
    return 0;
}
DWORD WINAPI ThreadFun2(LPVOID lparam)
{
    TestFun2();

    cout << "thread2 end" << endl;
    bThead2 = true;
    return 0;
}

int main()
{
    CStopwatch watch;
    //TestFun();  单线程测试
    // 多线程测试
    DWORD lpThreadId1 = 0;
    DWORD lpThreadId2 = 1;
    HANDLE hThread1 = CreateThread(NULL, 0, ThreadFun1, NULL, 0, &lpThreadId1);
    //HANDLE hThread2 = CreateThread(NULL, 0, ThreadFun2, NULL, 0, &lpThreadId2);
    while(1)
    {
        if (bThead1 && bThead2)
        {
            break;
        }
    }
    cout <<"共用时："<< watch.Now()<<"ms" << endl;
    return 0;
}