/*
 * 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.
 */

#include <log4cxx/logstring.h>
#include <log4cxx/xml/domconfigurator.h>
#include <log4cxx/appender.h>
#include <log4cxx/layout.h>
#include <log4cxx/logger.h>
#include <log4cxx/logmanager.h>
#include <log4cxx/level.h>
#include <log4cxx/spi/filter.h>
#include <log4cxx/helpers/loglog.h>
#include <log4cxx/helpers/stringhelper.h>
#include <log4cxx/helpers/loader.h>
#include <log4cxx/helpers/optionconverter.h>
#include <log4cxx/config/propertysetter.h>
#include <log4cxx/spi/errorhandler.h>
#include <log4cxx/spi/loggerfactory.h>
#include <log4cxx/defaultloggerfactory.h>
#include <log4cxx/helpers/filewatchdog.h>
#include <log4cxx/helpers/synchronized.h>
#include <log4cxx/spi/loggerrepository.h>
#include <log4cxx/spi/loggingevent.h>
#include <log4cxx/helpers/pool.h>
#include <sstream>
#include <log4cxx/helpers/transcoder.h>
#include <log4cxx/rolling/rollingfileappender.h>
#include <log4cxx/rolling/filterbasedtriggeringpolicy.h>
#include <apr_xml.h>
#include <log4cxx/helpers/bytebuffer.h>
#include <log4cxx/helpers/charsetdecoder.h>
#include <log4cxx/net/smtpappender.h>
#include <log4cxx/helpers/messagebuffer.h>

#define LOG4CXX 1
#include <log4cxx/helpers/aprinitializer.h>

using namespace log4cxx;
using namespace log4cxx::xml;
using namespace log4cxx::helpers;
using namespace log4cxx::spi;
using namespace log4cxx::config;
using namespace log4cxx::rolling;


#if APR_HAS_THREADS
namespace log4cxx
{
namespace xml
{
class XMLWatchdog  : public FileWatchdog
{
    public:
        XMLWatchdog(const File& filename) : FileWatchdog(filename)
        {
        }

        /**
        Call DOMConfigurator#doConfigure with the
        <code>filename</code> to reconfigure log4cxx.
        */
        void doOnChange()
        {
            DOMConfigurator().doConfigure(file,
                                          LogManager::getLoggerRepository());
        }
};
}
}
XMLWatchdog* DOMConfigurator::xdog = NULL;
#endif


IMPLEMENT_LOG4CXX_OBJECT(DOMConfigurator)

#define CONFIGURATION_TAG "log4j:configuration"
#define OLD_CONFIGURATION_TAG "configuration"
#define APPENDER_TAG "appender"
#define APPENDER_REF_TAG "appender-ref"
#define PARAM_TAG "param"
#define LAYOUT_TAG "layout"
#define ROLLING_POLICY_TAG "rollingPolicy"
#define TRIGGERING_POLICY_TAG "triggeringPolicy"
#define CATEGORY "category"
#define LOGGER "logger"
#define LOGGER_REF "logger-ref"
#define CATEGORY_FACTORY_TAG "categoryFactory"
#define NAME_ATTR "name"
#define CLASS_ATTR "class"
#define VALUE_ATTR "value"
#define ROOT_TAG "root"
#define ROOT_REF "root-ref"
#define LEVEL_TAG "level"
#define PRIORITY_TAG "priority"
#define FILTER_TAG "filter"
#define ERROR_HANDLER_TAG "errorHandler"
#define REF_ATTR "ref"
#define ADDITIVITY_ATTR "additivity"
#define THRESHOLD_ATTR "threshold"
#define STRINGSTREAM_ATTR "stringstream"
#define CONFIG_DEBUG_ATTR "configDebug"
#define INTERNAL_DEBUG_ATTR "debug"

DOMConfigurator::DOMConfigurator()
    : props(), repository()
{
}

void DOMConfigurator::addRef() const
{
    ObjectImpl::addRef();
}

void DOMConfigurator::releaseRef() const
{
    ObjectImpl::releaseRef();
}

