/*
******************************************************************************
* Copyright (C) 2014, International Business Machines
* Corporation and others.  All Rights Reserved.
******************************************************************************
* simplepatternformatter.cpp
*/
#include "simplepatternformatter.h"
#include "cstring.h"
#include "uassert.h"

#define LENGTHOF(array) (int32_t)(sizeof(array) / sizeof((array)[0]))

U_NAMESPACE_BEGIN

typedef enum SimplePatternFormatterCompileState {
    INIT,
    APOSTROPHE,
    PLACEHOLDER
} SimplePatternFormatterCompileState;

class SimplePatternFormatterIdBuilder {
public:
    SimplePatternFormatterIdBuilder() : id(0), idLen(0) { }
    ~SimplePatternFormatterIdBuilder() { }
    void reset() { id = 0; idLen = 0; }
    int32_t getId() const { return id; }
    void appendTo(UChar *buffer, int32_t *len) const;
    UBool isValid() const { return (idLen > 0); }
    void add(UChar ch);
private:
    int32_t id;
    int32_t idLen;
    SimplePatternFormatterIdBuilder(
            const SimplePatternFormatterIdBuilder &other);
    SimplePatternFormatterIdBuilder &operator=(
            const SimplePatternFormatterIdBuilder &other);
};

void SimplePatternFormatterIdBuilder::appendTo(
        UChar *buffer, int32_t *len) const {
    int32_t origLen = *len;
    int32_t kId = id;
    for (int32_t i = origLen + idLen - 1; i >= origLen; i--) {
        int32_t digit = kId % 10;
        buffer[i] = digit + 0x30;
        kId /= 10;
    }
    *len = origLen + idLen;
}

void SimplePatternFormatterIdBuilder::add(UChar ch) {
    id = id * 10 + (ch - 0x30);
    idLen++;
}

SimplePatternFormatter::SimplePatternFormatter() :
        noPlaceholders(),
        placeholdersByOffset(placeholderBuffer),
        placeholderSize(0),
        placeholderCapacity(EXPECTED_PLACEHOLDER_COUNT),
        placeholderCount(0) {
}

SimplePatternFormatter::SimplePatternFormatter(const UnicodeString &pattern) :
        noPlaceholders(),
        placeholdersByOffset(placeholderBuffer),
        placeholderSize(0),
        placeholderCapacity(EXPECTED_PLACEHOLDER_COUNT),
        placeholderCount(0) {
    UErrorCode status = U_ZERO_ERROR;
    compile(pattern, status);
}

SimplePatternFormatter::SimplePatternFormatter(
        const SimplePatternFormatter &other) :
        noPlaceholders(other.noPlaceholders),
        placeholdersByOffset(placeholderBuffer),
        placeholderSize(0),
        placeholderCapacity(EXPECTED_PLACEHOLDER_COUNT),
        placeholderCount(other.placeholderCount) {
    placeholderSize = ensureCapacity(other.placeholderSize);
    uprv_memcpy(
            placeholdersByOffset,
            other.placeholdersByOffset,
            placeholderSize * 2 * sizeof(int32_t));
}

SimplePatternFormatter &SimplePatternFormatter::operator=(
        const SimplePatternFormatter& other) {
    if (this == &other) {
        return *this;
    }
    noPlaceholders = other.noPlaceholders;
    placeholderCount = other.placeholderCount;
    placeholderSize = ensureCapacity(other.placeholderSize);
    uprv_memcpy(
            placeholdersByOffset,
            other.placeholdersByOffset,
            placeholderSize * 2 * sizeof(int32_t));
    return *this;
}

SimplePatternFormatter::~SimplePatternFormatter() {
    if (placeholdersByOffset != placeholderBuffer) {
        uprv_free(placeholdersByOffset);
    }
}

UBool SimplePatternFormatter::compile(
        const UnicodeString &pattern, UErrorCode &status) {
    if (U_FAILURE(status)) {
        return FALSE;
    }
    const UChar *patternBuffer = pattern.getBuffer();
    int32_t patternLength = pattern.length();
    UChar *buffer = noPlaceholders.getBuffer(patternLength);
    int32_t len = 0;
    placeholderSize = 0;
    placeholderCount = 0;
    SimplePatternFormatterCompileState state = INIT;
    SimplePatternFormatterIdBuilder idBuilder;
    for (int32_t i = 0; i < patternLength; ++i) {
        UChar ch = patternBuffer[i];
        switch (state) {
        case INIT:
            if (ch == 0x27) {
                state = APOSTROPHE;
            } else if (ch == 0x7B) {
                state = PLACEHOLDER;
                idBuilder.reset();
            } else {
               buffer[len++] = ch;
            }
            break;
        case APOSTROPHE:
            if (ch == 0x27) {
                buffer[len++] = 0x27;
            } else if (ch == 0x7B) {
                buffer[len++] = 0x7B;
            } else {
                buffer[len++] = 0x27;
                buffer[len++] = ch;
            }
            state = INIT;
            break;
        case PLACEHOLDER:
            if (ch >= 0x30 && ch <= 0x39) {
                idBuilder.add(ch);
            } else if (ch == 0x7D && idBuilder.isValid()) {
                if (!addPlaceholder(idBuilder.getId(), len)) {
                    status = U_MEMORY_ALLOCATION_ERROR;
                    return FALSE;
                }
                state = INIT;
            } else {
                buffer[len++] = 0x7B;
                idBuilder.appendTo(buffer, &len);
                buffer[len++] = ch;
                state = INIT;
            }
            break;
        default:
            U_ASSERT(FALSE);
            break;
        }
    }
    switch (state) {
    case INIT:
        break;
    case APOSTROPHE:
        buffer[len++] = 0x27;
        break;
    case PLACEHOLDER:
        buffer[len++] = 0X7B;
        idBuilder.appendTo(buffer, &len);
        break;
    default:
        U_ASSERT(false);
        break;
    }
    noPlaceholders.releaseBuffer(len);
    return TRUE;
}

