/*****************************************************************************
 * SD Logger                                                                 *
 *****************************************************************************
 * Modified: 2010-06-01 HBr                                                  *
 * Modified: 2011-03-22 SMa                                                  *
 ****************************************************************************/

#include "SDLog.h"
#include <ClientInfo.h>
#include <DeviceServerBase.h>
#include <iostream>
#include <syslog.h>
#include <time.h>
#include <sys/time.h>
#include <stdlib.h>
#include <rda/Config.h>

#define ENV_DEFAULT_HOSTNAME "SDLOG_HOST"
#define ENV_DEFAULT_PORT     "SDLOG_PORT"

SDLog *SDLog::instance = 0;
std::string SDLog::className = "fesaClass";
std::string SDLog::hostname = "";

SDLog::SDLog()
{
	udpLogger = 0;
	mirrorConsole = true;
	defaultDevice = "fesaDevice";
}

SDLog::~SDLog()
{
	if (udpLogger != 0) delete udpLogger;
	udpLogger = 0;
}

SDLog &SDLog::getInstance()
{
	if (instance == 0L)
	{
		instance = new SDLog();
		if (hostname == "")
		{
			char name[256];
			gethostname(name,sizeof(name));
			hostname = name;
		}
	}
	return *instance;
}

void SDLog::setClassName(const std::string &n)
{
	className = n;
	char name[256];
	gethostname(name,sizeof(name));
	hostname = name;
}

bool SDLog::connect()
{
	const char *host = getenv(ENV_DEFAULT_HOSTNAME);
	if (host == 0) host = rdaConfig::getProperty("cmw.threadedLogger.logServerHostname");
	const char *sport = getenv(ENV_DEFAULT_PORT);
	if (sport == 0) sport = rdaConfig::getProperty("cmw.threadedLogger.logServerPort");
	if (host == 0 || sport == 0)
	{
		return false;
	}
	unsigned short port = (unsigned short)atoi(sport);
	return connect(host,port);
}

bool SDLog::connect(std::string host, unsigned short port)
{
	//Create a new trace logging object using new parameters and switch to it
	UdpLogger* oldLogger = 0;
	if (udpLogger != 0) oldLogger = udpLogger;
	void (*oldHandler)(int) = signal(SIGPIPE, SIG_IGN);
	udpLogger = new UdpLogger(host.c_str(),port,/*connected mode=*/false);
	if (oldLogger != 0) delete oldLogger;
	signal(SIGPIPE, oldHandler);
	return true;
}

void SDLog::logAccess(std::string device, std::string property)
{
	static char buffer[1480];

	const char *user = "Unknown";
	const char *host = "Unknown";
	const rdaClientInfo* clientinfo = rdaDeviceServerBase::getClientInfo();
	if (clientinfo)
	{
		user = clientinfo->getUserName();
		host = clientinfo->getHostName();
	}
  struct timeval tv;
  struct timezone tz;
  gettimeofday(&tv, &tz);
  time_t t = tv.tv_sec;                                    // seconds, UTC
  long timeStamp = (tv.tv_usec/1000);
	struct tm *tmp = gmtime(&t);
//	struct tm *tmp = localtime(&t);
	sprintf(buffer,"%04d-%02d-%02d %02d:%02d:%02d:%03d INFO %s %s.%s %s {%s accessed by %s@%s}",
			tmp->tm_year+1900,tmp->tm_mon+1,tmp->tm_mday,tmp->tm_hour,tmp->tm_min,tmp->tm_sec,0,
			"FESA",className.c_str(),hostname.c_str(),device.c_str(),property.c_str(),user,host);
	send(buffer);
}

void SDLog::logInfo(std::string msg)
{
	logInfo(defaultDevice,msg);
}

void SDLog::logInfo(std::string device, std::string msg)
{
	log(device,msg,"INFO");
}

void SDLog::logWarn(std::string msg)
{
	logWarn(defaultDevice,msg);
}

void SDLog::logWarn(std::string device, std::string msg)
{
	log(device,msg,"WARN");
}

void SDLog::logError(std::string msg)
{
	logError(defaultDevice,msg);
}

void SDLog::logError(std::string device, std::string msg)
{
	log(device,msg,"ERROR");
}

void SDLog::log(const std::string &device, const std::string &msg, const char *level)
{
	static char buffer[1480];

  struct timeval tv;
  struct timezone tz;
  gettimeofday(&tv, &tz);
  time_t t = tv.tv_sec;                                    // seconds, UTC
  long timeStamp = (tv.tv_usec/1000);
	struct tm *tmp = gmtime(&t);
//	struct tm *tmp = localtime(&t);
	sprintf(buffer,"%04d-%02d-%02d %02d:%02d:%02d:%03d %s %s %s.%s %s {%s}",
			tmp->tm_year+1900,tmp->tm_mon+1,tmp->tm_mday,tmp->tm_hour,tmp->tm_min,tmp->tm_sec,0,
			level,"FESA",className.c_str(),hostname.c_str(),device.c_str(),msg.c_str());
	send(buffer);
}

void SDLog::send(const char* msg)
{
	if (mirrorConsole) std::cout << msg << std::endl;
	if (udpLogger == 0) return;
	int err = udpLogger->sendStr(msg);
	switch (err)
	{
		case 0: 			//Everything was ok
		case EAGAIN:		//Resource temporarily unavailable
			break;
		default:
			if (lastError != err)
			{
				std::string str("UDP send failure: ");
				str += strerror(err);
				syslog(LOG_ERR,(char*)str.c_str());
				lastError = err;
			}
	}
}