/**
Used internally to parse appenders by IDREF name.
*/
AppenderPtr DOMConfigurator::findAppenderByName(log4cxx::helpers::Pool& p,
        log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
        apr_xml_elem* element,
        apr_xml_doc* doc,
        const LogString& appenderName,
        AppenderMap& appenders)
{
    AppenderPtr appender;
    std::string tagName(element->name);

    if (tagName == APPENDER_TAG)
    {
        if (appenderName == getAttribute(utf8Decoder, element, NAME_ATTR))
        {
            appender = parseAppender(p, utf8Decoder, element, doc, appenders);
        }
    }

    if (element->first_child && !appender)
    {
        appender = findAppenderByName(p, utf8Decoder, element->first_child, doc, appenderName, appenders);
    }

    if (element->next && !appender)
    {
        appender = findAppenderByName(p, utf8Decoder, element->next, doc, appenderName, appenders);
    }

    return appender;
}

/**
 Used internally to parse appenders by IDREF element.
*/
AppenderPtr DOMConfigurator::findAppenderByReference(
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* appenderRef,
    apr_xml_doc* doc,
    AppenderMap& appenders)
{
    LogString appenderName(subst(getAttribute(utf8Decoder, appenderRef, REF_ATTR)));
    AppenderMap::const_iterator match = appenders.find(appenderName);
    AppenderPtr appender;

    if (match != appenders.end())
    {
        appender = match->second;
    }
    else if (doc)
    {
        appender = findAppenderByName(p, utf8Decoder, doc->root, doc, appenderName, appenders);

        if (appender)
        {
            appenders.insert(AppenderMap::value_type(appenderName, appender));
        }
    }

    if (!appender)
    {
        LogLog::error(LOG4CXX_STR("No appender named [") +
                      appenderName + LOG4CXX_STR("] could be found."));
    }

    return appender;
}

/**
Used internally to parse an appender element.
*/
AppenderPtr DOMConfigurator::parseAppender(Pool& p,
        log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
        apr_xml_elem* appenderElement,
        apr_xml_doc* doc,
        AppenderMap& appenders)
{

    LogString className(subst(getAttribute(utf8Decoder, appenderElement, CLASS_ATTR)));
    LogLog::debug(LOG4CXX_STR("Class name: [") + className + LOG4CXX_STR("]"));

    try
    {
        ObjectPtr instance = Loader::loadClass(className).newInstance();
        AppenderPtr appender = instance;
        PropertySetter propSetter(appender);

        appender->setName(subst(getAttribute(utf8Decoder, appenderElement, NAME_ATTR)));

        for (apr_xml_elem* currentElement = appenderElement->first_child;
                currentElement;
                currentElement = currentElement->next)
        {

            std::string tagName(currentElement->name);

            // Parse appender parameters
            if (tagName == PARAM_TAG)
            {
                setParameter(p, utf8Decoder, currentElement, propSetter);
            }
            // Set appender layout
            else if (tagName == LAYOUT_TAG)
            {
                appender->setLayout(parseLayout(p, utf8Decoder, currentElement));
            }
            // Add filters
            else if (tagName == FILTER_TAG)
            {
                std::vector<log4cxx::spi::FilterPtr> filters;
                parseFilters(p, utf8Decoder, currentElement, filters);

                for (std::vector<log4cxx::spi::FilterPtr>::iterator iter = filters.begin();
                        iter != filters.end();
                        iter++)
                {
                    appender->addFilter(*iter);
                }
            }
            else if (tagName == ERROR_HANDLER_TAG)
            {
                parseErrorHandler(p, utf8Decoder, currentElement, appender, doc, appenders);
            }
            else if (tagName == ROLLING_POLICY_TAG)
            {
                RollingPolicyPtr rollPolicy(parseRollingPolicy(p, utf8Decoder, currentElement));
                RollingFileAppenderPtr rfa(appender);

                if (rfa != NULL)
                {
                    rfa->setRollingPolicy(rollPolicy);
                }
            }
            else if (tagName == TRIGGERING_POLICY_TAG)
            {
                ObjectPtr policy(parseTriggeringPolicy(p, utf8Decoder, currentElement));
                RollingFileAppenderPtr rfa(appender);

                if (rfa != NULL)
                {
                    rfa->setTriggeringPolicy(policy);
                }
                else
                {
                    log4cxx::net::SMTPAppenderPtr smtpa(appender);

                    if (smtpa != NULL)
                    {
                        log4cxx::spi::TriggeringEventEvaluatorPtr evaluator(policy);
                        smtpa->setEvaluator(evaluator);
                    }
                }
            }
            else if (tagName == APPENDER_REF_TAG)
            {
                LogString refName = subst(getAttribute(utf8Decoder, currentElement, REF_ATTR));

                if (appender->instanceof(AppenderAttachable::getStaticClass()))
                {
                    AppenderAttachablePtr aa(appender);
                    LogLog::debug(LOG4CXX_STR("Attaching appender named [") +
                                  refName + LOG4CXX_STR("] to appender named [") +
                                  appender->getName() + LOG4CXX_STR("]."));
                    aa->addAppender(findAppenderByReference(p, utf8Decoder, currentElement, doc, appenders));
                }
                else
                {
                    LogLog::error(LOG4CXX_STR("Requesting attachment of appender named [") +
                                  refName + LOG4CXX_STR("] to appender named [") + appender->getName() +
                                  LOG4CXX_STR("] which does not implement AppenderAttachable."));
                }
            }
        }

        propSetter.activate(p);
        return appender;
    }
    /* Yes, it's ugly.  But all of these exceptions point to the same
        problem: we can't create an Appender */
    catch (Exception& oops)
    {
        LogLog::error(LOG4CXX_STR("Could not create an Appender. Reported error follows."),
                      oops);
        return 0;
    }
}

