/*********************************************************************

 *   Copyright 2018, UCAR/Unidata

 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.

 *   $Header$

 *********************************************************************/

#include "config.h"

#ifdef _MSC_VER

#include<io.h>

#endif

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_EXECINFO_H

#include <execinfo.h>

#endif

#include "netcdf.h"

#include "nclog.h"

#define PREFIXLEN 8

#define MAXTAGS 256

#define NCTAGDFALT "Log";

#define NC_MAX_FRAMES 1024

static int nclogginginitialized = 0;

static struct NCLOGGLOBAL {

    int nclogging;

    int tracelevel;

    FILE* nclogstream;

    int depth;

    struct Frame {

  const char* fcn;

  int level;

  int depth;

    } frames[NC_MAX_FRAMES];

} nclog_global = {0,-1,NULL};

static const char* nctagset[] = {"Note","Warning","Error","Debug"};

static const int nctagsize = sizeof(nctagset)/sizeof(char*);

/* Forward */

static const char* nctagname(int tag);

/*!\defgroup NClog NClog Management

@{*/

/*!\internal

*/

void

ncloginit(void)

{

    const char* envv = NULL;

    if(nclogginginitialized)

  return;

    nclogginginitialized = 1;

    memset(&nclog_global,0,sizeof(nclog_global));

    nclog_global.tracelevel = -1;    

    ncsetlogging(0);

    nclog_global.nclogstream = stderr;

    /* Use environment variables to preset nclogging state*/

    /* I hope this is portable*/

    envv = getenv(NCENVLOGGING);

    if(envv != NULL) {

  ncsetlogging(1);

    }

    envv = getenv(NCENVTRACING);

    if(envv != NULL) {

  nctracelevel(atoi(envv));

    }

}

/*!

Enable/Disable logging.

\param[in] tf If 1, then turn on logging, if 0, then turn off logging.

\return The previous value of the logging flag.

*/

int

ncsetlogging(int tf)

{

    int was;

    if(!nclogginginitialized) ncloginit();

    was = nclog_global.nclogging;

    nclog_global.nclogging = tf;

    if(nclog_global.nclogstream == NULL) nclogopen(NULL);

    return was;

}

int

nclogopen(FILE* stream)

{

    if(!nclogginginitialized) ncloginit();

    if(stream == NULL) stream = stderr;

    nclog_global.nclogstream = stream;

    return 1;

}

/*!

Send logging messages. This uses a variable

number of arguments and operates like the stdio

printf function.

\param[in] tag Indicate the kind of this log message.

\param[in] format Format specification as with printf.

*/

void

nclog(int tag, const char* fmt, ...)

{

    if(fmt != NULL) {

      va_list args;

      va_start(args, fmt);

      ncvlog(tag,fmt,args);

      va_end(args);

    }

}

int

ncvlog(int tag, const char* fmt, va_list ap)

{

    const char* prefix;

    int was = -1;

    if(!nclogginginitialized) ncloginit();

    if(tag == NCLOGERR) was = ncsetlogging(1);

    if(!nclog_global.nclogging || nclog_global.nclogstream == NULL) return was;

    prefix = nctagname(tag);

    fprintf(nclog_global.nclogstream,"%s: ",prefix);

    if(fmt != NULL) {

      vfprintf(nclog_global.nclogstream, fmt, ap);

    }

    fprintf(nclog_global.nclogstream, "\n" );

    fflush(nclog_global.nclogstream);

    return was;

}

void

nclogtext(int tag, const char* text)

{

    nclogtextn(tag,text,strlen(text));

}

/*!

Send arbitrarily long text as a logging message.

Each line will be sent using nclog with the specified tag.

\param[in] tag Indicate the kind of this log message.

\param[in] text Arbitrary text to send as a logging message.

*/

void

nclogtextn(int tag, const char* text, size_t count)

{

    NC_UNUSED(tag);

    if(!nclog_global.nclogging || nclog_global.nclogstream == NULL) return;

    fwrite(text,1,count,nclog_global.nclogstream);

    fflush(nclog_global.nclogstream);

}

static const char*

nctagname(int tag)

