#ifndef LOG_HPP_
#define LOG_HPP_

#include <string>
#include <cstdio>
#include <cstring>

#include <stdarg.h>

#include <syscall.h>
#include <sys/time.h>
#include <linux/limits.h>

#define LOG_STRING_MAX 4096

#define NEWLINE           "\n"
#define MAX_PATHSIZE      PATH_MAX
#define RETURN_OK             0

#define LOG(level,fmt,...)                                     \
do {                                                                  \
 if( _curPDLevel >= level )                                           \
 {                                                                    \
     log(level,__func__,__FILE__,__LINE__,fmt,##__VA_ARGS__);\
 }                                                                    \
}while( 0 )                                                           \

#define CHECK( cond, retCode, gotoLabel, level, fmt, ... )         \
do {                                                                  \
 if( !( cond ) )                                                      \
 {                                                                    \
     rc = ( retCode );                                                \
     LOG( (level), fmt, ##__VA_ARGS__ );                           \
     goto gotoLabel;                                                  \
 }                                                                    \
}while( 0 )                                                           \

enum PDLEVEL
{
 PDSERVER=0,
 PDERROR,
 PDEVENT,
 PDWARNING,
 PDINFO,
 PDDEBUG
};

extern PDLEVEL _curPDLevel;
const char * getPDLevelDesp( PDLEVEL level );

#define PD_DFT_DIAGLEVEL PDWARNING

void log( PDLEVEL level, const char * func, const char * file,
     unsigned int line, const char * format, ... );

void log( PDLEVEL level, const char * func, const char * file,
     unsigned int lne, std::string message );


#endif

#include "log.hpp"
#include "latch.hpp"
#include "FileOp.hpp"

const static char * PDLEVELSTRING[] =
{
    "SEVERE",
    "ERROR",
    "EVENT",
    "WARNING",
    "INFO",
    "DEBUG"
};

const char * getLevelDesp( PDLEVEL level )
{
    if( (unsigned int)level > (unsigned int)PDDEBUG )
    {
        return "Unknown level";
    }
    return PDLEVELSTRING[(unsigned int)level];
}

const static char * LOG_HEADER_FORMAT = \
        "[Time]     %04d-%02d-%02d-%02d.%02d.%02d           [Level] %s"OSS_NEWLINE \
        "[PID]      %-30d[TID]   %d"OSS_NEWLINE \
        "[Function] %-30s[Line]  %d"OSS_NEWLINE \
        "[File]     %s"OSS_NEWLINE\
        "[Message]  %s"OSS_NEWLINE OSS_NEWLINE;

LEVEL _curPDLevel = DFT_DIAGLEVEL;

static char _diaglogPath[ OSS_MAX_PATHSIZE+1 ] = { 0 };

Latch _logMutex;
FileOperation _logFile;

// open log file
static int _pdLogFileReopen()
{
    int rc = RETURN_OK;
    _logFile.Close();
    rc = _logFile.Open( _pdDiaglogPath );
    if( rc )
    {
        printf( "Failed to open log file, errono = %d", OSS_NEWLINE, rc );
        goto error;
    }

    _logFile.SeekToEnd();
done:
    return rc;
error:
    goto done;
}

// write log file
static int _logFileWrite( const char * pData )
{
    int rc = RETURN_OK;
    size_t dataSize = strlen( pData );
    _logMutex.get();
    if( !_logFile.IsValid() )
    {
        // open the file
        rc = _logFileReopen();
        if( rc )
        {
            printf( "Failed to open log file, erroro = %d"OSS_NEWLINE, rc);
            goto error;
        }
    }
    rc = _logFile.Write( pData, dataSize );
    if( rc )
    {
        printf( "Failed to write into log file, errno = %d"OSS_NEWLINE, rc );
        goto error;
    }
done:
    _logMutex.release();
    return rc;
error:
    goto done;
}

void log( PDLEVEL level, const char * func, const char * file, unsigned int line, const char * format, ... )
{
    int rc = RETURN_OK;
    if( _curPDLevel < level )
    {
        return;
    }
    va_list ap;
    char userInfo[ PD_LOG_STRING_MAX ];
    char sysInfo[PD_LOG_STRING_MAX];
    struct tm otm;
    struct timeval tv;
    struct timezone tz;
    time_t tt;

    gettimeofday( &tv, &tz );
    tt = tv.tv_sec;
    localtime_r( &tt, &otm );

    // create user information
    va_start( ap, format );
    vsnprintf( userInfo, PD_LOG_STRING_MAX, format, ap );
    va_end( ap );

    snprintf( sysInfo, LOG_STRING_MAX, LOG_HEADER_FORMAT,
            otm.tm_year + 1900,
            otm.tm_mon + 1,
            otm.tm_mday,
            otm.tm_hour,
            otm.tm_min,
            otm.tm_sec,
            PDLEVELSTRING[level],
            getpid(),
            syscall(SYS_gettid),
            func,
            line,
            file,
            userInfo );

    printf( "%s"NEWLINE, sysInfo);
/*
   if( _pdDiaglogPath[0] != '\0' )
    {
        rc = _logFileWrite( sysInfo );
        if( rc )
        {
            printf( "Failed to write into log file, errno = %d"NEWLINE, rc );
            printf( "%s"NEWLINE, sysInfo );
        }
    }
*/
    return;
}

/*
int main( int argc, char ** argv )
{
    PD_LOG( PDERROR, "%d", 1 );
    return 0;
}
*/