/*
 # Copyright (c) 2009, 2010 - OpenSLX Project, Computer Center University of
 # Freiburg
 #
 # This program is free software distributed under the GPL version 2.
 # See http://openslx.org/COPYING
 #
 # If you have any feedback please consult http://openslx.org/feedback and
 # send your suggestions, praise, or complaints to feedback@openslx.org
 #
 # General information about OpenSLX can be found at http://openslx.org/
 # -----------------------------------------------------------------------------
 # consoleLogger.cpp
 #  - ???.
 # -----------------------------------------------------------------------------
 */

#include "consoleLogger.h"

#ifdef never
template<class T>
void ConsoleLogger::addListener(T* who, void (T :: *func)(QString))
{
    LogNotify<T> *test = new LogNotify<T>(who, func);
    _CBLog.push_back(dynamic_cast<LogNotifyEntry*>(test));
}

template<class T>
void ConsoleLogger::removeListener(T* who, void (T :: *func)(QString))
{
    if (_CBLog.size())
    {
        for (std::list<LogNotifyEntry*>::iterator it = _CBLog.begin(); it != _CBLog.end(); it++)
        {
            LogNotify<T> *probe = dynamic_cast<LogNotify<T>*>((*it));
            if (probe)
            {
                if (probe->getCallee() == who && probe->getCB() == func)
                {
                    _CBLog.remove((*it));
                }
            }
        }
    }
//    LogNotify<T> *test = new LogNotify<T>(who, func);
    //  _CBLog.push_back(dynamic_cast<LogNotifyEntry*>(test));
}

#endif
int ConsoleLogger::writeLine(QString message, LOG_LEVEL level)
{
    if (message.size() == 0)
        return -1;

    ConsoleEntry consoleEntry(_getTimeStamp(), message, level);
    _announceWrite(consoleEntry);    // tell the listeners!
    _writeLine2File(consoleEntry.getLine());
    _log.push_back(consoleEntry);

    return _log.size();
}

int ConsoleLogger::writeline(const char* message, LOG_LEVEL level)
{
    if (message)
    {
        if (strlen(message) > 0)
            return writeLine(QString(message), level);
    }
    return -1;
}

int ConsoleLogger::writeError(QString error)
{
    return writeLine(error, LOG_ERROR);
}

int ConsoleLogger::writeError(const char* error)
{
    return writeLine(error, LOG_ERROR);
}

int ConsoleLogger::writeTerminal(QString terminal)
{
    // printing the line on the console happens further down the line!
    return writeLine(terminal, LOG_TERMINAL);
}

int ConsoleLogger::writeTerminal(const char* terminal)
{
    if (terminal)
        if (strlen(terminal) > 0)
            return writeTerminal(QString(terminal));

    terminal = NULL;
    return -1;
}

int ConsoleLogger::writeNetwork(QString network)
{
    // printing the line on the console happens further down the line!
    return writeLine(network, LOG_NETWORK);
}

int ConsoleLogger::writeNetwork(const char* network)
{
    if (network)
        if (strlen(network) > 0)
            return writeNetwork(QString(network));

    network = NULL;
    return -1;
}

int ConsoleLogger::writeChat(QString chat)
{
	return writeLine(chat, LOG_CHAT);
}

int ConsoleLogger::writeChat(const char* chat)
{
	if (chat)
		if (strlen(chat) > 0)
			return writeChat(QString(chat));

	chat = NULL;
	return -1;
}

void ConsoleLogger::getLine(int lineNum, char* line)
{
    QString tmp;
    getLine(lineNum, &tmp);
    if (tmp.size() > 0)
    {
        line = new char[_log[lineNum].getLine().size()+1];
        if (line)
        {
            memcpy(line, _log[lineNum].getLine().toUtf8().data(), _log[lineNum].getLine().size());
            if (strlen(line) > 0)
                return;
        }
    }
    line = NULL;

}

void ConsoleLogger::getLine(int lineNum, QString* line)
{
    if (lineNum <= int(_log.size()))
    {
        if (lineNum > 0)
            lineNum--;
        else if (lineNum < 0)
        {
            line = NULL;
            return;
        }
    }
    else
    {
        line->clear();
        line = NULL;
    }
}

void ConsoleLogger::setLogPath(QString logPath)
{
    getLogger()->_logPath = logPath;
    getLogger()->_prepareLog();
}

void ConsoleLogger::setLogName(QString logName)
{
    getLogger()->_logName = logName;
    getLogger()->_prepareLog();
}

void ConsoleLogger::dumpLog(DUMP_MODE mode)
{
    if (mode == DUMP_FILE || (DUMP_FILE_CONCAT && !_fileRead))
        getLogger()->_writeLog();
    if (mode == DUMP_FILE_CONCAT && _fileRead)
        getLogger()->_writeLog(true);
    if (mode == DUMP_ALL_LISTENERS)
    {
        for (int i = 0; i <int(_log.size()); i++)
        {
            _announceWrite(_log[i]);
        }
    }
}