/**
Used internally to parse an {@link ErrorHandler} element.
*/
void DOMConfigurator::parseErrorHandler(Pool& p,
                                        log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
                                        apr_xml_elem* element,
                                        AppenderPtr& appender,
                                        apr_xml_doc* doc,
                                        AppenderMap& appenders)
{

    ErrorHandlerPtr eh = OptionConverter::instantiateByClassName(
                             subst(getAttribute(utf8Decoder, element, CLASS_ATTR)),
                             ErrorHandler::getStaticClass(),
                             0);

    if (eh != 0)
    {
        eh->setAppender(appender);

        PropertySetter propSetter(eh);

        for (apr_xml_elem* currentElement = element->first_child;
                currentElement;
                currentElement = currentElement->next)
        {
            std::string tagName(currentElement->name);

            if (tagName == PARAM_TAG)
            {
                setParameter(p, utf8Decoder, currentElement, propSetter);
            }
            else if (tagName == APPENDER_REF_TAG)
            {
                eh->setBackupAppender(findAppenderByReference(p, utf8Decoder, currentElement, doc, appenders));
            }
            else if (tagName == LOGGER_REF)
            {
                LogString loggerName(getAttribute(utf8Decoder, currentElement, REF_ATTR));
                LoggerPtr logger = repository->getLogger(loggerName, loggerFactory);
                eh->setLogger(logger);
            }
            else if (tagName == ROOT_REF)
            {
                LoggerPtr root = repository->getRootLogger();
                eh->setLogger(root);
            }
        }

        propSetter.activate(p);
        ObjectPtrT<AppenderSkeleton> appSkeleton(appender);

        if (appSkeleton != 0)
        {
            appSkeleton->setErrorHandler(eh);
        }
    }
}

/**
 Used internally to parse a filter element.
*/
void DOMConfigurator::parseFilters(Pool& p,
                                   log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
                                   apr_xml_elem* element,
                                   std::vector<log4cxx::spi::FilterPtr>& filters)
{
    LogString clazz = subst(getAttribute(utf8Decoder, element, CLASS_ATTR));
    FilterPtr filter = OptionConverter::instantiateByClassName(clazz,
                       Filter::getStaticClass(), 0);

    if (filter != 0)
    {
        PropertySetter propSetter(filter);

        for (apr_xml_elem* currentElement = element->first_child;
                currentElement;
                currentElement = currentElement->next)
        {
            std::string tagName(currentElement->name);

            if (tagName == PARAM_TAG)
            {
                setParameter(p, utf8Decoder, currentElement, propSetter);
            }
        }

        propSetter.activate(p);
        filters.push_back(filter);
    }
}

