// Copyright (c) 2016 Ryan Prichard
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

// Efficient integer->string conversion and string concatenation.  The
// hexadecimal conversion may optionally have leading zeros.  Other ways to
// convert integers to strings in C++ suffer these drawbacks:
//
//  * std::stringstream: Inefficient, even more so than stdio.
//
//  * std::to_string: No hexadecimal output, tends to use heap allocation, not
//    supported on Cygwin.
//
//  * stdio routines: Requires parsing a format string (inefficient).  The
//    caller *must* know how large the content is for correctness.  The
//    string-printf functions are extremely inconsistent on Windows.  In
//    particular, 64-bit integers, wide strings, and return values are
//    problem areas.
//
// StringBuilderTest.cc is a standalone program that tests this header.

#ifndef WINPTY_STRING_BUILDER_H
#define WINPTY_STRING_BUILDER_H

#include <array>
#include <string>
#include <type_traits>

#ifdef STRING_BUILDER_TESTING
#include <assert.h>
#define STRING_BUILDER_CHECK(cond) assert(cond)
#else
#define STRING_BUILDER_CHECK(cond)
#endif // STRING_BUILDER_TESTING

#include "WinptyAssert.h"

template <typename C, size_t sz>
struct ValueString {
    std::array<C, sz> m_array;
    size_t m_offset;
    size_t m_size;

    const C *c_str() const { return m_array.data() + m_offset; }
    const C *data() const { return m_array.data() + m_offset; }
    size_t size() const { return m_size; }
    std::basic_string<C> str() const {
        return std::basic_string<C>(data(), m_size);
    }
};

#ifdef _MSC_VER
// Disable an MSVC /SDL error that forbids unsigned negation.  Signed negation
// invokes undefined behavior for INTxx_MIN, so unsigned negation is simpler to
// reason about.  (We assume twos-complement in any case.)
#define STRING_BUILDER_ALLOW_UNSIGNED_NEGATE(x) \
    (                                           \
        __pragma(warning(push))                 \
        __pragma(warning(disable:4146))         \
        (x)                                     \
        __pragma(warning(pop))                  \
    )
#else
#define STRING_BUILDER_ALLOW_UNSIGNED_NEGATE(x) (x)
#endif

// Formats an integer as decimal without leading zeros.
template <typename C, typename I>
ValueString<C, sizeof(I) * 3 + 1 + 1> gdecOfInt(const I value) {
    typedef typename std::make_unsigned<I>::type U;
    auto unsValue = static_cast<U>(value);
    const bool isNegative = (value < 0);
    if (isNegative) {
        unsValue = STRING_BUILDER_ALLOW_UNSIGNED_NEGATE(-unsValue);
    }
    decltype(gdecOfInt<C, I>(value)) out;
    auto &arr = out.m_array;
    C *const endp = arr.data() + arr.size();
    C *outp = endp;
    *(--outp) = '\0';
    STRING_BUILDER_CHECK(outp >= arr.data());
    do {
        const int digit = unsValue % 10;
        unsValue /= 10;
        *(--outp) = '0' + digit;
        STRING_BUILDER_CHECK(outp >= arr.data());
    } while (unsValue != 0);
    if (isNegative) {
        *(--outp) = '-';
        STRING_BUILDER_CHECK(outp >= arr.data());
    }
    out.m_offset = outp - arr.data();
    out.m_size = endp - outp - 1;
    return out;
}

template <typename I> decltype(gdecOfInt<char, I>(0)) decOfInt(I i) {
    return gdecOfInt<char>(i);
}

template <typename I> decltype(gdecOfInt<wchar_t, I>(0)) wdecOfInt(I i) {
    return gdecOfInt<wchar_t>(i);
}

