/** @name log.cpp
------------------------------------------------------------------F-----------

 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.

-----------------------------------------------------------------------------

   Description: This file contains class LogFacility

-----------------------------------------------------------------------------


   6/24/1999   Initial creation
   7/19/1999   logError(const ErrorInfo & crclErrorInfo) added

-------------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Include dependencies                                              */
/* ----------------------------------------------------------------------- */

#include <time.h>
#include "uima/log.hpp"

#include "uima/trace.hpp"
#include "uima/comp_ids.h"
#include "uima/msg.h"
#include "uima/resmgr.hpp"
#include "uima/exceptions.hpp"

/* ----------------------------------------------------------------------- */
/*       Constants                                                         */
/* ----------------------------------------------------------------------- */

#define UIMA_LOG_APPLICATION_KEY_UNKNOWN      _TEXT("???")
const size_t                  UIMA_LOG_STATIC_CONVERSION_BUFSIZE = 1024;
static apr_pool_t         * logPool=0;
static apr_thread_mutex_t * logMutex=0;
using namespace std;
/* ----------------------------------------------------------------------- */
/*       Forward declarations                                              */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Types / Classes                                                   */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Private Implementation                                            */
/* ----------------------------------------------------------------------- */
namespace uima {
  FileLogger::FileLogger(std::string filename) : iv_logfile(0) {
     iv_logfile = fopen(filename.c_str(),"a");
     if (iv_logfile == NULL) {   //Need to handle this better
        //cerr << "Could not open the log file " << cpszLogFile << endl;
        string str = "Could not open the log file ";
        str += filename;
        UIMA_EXC_THROW_NEW(Uima_runtime_error,
                           UIMA_MSG_ID_LITERAL_STRING,
                           UIMA_MSG_ID_LITERAL_STRING,
                           ErrorMessage(UIMA_MSG_ID_LITERAL_STRING, str.c_str()),
                           ErrorInfo::unrecoverable);
      } 
  }

  void FileLogger::log(LogStream::EnEntryType enType, 
                      string cpszClass,
                      string cpszMethod,
                      string cpszMsg, 
                      long lUserCode) 
  /* ----------------------------------------------------------------------- */
  {
     //write to local log file if one is available
     string message = cpszClass + " ";
     if (cpszMethod.length() >0) {
       message += cpszMethod + " ";
     }
     message += cpszMsg;
     message = format(enType, message, lUserCode);
     fwrite(message.c_str(), 1, message.size(), iv_logfile);
     fflush(iv_logfile);
  }

   std::string  FileLogger::format(LogStream::EnEntryType enType, 
                                  const string & cpszMsg, 
                                  long lUserCode)  {
    
    time_t rawtime;
    time ( &rawtime );
    string currts = ctime(&rawtime);

    stringstream str;
    str << currts.substr(0,currts.length()-1);

    //map enType to string
    switch (enType) {
    case LogStream::EnWarning :
      str << " WARNING: ";
      str << " RC=" << lUserCode << " ";
      break;
    case LogStream::EnError :
      str << " SEVERE: ";
      str << " RC=" << lUserCode << " ";
      break;
    default:
      str << " INFO: ";
      if (lUserCode !=0) {
        str << " RC=" << lUserCode << " ";
      }
    }
    
    str << cpszMsg << endl;
   
    return str.str();
  }

  TyMessageId LogFacility::getTypeAsMessageId(LogStream::EnEntryType enType) const
  /* ----------------------------------------------------------------------- */
  {
    switch (enType) {
    case LogStream::EnMessage :
      return(UIMA_MSG_ID_LOG_MESSAGE);
    case LogStream::EnWarning :
      return(UIMA_MSG_ID_LOG_WARNING);
    case LogStream::EnError   :
      return(UIMA_MSG_ID_LOG_ERROR);
    default:
      assertWithMsg(false, _TEXT("Unknown EnLogEntryType"));  //lint !e506: Constant value Boolean
    }
    return(0);                                         /* shutup compiler */
  }