/**
Used internally to parse an category or logger element.
*/
void DOMConfigurator::parseLogger(
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* loggerElement,
    apr_xml_doc* doc,
    AppenderMap& appenders)
{
    // Create a new Logger object from the <category> element.
    LogString loggerName = subst(getAttribute(utf8Decoder, loggerElement, NAME_ATTR));

    LogLog::debug(LOG4CXX_STR("Retreiving an instance of Logger."));
    LoggerPtr logger = repository->getLogger(loggerName, loggerFactory);

    // Setting up a logger needs to be an atomic operation, in order
    // to protect potential log operations while logger
    // configuration is in progress.
    LOCK_W sync(logger->getMutex());
    bool additivity = OptionConverter::toBoolean(
                          subst(getAttribute(utf8Decoder, loggerElement, ADDITIVITY_ATTR)),
                          true);

    LogLog::debug(LOG4CXX_STR("Setting [") + logger->getName() + LOG4CXX_STR("] additivity to [") +
                  (additivity ? LogString(LOG4CXX_STR("true")) : LogString(LOG4CXX_STR("false"))) + LOG4CXX_STR("]."));
    logger->setAdditivity(additivity);
    parseChildrenOfLoggerElement(p, utf8Decoder, loggerElement, logger, false, doc, appenders);
}

/**
 Used internally to parse the logger factory element.
*/
void DOMConfigurator::parseLoggerFactory(
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* factoryElement)
{
    LogString className(subst(getAttribute(utf8Decoder, factoryElement, CLASS_ATTR)));

    if (className.empty())
    {
        LogLog::error(LOG4CXX_STR("Logger Factory tag class attribute not found."));
        LogLog::debug(LOG4CXX_STR("No Logger Factory configured."));
    }
    else
    {
        LogLog::debug(LOG4CXX_STR("Desired logger factory: [") + className + LOG4CXX_STR("]"));
        loggerFactory = OptionConverter::instantiateByClassName(
                            className,
                            LoggerFactory::getStaticClass(),
                            0);
        PropertySetter propSetter(loggerFactory);

        for (apr_xml_elem* currentElement = factoryElement->first_child;
                currentElement;
                currentElement = currentElement->next)
        {
            std::string tagName(currentElement->name);

            if (tagName == PARAM_TAG)
            {
                setParameter(p, utf8Decoder, currentElement, propSetter);
            }
        }
    }
}

/**
 Used internally to parse the root logger element.
*/
void DOMConfigurator::parseRoot(
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* rootElement,
    apr_xml_doc* doc,
    AppenderMap& appenders)
{
    LoggerPtr root = repository->getRootLogger();
    // logger configuration needs to be atomic
    LOCK_W sync(root->getMutex());
    parseChildrenOfLoggerElement(p, utf8Decoder, rootElement, root, true, doc, appenders);
}

/**
 Used internally to parse the children of a logger element.
*/
void DOMConfigurator::parseChildrenOfLoggerElement(
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* loggerElement, LoggerPtr logger, bool isRoot,
    apr_xml_doc* doc,
    AppenderMap& appenders)
{

    PropertySetter propSetter(logger);

    // Remove all existing appenders from logger. They will be
    // reconstructed if need be.
    logger->removeAllAppenders();


    for (apr_xml_elem* currentElement = loggerElement->first_child;
            currentElement;
            currentElement = currentElement->next)
    {
        std::string tagName(currentElement->name);

        if (tagName == APPENDER_REF_TAG)
        {
            AppenderPtr appender = findAppenderByReference(p, utf8Decoder, currentElement, doc, appenders);
            LogString refName =  subst(getAttribute(utf8Decoder, currentElement, REF_ATTR));

            if (appender != 0)
            {
                LogLog::debug(LOG4CXX_STR("Adding appender named [") + refName +
                              LOG4CXX_STR("] to logger [") + logger->getName() + LOG4CXX_STR("]."));
            }
            else
            {
                LogLog::debug(LOG4CXX_STR("Appender named [") + refName +
                              LOG4CXX_STR("] not found."));
            }

            logger->addAppender(appender);

        }
        else if (tagName == LEVEL_TAG)
        {
            parseLevel(p, utf8Decoder, currentElement, logger, isRoot);
        }
        else if (tagName == PRIORITY_TAG)
        {
            parseLevel(p, utf8Decoder, currentElement, logger, isRoot);
        }
        else if (tagName == PARAM_TAG)
        {
            setParameter(p, utf8Decoder, currentElement, propSetter);
        }
    }

    propSetter.activate(p);
}