int ConsoleLogger::count = 0;

ConsoleLogger* ConsoleLogger::_logger;

ConsoleLogger* ConsoleLogger::getLogger()
{
    if (!_logger)
    {
        return ConsoleLogger::_logger = new ConsoleLogger();
    }
    else
        return ConsoleLogger::_logger;
}

ConsoleLogger::ConsoleLogger()
        :       _logName(""),
        _logPath(getPolicyFilePath(QString(""))),
        _fileRead(false),
        entryDispatcher()
{
//    _prepareLog();
}

ConsoleLogger::~ConsoleLogger()
{
    // doesnt work!?
    _writeLog();
}

void ConsoleLogger::_prepareLog()
{
    _logFile.close();
    _logFileGood = false;
    _readLog();

    createPolicyDir();
    QString fullpath;
    fullpath.append(_logPath);
    //TODO: handle wether path/ or path were entered?
    fullpath.append(_logName);
    _logFile.open(fullpath.toUtf8().data(), std::ofstream::out | std::ofstream::app);
    if (_logFile.good())
        _logFileGood = true;
    else
        qDebug("ERROR: Logfile ( %s ) not accessible/found. Logs will not be available.", qPrintable(_logPath));

    _logFile.close();
}

void ConsoleLogger::_writeLine2File(QString line)
{
    if (_logFileGood)
    {
        QString fullpath;
        fullpath.append(_logPath);
        //TODO: handle wether path/ or path were entered?
        fullpath.append(_logName);
        _logFile.open(fullpath.toUtf8().data(), std::ofstream::out | std::ofstream::app);

        if (_logFile.good()) // one can never be too sure
        {
            _logFile.write(line.toUtf8().data(), line.size());
        }

        _logFile.close();
    }

}

// overwrites the file and dumps the complete log archive of this session
void ConsoleLogger::_writeLog(bool concat)
{
    if (_logFileGood)
    {
        QString fullpath;
        fullpath.append(_logPath);
        //TODO: handle wether path/ or path were entered?
        fullpath.append(_logName);

        std::vector<ConsoleEntry> *tmpLog = NULL;

        if (concat)
        {
            std::vector<ConsoleEntry> newLog = _prev_log;
            newLog.insert(newLog.end(), _log.begin(), _log.end());
            tmpLog = &newLog;
        }
        else
        {
            tmpLog = &_log;
        }
        _logFile.open(fullpath.toUtf8().data(), std::ofstream::out | std::ofstream::trunc);

        if (_logFile.good()) // one can never be too sure
        {
            for (int i = 0; i < int(tmpLog->size()); i++)
            {
                _logFile.write(tmpLog->at(i).getLine().toUtf8().data(), tmpLog->at(i).getLine().size());
            }
        }

        _logFile.close();
    }
}

void ConsoleLogger::_announceWrite(ConsoleEntry consoleEntry)
{

    entryDispatcher.fire(consoleEntry);
}

void ConsoleLogger::_readLog(QString path)
{
    // todo, read the file, filter the entries and recombine them if possible etc..
    // then save it all to _log_prev.
    // then set _readFile to true, so the dump will concat our current log to the old and THEN overwrite the whole file
    _prev_log.clear();
    _fileRead = false;
}

QString ConsoleLogger::_getTimeStamp()
{
    time_t rawtime;
    tm * ptm;
    time ( &rawtime );

    //ptm = gmtime ( &rawtime );
    ptm = localtime ( &rawtime );

    QString tmpStr;
    if (ptm->tm_mday < 10)
        tmpStr.append(QString("0"));
    tmpStr.append(int2String(ptm->tm_mday));
    tmpStr.push_back('.');
    if (ptm->tm_mon < 10)
        tmpStr.append(QString("0"));
    tmpStr.append(int2String(int(ptm->tm_mon) +1));
    tmpStr.push_back('.');
    int year = (ptm->tm_year % 100);
    if (year < 10)
        tmpStr.append(QString("0"));
    tmpStr.append(int2String(year));
    tmpStr.push_back(' ');
    if (ptm->tm_hour < 10)
        tmpStr.append(QString("0"));
    tmpStr.append(int2String(ptm->tm_hour));
    tmpStr.push_back(':');
    if (ptm->tm_min < 10)
        tmpStr.append(QString("0"));
    tmpStr.append(int2String(ptm->tm_min));
    tmpStr.push_back(':');
    if (ptm->tm_sec < 10)
        tmpStr.append(QString("0"));
    tmpStr.append(int2String(ptm->tm_sec));

    return tmpStr;
}