  void LogFacility::doLog(LogStream::EnEntryType enType, const TCHAR * cpszMsg, long lUserCode) const
  /* ----------------------------------------------------------------------- */
  {
    apr_thread_mutex_lock(logMutex);
    string method="";
    if (isLoggable(enType)) {
      for (int i=0; i < vecLoggers.size(); i++) {
        vecLoggers.at(i)->log(enType,this->iv_strOrigin,
                                     method,cpszMsg,lUserCode);
      }
    }
    apr_thread_mutex_unlock(logMutex);
  }

  bool LogFacility::isLoggable(LogStream::EnEntryType enType) const {
    ///LogStream::EnEntryType minLogLevel = ResourceManager::getInstance().getLoggingLevel();
    if (enType <  iv_logLevel) {
      return false;
    }
    return true;
  }

  void LogFacility::setLogLevel(LogStream::EnEntryType enType)  {
    ///LogStream::EnEntryType minLogLevel = ResourceManager::getInstance().getLoggingLevel();
    iv_logLevel = enType;
  }

  void LogFacility::log(LogStream::EnEntryType enType, const TCHAR * cpszMsg, long lUserCode) const
  /* ----------------------------------------------------------------------- */
  {
    doLog(enType, cpszMsg, lUserCode);

    if (enType == LogStream::EnError) {
      LogFacility * pclThis = CONST_CAST(LogFacility *, this);
      assert(pclThis == this);
      //remember last error as string/number
      pclThis->iv_lLastUserCode = lUserCode;
      pclThis->iv_strLastError  = string(cpszMsg);
      //reset error info object
      pclThis->iv_errInfo.reset();
    }
  }


  void  LogFacility::log(LogStream::EnEntryType enType, ErrorInfo const & errInfo) const
  /* ----------------------------------------------------------------------- */
  {
    doLog(enType, errInfo.asString().c_str());

    LogFacility * pclThis = CONST_CAST(LogFacility *, this);
    assert(pclThis == this);
    //remember last error as error info object
    pclThis->iv_errInfo = errInfo;
    //reset string/number
    // MSV6 compile error: pclThis->iv_strLastError.clear();
    pclThis->iv_strLastError = std::string();
    pclThis->iv_lLastUserCode = 0;
  }


  void LogFacility::log(LogStream::EnEntryType enType, const icu::UnicodeString & ustrMsg, long lUserCode) const
  /* ----------------------------------------------------------------------- */
  {
    string strMsg;
    UnicodeStringRef ref(ustrMsg);
    ref.extract(strMsg, CCSID::getDefaultName());
    log(enType, strMsg.c_str(), lUserCode);
  }

  /* ----------------------------------------------------------------------- */
  /*       Implementation                                                    */
  /* ----------------------------------------------------------------------- */

  LogStream & LogStream::flush() {
    this->stringstream::flush();
    iv_pLogFacility->flushLogStream();
    str("");
    return (*this);
  }

  LogStream & LogFacility::getLogStream(LogStream::EnEntryType enLogEntryType) {
    iv_logStream.iv_enLogEntryType = enLogEntryType;
    flushLogStream();
    return iv_logStream;
  }

  void LogFacility::flushLogStream() {
    string strMsg = iv_logStream.str();
    if (strMsg.size() == 0) {
      return;
    }
    log(iv_logStream.iv_enLogEntryType, strMsg.c_str());
  }