/**
 Used internally to parse a layout element.
*/
LayoutPtr DOMConfigurator::parseLayout (
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* layout_element)
{
    LogString className(subst(getAttribute(utf8Decoder, layout_element, CLASS_ATTR)));
    LogLog::debug(LOG4CXX_STR("Parsing layout of class: \"") + className + LOG4CXX_STR("\""));

    try
    {
        ObjectPtr instance = Loader::loadClass(className).newInstance();
        LayoutPtr layout = instance;
        PropertySetter propSetter(layout);

        for (apr_xml_elem* currentElement = layout_element->first_child;
                currentElement;
                currentElement = currentElement->next)
        {
            std::string tagName(currentElement->name);

            if (tagName == PARAM_TAG)
            {
                setParameter(p, utf8Decoder, currentElement, propSetter);
            }
        }

        propSetter.activate(p);
        return layout;
    }
    catch (Exception& oops)
    {
        LogLog::error(LOG4CXX_STR("Could not create the Layout. Reported error follows."),
                      oops);
        return 0;
    }
}

/**
 Used internally to parse a triggering policy
*/
ObjectPtr DOMConfigurator::parseTriggeringPolicy (
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* layout_element)
{
    LogString className = subst(getAttribute(utf8Decoder, layout_element, CLASS_ATTR));
    LogLog::debug(LOG4CXX_STR("Parsing triggering policy of class: \"") + className + LOG4CXX_STR("\""));

    try
    {
        ObjectPtr instance = Loader::loadClass(className).newInstance();
        PropertySetter propSetter(instance);

        for (apr_xml_elem* currentElement = layout_element->first_child;
                currentElement;
                currentElement = currentElement->next)
        {
            std::string tagName(currentElement->name);

            if (tagName == PARAM_TAG)
            {
                setParameter(p, utf8Decoder, currentElement, propSetter);
            }
            else if (tagName == FILTER_TAG)
            {
                std::vector<log4cxx::spi::FilterPtr> filters;
                parseFilters(p, utf8Decoder, currentElement, filters);
                FilterBasedTriggeringPolicyPtr fbtp(instance);

                if (fbtp != NULL)
                {
                    for (std::vector<log4cxx::spi::FilterPtr>::iterator iter = filters.begin();
                            iter != filters.end();
                            iter++)
                    {
                        fbtp->addFilter(*iter);
                    }
                }
            }
        }

        propSetter.activate(p);
        return instance;
    }
    catch (Exception& oops)
    {
        LogLog::error(LOG4CXX_STR("Could not create the TriggeringPolicy. Reported error follows."),
                      oops);
        return 0;
    }
}

/**
 Used internally to parse a triggering policy
*/
RollingPolicyPtr DOMConfigurator::parseRollingPolicy (
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* layout_element)
{
    LogString className = subst(getAttribute(utf8Decoder, layout_element, CLASS_ATTR));
    LogLog::debug(LOG4CXX_STR("Parsing rolling policy of class: \"") + className + LOG4CXX_STR("\""));

    try
    {
        ObjectPtr instance = Loader::loadClass(className).newInstance();
        RollingPolicyPtr layout = instance;
        PropertySetter propSetter(layout);

        for (apr_xml_elem* currentElement = layout_element->first_child;
                currentElement;
                currentElement = currentElement->next)
        {
            std::string tagName(currentElement->name);

            if (tagName == PARAM_TAG)
            {
                setParameter(p, utf8Decoder, currentElement, propSetter);
            }
        }

        propSetter.activate(p);
        return layout;
    }
    catch (Exception& oops)
    {
        LogLog::error(LOG4CXX_STR("Could not create the RollingPolicy. Reported error follows."),
                      oops);
        return 0;
    }
}


