/*
 * 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/properties.h>
#include <log4cxx/helpers/inputstreamreader.h>
#include <log4cxx/helpers/exception.h>
#include <log4cxx/helpers/pool.h>

using namespace log4cxx;
using namespace log4cxx::helpers;

class PropertyParser
{
    public:
        void parse(LogString& in, Properties& properties)
        {
            LogString key, element;
            LexemType lexemType = BEGIN;
            logchar c;
            bool finished = false;

            if (!get(in, c))
            {
                return;
            }

            while (!finished)
            {
                switch (lexemType)
                {
                    case BEGIN:
                        switch (c)
                        {
                            case 0x20: // ' '
                            case 0x09: // '\t'
                            case 0x0A: // '\n'
                            case 0x0D: // '\r'
                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            case 0x23: // '#'
                            case 0x21: // '!'
                                lexemType = COMMENT;

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            default:
                                lexemType = KEY;
                                break;
                        }

                        break;

                    case KEY:
                        switch (c)
                        {
                            case 0x5C: // '\\'
                                lexemType = KEY_ESCAPE;

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            case 0x09: // '\t'
                            case 0x20: // ' '
                            case 0x3A: // ':'
                            case 0x3D: // '='
                                lexemType = DELIMITER;

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            case 0x0A:
                            case 0x0D:
                                // key associated with an empty string element
                                properties.setProperty(key, LogString());
                                key.erase(key.begin(), key.end());
                                lexemType = BEGIN;

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            default:
                                key.append(1, c);

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;
                        }

                        break;

                    case KEY_ESCAPE:
                        switch (c)
                        {
                            case 0x74: // 't'
                                key.append(1, 0x09);
                                lexemType = KEY;
                                break;

                            case 0x6E: // 'n'
                                key.append(1, 0x0A);
                                lexemType = KEY;
                                break;

                            case 0x72: // 'r'
                                key.append(1, 0x0D);
                                lexemType = KEY;
                                break;

                            case 0x0A: // '\n'
                                lexemType = KEY_CONTINUE;
                                break;

                            case 0x0D: // '\r'
                                lexemType = KEY_CONTINUE2;
                                break;

                            default:
                                key.append(1, c);
                                lexemType = KEY;
                        }

                        if (!get(in, c))
                        {
                            finished = true;
                        }

                        break;

                    case KEY_CONTINUE:
                        switch (c)
                        {
                            case 0x20:  // ' '
                            case 0x09: //  '\t'
                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            default:
                                lexemType = KEY;
                                break;
                        }

                        break;

                    case KEY_CONTINUE2:
                        switch (c)
                        {
                            case 0x0A: // '\n'
                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                lexemType = KEY_CONTINUE;
                                break;

                            default:
                                lexemType = KEY_CONTINUE;
                                break;
                        }

                        break;

                    case DELIMITER:
                        switch (c)
                        {
                            case 0x09: // '\t'
                            case 0x20: // ' '
                            case 0x3A: // ':'
                            case 0x3D: // '='
                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            default:
                                lexemType = ELEMENT;
                                break;
                        }

                        break;

                    case ELEMENT:
                        switch (c)
                        {
                            case 0x5C: // '\\'
                                lexemType = ELEMENT_ESCAPE;

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            case 0x0A: // '\n'
                            case 0x0D: // '\r'
                                // key associated with an empty string element
                                properties.setProperty(key, element);
                                key.erase(key.begin(), key.end());
                                element.erase(element.begin(), element.end());
                                lexemType = BEGIN;

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            default:
                                element.append(1, c);

                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;
                        }

                        break;

                    case ELEMENT_ESCAPE:
                        switch (c)
                        {
                            case 0x74: // 't'
                                element.append(1, 0x09);
                                lexemType = ELEMENT;
                                break;

                            case 0x6E: // 'n'
                                element.append(1, 0x0A);
                                lexemType = ELEMENT;
                                break;

                            case 0x72: // 'r'
                                element.append(1, 0x0D);
                                lexemType = ELEMENT;
                                break;

                            case 0x0A: // '\n'
                                lexemType = ELEMENT_CONTINUE;
                                break;

                            case 0x0D: // '\r'
                                lexemType = ELEMENT_CONTINUE2;
                                break;

                            default:
                                element.append(1, c);
                                lexemType = ELEMENT;
                                break;
                        }

                        if (!get(in, c))
                        {
                            finished = true;
                        }

                        break;

                    case ELEMENT_CONTINUE:
                        switch (c)
                        {
                            case 0x20: // ' '
                            case 0x09: // '\t'
                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                break;

                            default:
                                lexemType = ELEMENT;
                                break;
                        }

                        break;

                    case ELEMENT_CONTINUE2:
                        switch (c)
                        {
                            case 0x0A: // '\n'
                                if (!get(in, c))
                                {
                                    finished = true;
                                }

                                lexemType = ELEMENT_CONTINUE;
                                break;

                            default:
                                lexemType = ELEMENT_CONTINUE;
                                break;
                        }

                        break;

                    case COMMENT:
                        if (c == 0x0A || c == 0x0D)
                        {
                            lexemType = BEGIN;
                        }

                        if (!get(in, c))
                        {
                            finished = true;
                        }

                        break;
                }
            }

            if (!key.empty())
            {
                properties.setProperty(key, element);
            }
        }

    protected:
        static bool get(LogString& in, logchar& c)
        {
            if (in.empty())
            {
                c = 0;
                return false;
            }

            c = in[0];
            in.erase(in.begin());
            return true;
        }

        typedef enum
        {
            BEGIN,
            KEY,
            KEY_ESCAPE,
            KEY_CONTINUE,
            KEY_CONTINUE2,
            DELIMITER,
            ELEMENT,
            ELEMENT_ESCAPE,
            ELEMENT_CONTINUE,
            ELEMENT_CONTINUE2,
            COMMENT
        }
        LexemType;
};

Properties::Properties() : properties(new PropertyMap())
{
}

Properties::~Properties()
{
    delete properties;
}

LogString Properties::setProperty(const LogString& key, const LogString& value)
{
    return put(key, value);
}

LogString Properties::put(const LogString& key, const LogString& value)
{
    LogString oldValue((*properties)[key]);
    (*properties)[key] = value;
    return oldValue;
}

LogString Properties::getProperty(const LogString& key) const
{
    return get(key);
}

LogString Properties::get(const LogString& key) const
{
    PropertyMap::const_iterator it = properties->find(key);
    return (it != properties->end()) ? it->second : LogString();
}

void Properties::load(InputStreamPtr inStream)
{
    Pool pool;
    InputStreamReaderPtr lineReader(
        new InputStreamReader(inStream, CharsetDecoder::getISOLatinDecoder()));
    LogString contents = lineReader->read(pool);
    properties->clear();
    PropertyParser parser;
    parser.parse(contents, *this);
}

std::vector<LogString> Properties::propertyNames() const
{
    std::vector<LogString> names;
    names.reserve(properties->size());

    PropertyMap::const_iterator it;

    for (it = properties->begin(); it != properties->end(); it++)
    {
        const LogString& key = it->first;
        names.push_back(key);
    }

    return names;
}