/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0""

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  This class provide log functionality.

*

*/

#include <logger.h>

#include "logoutput.h"

#include "logoutputimpl.h"

#include <QtAlgorithms>

#include <QHash>

#include <QString>

#include <QStringList>

#include <QDateTime>

#include <QSettings>

#include <QFileInfo>

#include "loglogger.h"

#include "logoutputfactory.h"

typedef QHash<QString,Logger*> LoggerContainer;

Q_GLOBAL_STATIC(LoggerContainer,theLoggerList)

class InitLogLogger 

{

public:

    InitLogLogger() {

        LogOutput *output = new DebugLogOutput();

        output->init();

        Logger::instance(LOGLOGGER_NAME)->addLogOutput(output);

    }

} dummy_instance;

class LoggerPrivate 

{

public:

    LoggerPrivate(const QString &name = QString())

        : mName(name), 

          mDateTimeFormat("hh:mm:ss:zzz"),

          mLogDateTime(true),

          mLogLoggerName(true)

    {

    }

    ~LoggerPrivate()

    {

        clearAllLogOutput();

    }

    void clearAllLogOutput() 

    {

        qDeleteAll(mLogOutputs.begin(),mLogOutputs.end());

        mLogOutputs.clear();

    }

    QString mName;

    QString mDateTimeFormat;

    QList<LogOutput*> mLogOutputs;

    bool mLogDateTime;

    bool mLogLoggerName;

};

Logger *Logger::instance(const QString &name)

{

    if (name.isEmpty()) {

        LOGGER_LOG("Logger::instance() >> name is empty.");

        return 0;

    }

    QString nameLower(name);

    nameLower.toLower();

    Logger *logger = theLoggerList()->value(nameLower);

    if (!logger) {

        logger = new Logger(nameLower);

        theLoggerList()->insert(nameLower,logger);

    }

    return logger;

}

void Logger::closeAll()

{

    qDeleteAll(theLoggerList()->begin(),theLoggerList()->end());

    theLoggerList()->clear();

}

void Logger::close(const QString &name)

{

    QString nameLower(name);

    nameLower.toLower();

    delete theLoggerList()->take(nameLower);

}

Logger::Logger(const QString &name /*= QString()*/,QObject *parent /*= 0*/) : QObject(parent),

    d_ptr(new LoggerPrivate(name))

{

}

Logger::~Logger()

{

    delete d_ptr;

}

void Logger::log(const QString &log)

{

    if (d_ptr->mLogOutputs.isEmpty()) {

        return;

    }

    QString logStr;

    if (d_ptr->mLogDateTime) {

        logStr += QDateTime::currentDateTime().toString(d_ptr->mDateTimeFormat) + ' ';

    }

    if (d_ptr->mLogLoggerName) {

        logStr += '[';

        logStr += name();

        logStr += "]:";

    }

    logStr += log;

    logStr += LINE_SEPERATOR;

    foreach(LogOutput *logOutput, d_ptr->mLogOutputs) {

        logOutput->output(logStr);

    }

}

void Logger::configure(const QString &configFile,QSettings::Format format /*= QSettings::NativeFormat*/)

{

    if (QFileInfo(configFile).exists()) {

        QSettings settings(configFile,format);

        configure(settings);

    }

}

void Logger::configure(QSettings &settings)

{

    clearAllLogOutput();

    settings.beginGroup(name());

    QString strOutput = settings.value(LOGGER_OUTPUT).toString();

    d_ptr->mLogDateTime = settings.value(LOGGER_LOGDATETIME,true).toBool();

    d_ptr->mLogLoggerName = settings.value(LOGGER_LOGLOGGERNAME,true).toBool();

    QString strDateTimeFormat = settings.value(LOGGER_DATETIMEFORMAT).toString();

    if (!strDateTimeFormat.isEmpty()) {

        d_ptr->mDateTimeFormat = strDateTimeFormat;

    }

    settings.endGroup();

    QStringList outputNameList = strOutput.split(' ',QString::SkipEmptyParts);

    foreach(const QString &outputName,outputNameList) {

        LogOutput *output = LogOutputFactory::createLogOutput(outputName);

        if (output) {

            output->setParentLogger(this);

            if (output->load(settings)) {

                addLogOutput(output);

            }

            else {

                delete output;

            }

        }

    }

}

bool Logger::addLogOutput(LogOutput *output)

{

    if (!output) {

        LOGGER_LOG("Logger::addLogOutput >> output is NULL.");

        return false;

    }

    if ( d_ptr->mLogOutputs.indexOf(output) >= 0) {

        LOGGER_LOG("Logger::addLogOutput >> output is already in list.");

        return false;

    }

    if (logOutput(output->name())) {

        LOGGER_LOG( QString("Logger::addLogOutput >> output with the name <") + output->name() + "> is already in list.");

    }

    output->setParentLogger(this);

    d_ptr->mLogOutputs.append(output);

    return true;

}

void Logger::removeLogOutput(LogOutput *output)

{

    d_ptr->mLogOutputs.removeAll(output);

}

LogOutput *Logger::logOutput(const QString &name)

{

    foreach(LogOutput *output,d_ptr->mLogOutputs) {

        if (output->name().compare(name,Qt::CaseInsensitive) == 0) {

            return output;

        }

    }

    return 0;

}

void Logger::clearAllLogOutput()

{

    d_ptr->clearAllLogOutput();

}

QString Logger::name() const

{

    return d_ptr->mName;

}

bool Logger::logDateTime() const

{

    return d_ptr->mLogDateTime;

}

void Logger::setLogDateTime(bool on)

{

    d_ptr->mLogDateTime = on;

}

bool Logger::logLoggerName() const

{

    return d_ptr->mLogLoggerName;

}

void Logger::setLogLoggerName(bool on)

{

    d_ptr->mLogLoggerName = on;

}

QString Logger::dateTimeFormat() const

{

    return d_ptr->mDateTimeFormat;

}

void Logger::setDateTimeFormat(const QString &format)

{

    d_ptr->mDateTimeFormat = format;

}