// Formats an integer as hexadecimal, with or without leading zeros.
template <typename C, bool leadingZeros=false, typename I>
ValueString<C, sizeof(I) * 2 + 1> ghexOfInt(const I value) {
    typedef typename std::make_unsigned<I>::type U;
    const auto unsValue = static_cast<U>(value);
    static const C hex[16] = {'0','1','2','3','4','5','6','7',
                              '8','9','a','b','c','d','e','f'};
    decltype(ghexOfInt<C, leadingZeros, I>(value)) out;
    auto &arr = out.m_array;
    C *outp = arr.data();
    int inIndex = 0;
    int shift = sizeof(I) * 8 - 4;
    const int len = sizeof(I) * 2;
    if (!leadingZeros) {
        for (; inIndex < len - 1; ++inIndex, shift -= 4) {
            STRING_BUILDER_CHECK(shift >= 0 && shift < sizeof(unsValue) * 8);
            const int digit = (unsValue >> shift) & 0xF;
            if (digit != 0) {
                break;
            }
        }
    }
    for (; inIndex < len; ++inIndex, shift -= 4) {
        const int digit = (unsValue >> shift) & 0xF;
        *(outp++) = hex[digit];
        STRING_BUILDER_CHECK(outp <= arr.data() + arr.size());
    }
    *(outp++) = '\0';
    STRING_BUILDER_CHECK(outp <= arr.data() + arr.size());
    out.m_offset = 0;
    out.m_size = outp - arr.data() - 1;
    return out;
}

template <bool leadingZeros=false, typename I>
decltype(ghexOfInt<char, leadingZeros, I>(0)) hexOfInt(I i) {
    return ghexOfInt<char, leadingZeros, I>(i);
}

template <bool leadingZeros=false, typename I>
decltype(ghexOfInt<wchar_t, leadingZeros, I>(0)) whexOfInt(I i) {
    return ghexOfInt<wchar_t, leadingZeros, I>(i);
}

template <typename C>
class GStringBuilder {
public:
    typedef std::basic_string<C> StringType;

    GStringBuilder() {}
    GStringBuilder(size_t capacity) {
        m_out.reserve(capacity);
    }

    GStringBuilder &operator<<(C ch) { m_out.push_back(ch); return *this; }
    GStringBuilder &operator<<(const C *str) { m_out.append(str); return *this; }
    GStringBuilder &operator<<(const StringType &str) { m_out.append(str); return *this; }

    template <size_t sz>
    GStringBuilder &operator<<(const ValueString<C, sz> &str) {
        m_out.append(str.data(), str.size());
        return *this;
    }

private:
    // Forbid output of char/wchar_t for GStringBuilder if the type doesn't
    // exactly match the builder element type.  The code still allows
    // signed char and unsigned char, but I'm a little worried about what
    // happens if a user tries to output int8_t or uint8_t.
    template <typename P>
    typename std::enable_if<
        (std::is_same<P, char>::value || std::is_same<P, wchar_t>::value) &&
        !std::is_same<C, P>::value, GStringBuilder&>::type
    operator<<(P ch) {
        ASSERT(false && "Method was not supposed to be reachable.");
        return *this;
    }

public:
    GStringBuilder &operator<<(short i)              { return *this << gdecOfInt<C>(i); }
    GStringBuilder &operator<<(unsigned short i)     { return *this << gdecOfInt<C>(i); }
    GStringBuilder &operator<<(int i)                { return *this << gdecOfInt<C>(i); }
    GStringBuilder &operator<<(unsigned int i)       { return *this << gdecOfInt<C>(i); }
    GStringBuilder &operator<<(long i)               { return *this << gdecOfInt<C>(i); }
    GStringBuilder &operator<<(unsigned long i)      { return *this << gdecOfInt<C>(i); }
    GStringBuilder &operator<<(long long i)          { return *this << gdecOfInt<C>(i); }
    GStringBuilder &operator<<(unsigned long long i) { return *this << gdecOfInt<C>(i); }

    GStringBuilder &operator<<(const void *p) {
        m_out.push_back(static_cast<C>('0'));
        m_out.push_back(static_cast<C>('x'));
        *this << ghexOfInt<C>(reinterpret_cast<uintptr_t>(p));
        return *this;
    }

    StringType str() { return m_out; }
    StringType str_moved() { return std::move(m_out); }
    const C *c_str() const { return m_out.c_str(); }

private:
    StringType m_out;
};

typedef GStringBuilder<char> StringBuilder;
typedef GStringBuilder<wchar_t> WStringBuilder;

#endif // WINPTY_STRING_BUILDER_H