/**
 Used internally to parse a level  element.
*/
void DOMConfigurator::parseLevel(
    log4cxx::helpers::Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* element, LoggerPtr logger, bool isRoot)
{
    LogString loggerName = logger->getName();

    if (isRoot)
    {
        loggerName = LOG4CXX_STR("root");
    }

    LogString levelStr(subst(getAttribute(utf8Decoder, element, VALUE_ATTR)));
    LogLog::debug(LOG4CXX_STR("Level value for ") + loggerName + LOG4CXX_STR(" is [") + levelStr + LOG4CXX_STR("]."));

    if (StringHelper::equalsIgnoreCase(levelStr, LOG4CXX_STR("INHERITED"), LOG4CXX_STR("inherited"))
            || StringHelper::equalsIgnoreCase(levelStr, LOG4CXX_STR("NULL"), LOG4CXX_STR("null")))
    {
        if (isRoot)
        {
            LogLog::error(LOG4CXX_STR("Root level cannot be inherited. Ignoring directive."));
        }
        else
        {
            logger->setLevel(0);
        }
    }
    else
    {
        LogString className(subst(getAttribute(utf8Decoder, element, CLASS_ATTR)));

        if (className.empty())
        {
            logger->setLevel(OptionConverter::toLevel(levelStr, Level::getDebug()));
        }
        else
        {
            LogLog::debug(LOG4CXX_STR("Desired Level sub-class: [") + className + LOG4CXX_STR("]"));

            try
            {
                Level::LevelClass& levelClass =
                    (Level::LevelClass&)Loader::loadClass(className);
                LevelPtr level = levelClass.toLevel(levelStr);
                logger->setLevel(level);
            }
            catch (Exception& oops)
            {
                LogLog::error(
                    LOG4CXX_STR("Could not create level [") + levelStr +
                    LOG4CXX_STR("]. Reported error follows."),
                    oops);

                return;
            }
            catch (...)
            {
                LogLog::error(
                    LOG4CXX_STR("Could not create level [") + levelStr);

                return;
            }
        }
    }

    LogLog::debug(loggerName + LOG4CXX_STR(" level set to ") +
                  logger->getEffectiveLevel()->toString());
}

void DOMConfigurator::setParameter(log4cxx::helpers::Pool& p,
                                   log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
                                   apr_xml_elem* elem,
                                   PropertySetter& propSetter)
{
    LogString name(subst(getAttribute(utf8Decoder, elem, NAME_ATTR)));
    LogString value(subst(getAttribute(utf8Decoder, elem, VALUE_ATTR)));
    value = subst(value);
    propSetter.setProperty(name, value, p);
}

void DOMConfigurator::doConfigure(const File& filename, spi::LoggerRepositoryPtr& repository1)
{
    repository1->setConfigured(true);
    this->repository = repository1;
    LogString msg(LOG4CXX_STR("DOMConfigurator configuring file "));
    msg.append(filename.getPath());
    msg.append(LOG4CXX_STR("..."));
    LogLog::debug(msg);

    loggerFactory = new DefaultLoggerFactory();

    Pool p;
    apr_file_t* fd;

    log4cxx_status_t rv = filename.open(&fd, APR_READ, APR_OS_DEFAULT, p);

    if (rv != APR_SUCCESS)
    {
        LogString msg2(LOG4CXX_STR("Could not open file ["));
        msg2.append(filename.getPath());
        msg2.append(LOG4CXX_STR("]."));
        LogLog::error(msg2);
    }
    else
    {
        apr_xml_parser* parser = NULL;
        apr_xml_doc* doc = NULL;
        rv = apr_xml_parse_file(p.getAPRPool(), &parser, &doc, fd, 2000);

        if (rv != APR_SUCCESS)
        {
            char errbuf[2000];
            char errbufXML[2000];
            LogString msg2(LOG4CXX_STR("Error parsing file ["));
            msg2.append(filename.getPath());
            msg2.append(LOG4CXX_STR("], "));
            apr_strerror(rv, errbuf, sizeof(errbuf));
            LOG4CXX_DECODE_CHAR(lerrbuf, std::string(errbuf));
            msg2.append(lerrbuf);

            if (parser)
            {
                apr_xml_parser_geterror(parser, errbufXML, sizeof(errbufXML));
                LOG4CXX_DECODE_CHAR(lerrbufXML, std::string(errbufXML));
                msg2.append(lerrbufXML);
            }

            LogLog::error(msg2);
        }
        else
        {
            AppenderMap appenders;
            CharsetDecoderPtr utf8Decoder(CharsetDecoder::getUTF8Decoder());
            parse(p, utf8Decoder, doc->root, doc, appenders);
        }
    }
}

