/*
 * 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/helpers/resourcebundle.h>
#include <log4cxx/helpers/propertyresourcebundle.h>
#include <log4cxx/helpers/loader.h>
#include <log4cxx/helpers/pool.h>
#include <log4cxx/helpers/transcoder.h>
#include <log4cxx/helpers/locale.h>

using namespace log4cxx;
using namespace log4cxx::helpers;

IMPLEMENT_LOG4CXX_OBJECT(ResourceBundle)

ResourceBundlePtr ResourceBundle::getBundle(const LogString& baseName,
        const Locale& locale)
{
    LogString bundleName;
    PropertyResourceBundlePtr resourceBundle, previous;

    std::vector<LogString> bundlesNames;

    if (!locale.getVariant().empty())
    {
        bundlesNames.push_back(baseName + LOG4CXX_STR("_") +
                               locale.getLanguage() + LOG4CXX_STR("_") +
                               locale.getCountry() + LOG4CXX_STR("_") +
                               locale.getVariant());
    }

    if (!locale.getCountry().empty())
    {
        bundlesNames.push_back(baseName + LOG4CXX_STR("_") +
                               locale.getLanguage() + LOG4CXX_STR("_") +
                               locale.getCountry());
    }

    if (!locale.getLanguage().empty())
    {
        bundlesNames.push_back(baseName + LOG4CXX_STR("_") +
                               locale.getLanguage());
    }

    bundlesNames.push_back(baseName);

    for (std::vector<LogString>::iterator it = bundlesNames.begin();
            it != bundlesNames.end(); it++)
    {

        bundleName = *it;

        PropertyResourceBundlePtr current;

        // Try loading a class which implements ResourceBundle
        try
        {
            const Class& classObj = Loader::loadClass(bundleName);
            current = classObj.newInstance();
        }
        catch (ClassNotFoundException&)
        {
            current = 0;
        }

        // No class found, then try to create a PropertyResourceBundle from a file
        if (current == 0)
        {
            InputStreamPtr bundleStream =
                Loader::getResourceAsStream(
                    bundleName + LOG4CXX_STR(".properties"));

            if (bundleStream == 0)
            {
                continue;
            }

            try
            {
                current = new PropertyResourceBundle(bundleStream);
            }
            catch (Exception&)
            {
                throw;
            }
        }

        // Add the new resource bundle to the hierarchy
        if (resourceBundle == 0)
        {
            resourceBundle = current;
            previous = current;
        }
        else
        {
            previous->setParent(current);
            previous = current;
        }
    }

    // no resource bundle found at all, then throw exception
    if (resourceBundle == 0)
    {
        throw MissingResourceException(
            ((LogString) LOG4CXX_STR("Missing resource bundle ")) + baseName);
    }

    return resourceBundle;
}