  LogFacility::LogFacility(icu::UnicodeString const & crEngineName):
      iv_lLastUserCode(0),
      iv_logStream(*this, LogStream::EnMessage),
      vecLoggers(ResourceManager::getInstance().getLoggers()),
      iv_logLevel(ResourceManager::getInstance().getLoggingLevel()) {
   if (logPool == NULL) {
      apr_status_t rv = apr_pool_create( &logPool,NULL );
      if ( rv == APR_SUCCESS ) {
        UnicodeStringRef ref(crEngineName);
        ref.extract(iv_strOrigin, CCSID::getDefaultName()  );
        apr_thread_mutex_create(&logMutex,APR_THREAD_MUTEX_UNNESTED, logPool);
      } else {
        UIMA_EXC_THROW_NEW(ExcOutOfMemory,
          UIMA_ERR_ENGINE_OUT_OF_MEMORY,
          UIMA_MSG_ID_EXC_OUT_OF_MEMORY,
          ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_POOL_FOR_CLASS,"uima::LogFacility"),
          ErrorInfo::unrecoverable);
      }
   }
  }

  LogFacility::LogFacility(icu::UnicodeString const & crEngineName,
                           LogStream::EnEntryType crLoggingLevel):
      iv_lLastUserCode(0),
      iv_logStream(*this, crLoggingLevel),
      vecLoggers(ResourceManager::getInstance().getLoggers()),
      iv_logLevel(crLoggingLevel) {

    if (logPool == NULL) {
      apr_status_t rv = apr_pool_create( &logPool,NULL );
      if ( rv == APR_SUCCESS ) {
        UnicodeStringRef ref(crEngineName);
        ref.extract(iv_strOrigin, CCSID::getDefaultName()  );
        apr_thread_mutex_create(&logMutex,APR_THREAD_MUTEX_UNNESTED, logPool);
      } else {
        UIMA_EXC_THROW_NEW(ExcOutOfMemory,
          UIMA_ERR_ENGINE_OUT_OF_MEMORY,
          UIMA_MSG_ID_EXC_OUT_OF_MEMORY,
          ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_POOL_FOR_CLASS,"uima::LogFacility"),
          ErrorInfo::unrecoverable);
      }
    }
  }

  LogFacility::~LogFacility() {
    flushLogStream();
  }

  const TCHAR * LogFacility::getLastErrorAsCStr(void) const {
    /* ----------------------------------------------------------------------- */
    LogFacility * pclThis = CONST_CAST(LogFacility *, this);
    ErrorInfo errInfo = getLastError();
    if (errInfo.getErrorId() == UIMA_ERR_NONE) {
      return (NULL);
    }
    pclThis->iv_strLastError = getLastError().asString();
    return(iv_strLastError.c_str());
  }

  ErrorInfo const & LogFacility::getLastError() const {
    /* ----------------------------------------------------------------------- */
    // check if we have a string or info based information on last error
    if (iv_strLastError.length() > 0) {
      // if we have error string the error object must be clear
      assert(iv_errInfo.getErrorId() == UIMA_ERR_NONE);
      // now set up the object with the string information
      LogFacility * pclThis = CONST_CAST(LogFacility *, this);
      assert(pclThis == this);
      if (iv_lLastUserCode == 0) {
        pclThis->iv_errInfo.setErrorId(UIMA_ERR_USER_ANNOTATOR_ERROR_UNSPECIFIED);
      } else {
        pclThis->iv_errInfo.setErrorId(iv_lLastUserCode);
      }
      ErrorMessage msg(UIMA_MSG_ID_LOG_TO_ERROR_INFO, iv_strOrigin);
      msg.addParam(iv_strLastError);
      pclThis->iv_errInfo.setMessage(msg);
      pclThis->iv_errInfo.setSeverity(ErrorInfo::unrecoverable);
      // now that the information is transferred into the object clear string
      pclThis->iv_lLastUserCode = 0;
      // MSV6 compile error:
      //pclThis->iv_strLastError.clear();
      pclThis->iv_strLastError = std::string();
    }
    assert(iv_strLastError.length() == 0);
    assert(iv_lLastUserCode == 0);
    return iv_errInfo;
  }


  void LogFacility::logWarning(const ErrorInfo & errInfo) const
  /* ----------------------------------------------------------------------- */
  {
    log(LogStream::EnWarning, errInfo);
  }


  void LogFacility::logError(const ErrorInfo & errInfo) const
  /* ----------------------------------------------------------------------- */
  {
    log(LogStream::EnError, errInfo);
  }

} //namespace uima
/* <EOF> */