/** \file
  Interface to the Shine Error logger
  \author Lukas Nellen
  \version $Id: ErrorLogger.h 22466 2012-12-17 21:54:01Z schroeder $
  \date 24-Jan-2003
*/

#ifndef _utl_ErrorLogger_h_
#define _utl_ErrorLogger_h_

#include <string>
#include <vector>
#include <iostream>
#include <sstream>

#ifndef __CINT__
# include <boost/format.hpp>
#endif

#include <utl/Singleton.h>
#include <utl/Verbosity.h>

namespace utl {

  /**
    \class ErrorLogger ErrorLogger.h "utl/ErrorLogger.h"
    \ingroup errors

    \brief Class to handle routing and writing of error messages

    \todo
    General routing

    \todo
    Improve message formating
  */

  class ErrorLogger : public LeakingSingleton<ErrorLogger> {

  public:
    typedef Verbosity::EVerbosity EVerbosity;

    /// Message severity levels
    enum ESeverityLevel {
      eDebug   = -1,            ///< Debugging message
      eMinSeverity = eDebug,
      eInfo    = 0,             ///< General (informational) message
      eWarning = 1,             ///< Warning message
      eError   = 2,             ///< Error message
      eFatal   = 3,             ///< Fatal error message
      eMaxSeverity = eFatal
    };

    /// General interface for logging a message
    void Log(const ESeverityLevel severity,
             const std::string& functionName,
             const std::string& fileName,
             const int lineNumber,
             const std::string& message,
             EVerbosity verbosity = Verbosity::eDefault,
             bool stripBaseDir = true) const;

    /// \brief Dump message from \c ostringstream instead of of a \c string
    void Log(const ESeverityLevel severity,
             const std::string& functionName,
             const std::string& fileName,
             const int lineNumber,
             const std::ostringstream& message,
             const EVerbosity verbosity = Verbosity::eDefault,
             bool stripBaseDir = true) const
    { Log(severity, functionName, fileName, lineNumber,
          message.str(), verbosity, stripBaseDir); }

#ifndef __CINT__
    /// \brief Dump message from \c boost::format instead of of a \c string
    void Log(const ESeverityLevel severity,
             const std::string& functionName,
             const std::string& fileName,
             const int lineNumber,
             const boost::format& message,
             const EVerbosity verbosity = Verbosity::eDefault,
             bool stripBaseDir = true) const
    { Log(severity, functionName, fileName, lineNumber,
          message.str(), verbosity, stripBaseDir); }
#endif

    /**
      \brief Set the error logging stream

      \note
      This method will be replaced by a more general mechanism for the
      routing of error messages.
    */
    void SetStream(std::ostream& stream) { fOStream = &stream; }

    /// Set the verbosity level
    void SetVerbosity(const EVerbosity verbosity)
    { if (verbosity != Verbosity::eDefault) fVerbosity = verbosity; }

    /// Get the verbosity level
    EVerbosity GetVerbosity() const { return fVerbosity; }

    void SetColorOutput(const bool color) { fColorOutput = color; }

    /// Get string name for severity level
    const std::string& GetSeverityName(const ESeverityLevel severity,
                                       const bool color = false) const;

  private:
    ErrorLogger();
    ErrorLogger(const ErrorLogger& er);
    ErrorLogger& operator=(const ErrorLogger& rhs);

    std::ostream* fOStream;     ///< Current stream for logging messages
    EVerbosity fVerbosity;  ////< Verbosity level
    unsigned int fBaseDirLength;
    bool fColorOutput;

    friend class LeakingSingleton<ErrorLogger>;

  };

}


/**
  \brief Standard message logging macro

  This macro is used by the convenience macros defined below to write
  a log message. It automatically sets the function name, the file
  name and the line number.
*/

#define LOG_MESSAGE_(severity, message) \
utl::ErrorLogger::GetInstance().Log(severity, __func__, __FILE__, __LINE__, \
  message)

/// Brief message logging macro - always do \e terse logging
#define LOG_TERSE_MESSAGE_(severity, message) \
utl::ErrorLogger::GetInstance().Log(severity, __func__, __FILE__,  __LINE__, \
  message, utl::Verbosity::eTerse)

/**
  \brief Macro for logging debugging messages.

  This macro is only active if the \c DEBUG macro is
  defined. Otherwise, debug messages are suppressed at compile time.

  \remark This macro is not named \c DEBUG since \c DEBUG is usually
  used to activate conditionally compiled debugging code.
*/
#ifdef DEBUG
#  define DEBUGLOG(message) LOG_MESSAGE_(utl::ErrorLogger::eDebug, message)
#else
#  define DEBUGLOG(message)
#endif

/// Macro for logging informational messages
#define INFO(message) LOG_MESSAGE_(utl::ErrorLogger::eInfo, message)
/// Macro for logging warning messages
#define WARNING(message) LOG_MESSAGE_(utl::ErrorLogger::eWarning, message)
/// Macro for logging error messages
#define ERROR(message) LOG_MESSAGE_(utl::ErrorLogger::eError, message)
/// Macro for logging fatal messages
#define FATAL(message) LOG_MESSAGE_(utl::ErrorLogger::eFatal, message)

/// Macro for logging informational messages
#define INFO_TERSE(message) LOG_TERSE_MESSAGE_(utl::ErrorLogger::eInfo, \
                                               message)
/// Macro for logging warning messages
#define WARNING_TERSE(message) LOG_TERSE_MESSAGE_(utl::ErrorLogger::eWarning, \
                                                  message)
/// Macro for logging error messages
#define ERROR_TERSE(message) LOG_TERSE_MESSAGE_(utl::ErrorLogger::eError, \
                                                message)
/// Macro for logging fatal messages
#define FATAL_TERSE(message) LOG_TERSE_MESSAGE_(utl::ErrorLogger::eFatal, \
                                                message)

#endif