void DOMConfigurator::configure(const std::string& filename)
{
    File file(filename);
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
}

#if LOG4CXX_WCHAR_T_API
void DOMConfigurator::configure(const std::wstring& filename)
{
    File file(filename);
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
}
#endif

#if LOG4CXX_UNICHAR_API
void DOMConfigurator::configure(const std::basic_string<UniChar>& filename)
{
    File file(filename);
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
}
#endif

#if LOG4CXX_CFSTRING_API
void DOMConfigurator::configure(const CFStringRef& filename)
{
    File file(filename);
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
}
#endif


void DOMConfigurator::configureAndWatch(const std::string& filename)
{
    configureAndWatch(filename, FileWatchdog::DEFAULT_DELAY);
}

#if LOG4CXX_WCHAR_T_API
void DOMConfigurator::configureAndWatch(const std::wstring& filename)
{
    configureAndWatch(filename, FileWatchdog::DEFAULT_DELAY);
}
#endif

#if LOG4CXX_UNICHAR_API
void DOMConfigurator::configureAndWatch(const std::basic_string<UniChar>& filename)
{
    configureAndWatch(filename, FileWatchdog::DEFAULT_DELAY);
}
#endif

#if LOG4CXX_CFSTRING_API
void DOMConfigurator::configureAndWatch(const CFStringRef& filename)
{
    configureAndWatch(filename, FileWatchdog::DEFAULT_DELAY);
}
#endif

void DOMConfigurator::configureAndWatch(const std::string& filename, long delay)
{
    File file(filename);
#if APR_HAS_THREADS

    if ( xdog )
    {
        APRInitializer::unregisterCleanup(xdog);
        delete xdog;
    }

    xdog = new XMLWatchdog(file);
    APRInitializer::registerCleanup(xdog);
    xdog->setDelay(delay);
    xdog->start();
#else
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
#endif
}

#if LOG4CXX_WCHAR_T_API
void DOMConfigurator::configureAndWatch(const std::wstring& filename, long delay)
{
    File file(filename);
#if APR_HAS_THREADS

    if ( xdog )
    {
        APRInitializer::unregisterCleanup(xdog);
        delete xdog;
    }

    xdog = new XMLWatchdog(file);
    APRInitializer::registerCleanup(xdog);
    xdog->setDelay(delay);
    xdog->start();
#else
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
#endif
}
#endif

#if LOG4CXX_UNICHAR_API
void DOMConfigurator::configureAndWatch(const std::basic_string<UniChar>& filename, long delay)
{
    File file(filename);
#if APR_HAS_THREADS

    if ( xdog )
    {
        APRInitializer::unregisterCleanup(xdog);
        delete xdog;
    }

    xdog = new XMLWatchdog(file);
    APRInitializer::registerCleanup(xdog);
    xdog->setDelay(delay);
    xdog->start();
#else
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
#endif
}
#endif

#if LOG4CXX_CFSTRING_API
void DOMConfigurator::configureAndWatch(const CFStringRef& filename, long delay)
{
    File file(filename);
#if APR_HAS_THREADS

    if ( xdog )
    {
        APRInitializer::unregisterCleanup(xdog);
        delete xdog;
    }

    xdog = new XMLWatchdog(file);
    APRInitializer::registerCleanup(xdog);
    xdog->setDelay(delay);
    xdog->start();
#else
    DOMConfigurator().doConfigure(file, LogManager::getLoggerRepository());
#endif
}
#endif