{

    if(tag < 0 || tag >= nctagsize)

  return "unknown";

    return nctagset[tag];

}

/*!

Send trace messages.

\param[in] level Indicate the level of trace

\param[in] format Format specification as with printf.

*/

int

nctracelevel(int level)

{

    int oldlevel;

    if(!nclogginginitialized) ncloginit();

    oldlevel = nclog_global.tracelevel;

    if(level < 0) {

      nclog_global.tracelevel = level;

      ncsetlogging(0);

    } else { /*(level >= 0)*/

        nclog_global.tracelevel = level;

        ncsetlogging(1);

  nclogopen(NULL); /* use stderr */    

    }

    return oldlevel;

}

void

nctrace(int level, const char* fcn, const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    ncvtrace(level,fcn,fmt,args);

    va_end(args);

}

void

nctracemore(int level, const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    ncvtrace(level,NULL,fmt,args);

    va_end(args);

}

void

ncvtrace(int level, const char* fcn, const char* fmt, va_list ap)

{

    struct Frame* frame;

    if(!nclogginginitialized) ncloginit();

    if(nclog_global.tracelevel < 0) ncsetlogging(0);

    if(fcn != NULL) {

        frame = &nclog_global.frames[nclog_global.depth];

        frame->fcn = fcn;

        frame->level = level;

        frame->depth = nclog_global.depth;

    }

    if(level <= nclog_global.tracelevel) {

  if(fcn != NULL)

            fprintf(nclog_global.nclogstream,"%s: (%d): %s:","Enter",level,fcn);

        if(fmt != NULL)

            vfprintf(nclog_global.nclogstream, fmt, ap);

        fprintf(nclog_global.nclogstream, "\n" );

        fflush(nclog_global.nclogstream);

    }

    if(fcn != NULL) nclog_global.depth++;

}

int

ncuntrace(const char* fcn, int err, const char* fmt, ...)

{

    va_list args;

    struct Frame* frame;

    va_start(args, fmt);

    if(nclog_global.depth == 0) {

  fprintf(nclog_global.nclogstream,"*** Unmatched untrace: %s: depth==0\n",fcn);

  goto done;

    }

    nclog_global.depth--;

    frame = &nclog_global.frames[nclog_global.depth];

    if(frame->depth != nclog_global.depth || strcmp(frame->fcn,fcn) != 0) {

  fprintf(nclog_global.nclogstream,"*** Unmatched untrace: fcn=%s expected=%s\n",frame->fcn,fcn);

  goto done;

    }

    if(frame->level <= nclog_global.tracelevel) {

        fprintf(nclog_global.nclogstream,"%s: (%d): %s: ","Exit",frame->level,frame->fcn);

  if(err)

      fprintf(nclog_global.nclogstream,"err=(%d) '%s':",err,nc_strerror(err));

        if(fmt != NULL)

            vfprintf(nclog_global.nclogstream, fmt, args);

        fprintf(nclog_global.nclogstream, "\n" );

        fflush(nclog_global.nclogstream);

#ifdef HAVE_EXECINFO_H

        if(err != 0)

            ncbacktrace();

#endif

    }

done:

    va_end(args);

    if(err != 0)

        return ncbreakpoint(err);

    else

  return err;

}

int

ncthrow(int err,const char* file,int line)

{

    if(err == 0) return err;

    return ncbreakpoint(err);

}

int

ncbreakpoint(int err)

{

    return err;

}

#ifdef HAVE_EXECINFO_H

#define MAXSTACKDEPTH 100

void

ncbacktrace(void)

{

    int j, nptrs;

    void* buffer[MAXSTACKDEPTH];

    char **strings;

    if(getenv("NCBACKTRACE") == NULL) return;

    nptrs = backtrace(buffer, MAXSTACKDEPTH);

    strings = backtrace_symbols(buffer, nptrs);

    if (strings == NULL) {

        perror("backtrace_symbols");

        errno = 0;

  return;

    }

    fprintf(stderr,"Backtrace:\n");

    for(j = 0; j < nptrs; j++)

  fprintf(stderr,"%s\n", strings[j]);

    free(strings);

}

#endif

/**@}*/