/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2015, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "PatternEvaluator.h"

#include <ctype.h>
#include <stdlib.h>
#include <string.h>



// #pragma mark - PatternEvaluator


/*static*/ BString
PatternEvaluator::Evaluate(const char* pattern, PlaceholderMapper& mapper)
{
        BString result;
        BString before;
        bool isBefore = false;
        bool isAfter = false;
        bool hadResult = false;
        bool began = false;

        while (*pattern != '\0') {
                // find next placeholder
                const char* placeholder = strchr(pattern, '%');
                size_t length = 0;
                if (placeholder != NULL)
                        length = placeholder - pattern;
                else
                        length = INT_MAX;

                // append skipped chars
                if (placeholder != pattern) {
                        if (isBefore) {
                                before.SetTo(pattern, length);
                                isBefore = false;
                        } else if (!isAfter || hadResult) {
                                result.Append(pattern, length);
                                isBefore = false;
                                before.SetTo(NULL);
                                isAfter = false;
                        }
                }
                if (placeholder == NULL)
                        return result;

                pattern = placeholder + 1;

                // check for special placeholders
                switch (pattern[0]) {
                        case '%':
                                // An escaped '%'
                                result += '%';
                                pattern++;
                                continue;
                        case '<':
                                // An optional before string
                                isBefore = began = true;
                                hadResult = false;
                                pattern++;
                                continue;
                        case '>':
                                // An optional after string
                                isAfter = true;
                                began = false;
                                before.SetTo(NULL);
                                pattern++;
                                continue;
                        case '-':
                                // End of any other section; ignore
                                pattern++;
                                isBefore = false;
                                isAfter = false;
                                continue;
                }
                // Count non alpha numeric characters to the before section
                while (pattern[0] != '\0' && !isalnum(pattern[0])) {
                        before.Append(pattern[0], 1);
                        pattern++;
                }

                // parse a number, if there is one
                int64 number = 0;
                bool hasNumber = false;
                if (isdigit(*pattern)) {
                        char* numberEnd;
                        number = strtoll(pattern, &numberEnd, 10);
                        pattern = numberEnd;
                        hasNumber = true;
                }

                BString mappedValue;
                if (*pattern != '\0' && mapper.MapPlaceholder(*pattern,
                                number, hasNumber, mappedValue)) {
                        // mapped successfully -- append the replacement string
                        if (began && !mappedValue.IsEmpty())
                                hadResult = true;
                        if (!before.IsEmpty() && !mappedValue.IsEmpty()) {
                                result += before;
                                before.SetTo(NULL);
                        }

                        result += mappedValue;
                        pattern++;
                } else {
                        // something went wrong -- just append the literal part of the
                        // pattern
                        result.Append(placeholder, length);
                }
        }

        return result;
}


// #pragma mark - PlaceholderMapper


PatternEvaluator::PlaceholderMapper::~PlaceholderMapper()
{
}