void DOMConfigurator::parse(
    Pool& p,
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* element,
    apr_xml_doc* doc,
    AppenderMap& appenders)
{
    std::string rootElementName(element->name);

    if (rootElementName != CONFIGURATION_TAG)
    {
        if (rootElementName == OLD_CONFIGURATION_TAG)
        {
            //LogLog::warn(LOG4CXX_STR("The <")+String(OLD_CONFIGURATION_TAG)+
            // LOG4CXX_STR("> element has been deprecated."));
            //LogLog::warn(LOG4CXX_STR("Use the <")+String(CONFIGURATION_TAG)+
            // LOG4CXX_STR("> element instead."));
        }
        else
        {
            LogLog::error(LOG4CXX_STR("DOM element is - not a <configuration> element."));
            return;
        }
    }

    LogString debugAttrib = subst(getAttribute(utf8Decoder, element, INTERNAL_DEBUG_ATTR));

    static const LogString NuLL(LOG4CXX_STR("NULL"));
    LogLog::debug(LOG4CXX_STR("debug attribute= \"") + debugAttrib + LOG4CXX_STR("\"."));

    // if the log4j.dtd is not specified in the XML file, then the
    // "debug" attribute is returned as the empty string.
    if (!debugAttrib.empty() && debugAttrib != NuLL)
    {
        LogLog::setInternalDebugging(OptionConverter::toBoolean(debugAttrib, true));
    }
    else
    {
        LogLog::debug(LOG4CXX_STR("Ignoring internalDebug attribute."));
    }


    LogString confDebug = subst(getAttribute(utf8Decoder, element, CONFIG_DEBUG_ATTR));

    if (!confDebug.empty() && confDebug != NuLL)
    {
        LogLog::warn(LOG4CXX_STR("The \"configDebug\" attribute is deprecated."));
        LogLog::warn(LOG4CXX_STR("Use the \"internalDebug\" attribute instead."));
        LogLog::setInternalDebugging(OptionConverter::toBoolean(confDebug, true));
    }

    LogString thresholdStr = subst(getAttribute(utf8Decoder, element, THRESHOLD_ATTR));
    LogLog::debug(LOG4CXX_STR("Threshold =\"") + thresholdStr + LOG4CXX_STR("\"."));

    if (!thresholdStr.empty() && thresholdStr != NuLL)
    {
        repository->setThreshold(thresholdStr);
    }

    LogString strstrValue = subst(getAttribute(utf8Decoder, element, STRINGSTREAM_ATTR));
    LogLog::debug(LOG4CXX_STR("Stringstream =\"") + strstrValue + LOG4CXX_STR("\"."));

    if (!strstrValue.empty() && strstrValue != NuLL)
    {
        MessageBufferUseStaticStream();
    }

    apr_xml_elem* currentElement;

    for (currentElement = element->first_child;
            currentElement;
            currentElement = currentElement->next)
    {
        std::string tagName(currentElement->name);

        if (tagName == CATEGORY_FACTORY_TAG)
        {
            parseLoggerFactory(p, utf8Decoder, currentElement);
        }
    }

    for (currentElement = element->first_child;
            currentElement;
            currentElement = currentElement->next)
    {
        std::string tagName(currentElement->name);

        if (tagName == CATEGORY || tagName == LOGGER)
        {
            parseLogger(p, utf8Decoder, currentElement, doc, appenders);
        }
        else if (tagName == ROOT_TAG)
        {
            parseRoot(p, utf8Decoder, currentElement, doc, appenders);
        }
    }
}

LogString DOMConfigurator::subst(const LogString& value)
{
    try
    {
        return OptionConverter::substVars(value, props);
    }
    catch (IllegalArgumentException& e)
    {
        LogLog::warn(LOG4CXX_STR("Could not perform variable substitution."), e);
        return value;
    }
}


LogString DOMConfigurator::getAttribute(
    log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
    apr_xml_elem* element,
    const std::string& attrName)
{
    LogString attrValue;

    for (apr_xml_attr* attr = element->attr;
            attr;
            attr = attr->next)
    {
        if (attrName == attr->name)
        {
            ByteBuffer buf((char*) attr->value, strlen(attr->value));
            utf8Decoder->decode(buf, attrValue);
        }
    }

    return attrValue;
}