UnicodeString& SimplePatternFormatter::format(
        const UnicodeString &arg0,
        UnicodeString &appendTo,
        UErrorCode &status) const {
    const UnicodeString *params[] = {&arg0};
    return format(
            params,
            LENGTHOF(params),
            appendTo,
            NULL,
            0,
            status);
}

UnicodeString& SimplePatternFormatter::format(
        const UnicodeString &arg0,
        const UnicodeString &arg1,
        UnicodeString &appendTo,
        UErrorCode &status) const {
    const UnicodeString *params[] = {&arg0, &arg1};
    return format(
            params,
            LENGTHOF(params),
            appendTo,
            NULL,
            0,
            status);
}

UnicodeString& SimplePatternFormatter::format(
        const UnicodeString &arg0,
        const UnicodeString &arg1,
        const UnicodeString &arg2,
        UnicodeString &appendTo,
        UErrorCode &status) const {
    const UnicodeString *params[] = {&arg0, &arg1, &arg2};
    return format(
            params,
            LENGTHOF(params),
            appendTo,
            NULL,
            0,
            status);
}

static void updatePlaceholderOffset(
        int32_t placeholderId,
        int32_t placeholderOffset,
        int32_t *offsetArray,
        int32_t offsetArrayLength) {
    if (placeholderId < offsetArrayLength) {
        offsetArray[placeholderId] = placeholderOffset;
    }
}

static void appendRange(
        const UnicodeString &src,
        int32_t start,
        int32_t end,
        UnicodeString &dest) {
    dest.append(src, start, end - start);
}

UnicodeString& SimplePatternFormatter::format(
        const UnicodeString * const *placeholderValues,
        int32_t placeholderValueCount,
        UnicodeString &appendTo,
        int32_t *offsetArray,
        int32_t offsetArrayLength,
        UErrorCode &status) const {
    if (U_FAILURE(status)) {
        return appendTo;
    }
    if (placeholderValueCount < placeholderCount) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return appendTo;
    }
    for (int32_t i = 0; i < offsetArrayLength; ++i) {
        offsetArray[i] = -1;
    }
    if (placeholderSize == 0) {
        appendTo.append(noPlaceholders);
        return appendTo;
    }
    appendRange(
            noPlaceholders,
            0,
            placeholdersByOffset[0],
            appendTo);
    updatePlaceholderOffset(
            placeholdersByOffset[1],
            appendTo.length(),
            offsetArray,
            offsetArrayLength);
    appendTo.append(*placeholderValues[placeholdersByOffset[1]]);
    for (int32_t i = 1; i < placeholderSize; ++i) {
        appendRange(
                noPlaceholders,
                placeholdersByOffset[2 * i - 2],
                placeholdersByOffset[2 * i],
                appendTo);
        updatePlaceholderOffset(
                placeholdersByOffset[2 * i + 1],
                appendTo.length(),
                offsetArray,
                offsetArrayLength);
        appendTo.append(*placeholderValues[placeholdersByOffset[2 * i + 1]]);
    }
    appendRange(
            noPlaceholders,
            placeholdersByOffset[2 * placeholderSize - 2],
            noPlaceholders.length(),
            appendTo);
    return appendTo;
}

int32_t SimplePatternFormatter::ensureCapacity(int32_t atLeast) {
    if (atLeast <= placeholderCapacity) {
        return atLeast;
    }
    // aim to double capacity each time
    int32_t newCapacity = 2*atLeast - 2;

    // allocate new buffer
    int32_t *newBuffer = (int32_t *) uprv_malloc(2 * newCapacity * sizeof(int32_t));
    if (newBuffer == NULL) {
        return placeholderCapacity;
    }

    // Copy contents of old buffer to new buffer
    uprv_memcpy(newBuffer, placeholdersByOffset, 2 * placeholderSize * sizeof(int32_t));

    // free old buffer
    if (placeholdersByOffset != placeholderBuffer) {
        uprv_free(placeholdersByOffset);
    }

    // Use new buffer
    placeholdersByOffset = newBuffer;
    placeholderCapacity = newCapacity;
    return atLeast;
}

UBool SimplePatternFormatter::addPlaceholder(int32_t id, int32_t offset) {
    if (ensureCapacity(placeholderSize + 1) < placeholderSize + 1) {
        return FALSE;
    }
    ++placeholderSize;
    placeholdersByOffset[2 * placeholderSize - 2] = offset;
    placeholdersByOffset[2 * placeholderSize - 1] = id;
    if (id >= placeholderCount) {
        placeholderCount = id + 1;
    }
    return TRUE;
}
    
U_NAMESPACE_END