
/**
 * Mobizt's SRAM/PSRAM supported String, version 1.2.12
 *
 * Created March 25, 2024
 *
 * Changes Log
 *
 * v1.2.12
 * - using std namespace
 * 
 * v1.2.11
 * - fix float to string conversion
 * 
 * v1.2.10
 * - add support Arduino UNO WiFi R4
 * 
 * v1.2.9
 * - substring optimization
 *
 * v1.2.8
 * - Add support StringSumHelper class in Arduino
 *
 * v1.2.7
 * - Fix string sub type checking issue
 *
 * v1.2.6
 * - Update trim() function
 *
 * v1.2.5
 * - Fixed double string issue and add support long double
 *
 * v1.2.4
 * - Check PSRAM availability before allocating the memory
 *
 * v1.2.3
 * - Fixed flash string F and PSTR handle
 *
 * v1.2.2
 * - Add supports more MCUs.
 *
 * v1.2.1
 * - Add flash string manipulation functions.
 *
 * v1.2.0
 * - Add supports bool, integer and float manipulation.
 *
 * v1.1.2
 * - Fix substring with zero length returns the original string issue.
 *
 * v1.1.1
 * - Fix possible ESP8266 code exit without resetting the external heap stack
 *
 * v1.1.0
 * - Add support ESP8266 external virtual RAM (SRAM or PSRAM)
 *
 * v1.0.1
 * - Add trim function
 * - Add version enum
 *
 * v1.0.0
 * - Initial release
 *
 * The MIT License (MIT)
 * Copyright (c) 2023 K. Suwatchai (Mobizt)
 *
 *
 * Permission is hereby granted, free of charge, to any person returning 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.
 */

#ifndef MB_String_H
#define MB_String_H

#include <Arduino.h>
#if !defined(__AVR__)
#include <string>
#include <strings.h>
#include <algorithm>
#endif

#define MB_STRING_MAJOR 1
#define MB_STRING_MINOR 2
#define MB_STRING_PATCH 5

#if defined(ESP8266) && defined(MMU_EXTERNAL_HEAP) && defined(MB_STRING_USE_PSRAM)
#include <umm_malloc/umm_malloc.h>
#include <umm_malloc/umm_heap_select.h>
#define ESP8266_USE_EXTERNAL_HEAP
#endif

#if defined(ESP8266) || defined(ESP32)
#define MBSTRING_FLASH_MCR FPSTR
#elif defined(ARDUINO_ARCH_SAMD) || defined(__AVR_ATmega4809__) || defined(ARDUINO_NANO_RP2040_CONNECT)
#define MBSTRING_FLASH_MCR PSTR
#else
#define MBSTRING_FLASH_MCR(s) (s)
#endif

class MB_String;

#define pgm2Str(p) (MB_String().appendP(p).c_str())
#define num2Str(v, p) (MB_String().appendNum(v, p).c_str())


namespace mb_string
{
    enum mb_string_sub_type
    {
        mb_string_sub_type_none,
        mb_string_sub_type_bool,
        mb_string_sub_type_float,
        mb_string_sub_type_double,
        mb_string_sub_type_int8,
        mb_string_sub_type_uint8,
        mb_string_sub_type_int16,
        mb_string_sub_type_uint16,
        mb_string_sub_type_int32,
        mb_string_sub_type_uint32,
        mb_string_sub_type_int64,
        mb_string_sub_type_uint64,
        mb_string_sub_type_cstring,
        mb_string_sub_type_chars,
        mb_string_sub_type_mb_string,
        mb_string_sub_type_arduino_string,
        mb_string_sub_type_std_string,
        mb_string_sub_type_fptr,
        mb_string_sub_type_string_sum_helper

    };

    typedef struct mb_string_ptr_t
    {

    public:
        mb_string_ptr_t(uint32_t addr = 0, mb_string_sub_type type = mb_string_sub_type_cstring, int precision = -1, const StringSumHelper *s = nullptr)
        {
            _addr = addr;
            _type = type;
            _precision = precision;
            _ssh = s;
        }
        int precision() { return _precision; }
        mb_string_sub_type type() { return _type; }
        uint32_t address() { return _addr; }
        const StringSumHelper *stringsumhelper() { return _ssh; }

    private:
        mb_string_sub_type _type = mb_string_sub_type_none;
        int _precision = -1;
        uint32_t _addr = 0;
        const StringSumHelper *_ssh = nullptr;

    } MB_StringPtr;

    template <bool, typename T = void>
    struct enable_if
    {
    };
    template <typename T>
    struct enable_if<true, T>
    {
        typedef T type;
    };
    template <typename T, typename U>
    struct is_same
    {
        static bool const value = false;
    };
    template <typename T>
    struct is_same<T, T>
    {
        static bool const value = true;
    };

    template <typename T>
    struct is_num_int8
    {
        static bool const value = std::is_same<T, int8_t>::value || std::is_same<T, signed char>::value;
    };

    template <typename T>
    struct is_num_uint8
    {
        static bool const value = std::is_same<T, uint8_t>::value || std::is_same<T, unsigned char>::value;
    };

    template <typename T>
    struct is_num_int16
    {
        static bool const value = std::is_same<T, int16_t>::value || std::is_same<T, signed short>::value;
    };

    template <typename T>
    struct is_num_uint16
    {
        static bool const value = std::is_same<T, uint16_t>::value || std::is_same<T, unsigned short>::value;
    };

    template <typename T>
    struct is_num_int32
    {
        static bool const value = std::is_same<T, signed int>::value || std::is_same<T, int>::value ||
                                  std::is_same<T, int32_t>::value || std::is_same<T, long>::value ||
                                  std::is_same<T, signed long>::value;
    };

    template <typename T>
    struct is_num_uint32
    {
        static bool const value = std::is_same<T, unsigned int>::value || std::is_same<T, uint32_t>::value ||
                                  std::is_same<T, unsigned long>::value;
    };

    template <typename T>
    struct is_num_int64
    {
        static bool const value = std::is_same<T, int64_t>::value || std::is_same<T, signed long long>::value;
    };

    template <typename T>
    struct is_num_uint64
    {
        static bool const value = std::is_same<T, uint64_t>::value || std::is_same<T, unsigned long long>::value;
    };

    template <typename T>
    struct is_num_neg_int
    {
        static bool const value = is_num_int8<T>::value || is_num_int16<T>::value ||
                                  is_num_int32<T>::value || is_num_int64<T>::value;
    };

    template <typename T>
    struct is_num_pos_int
    {
        static bool const value = is_num_uint8<T>::value || is_num_uint16<T>::value ||
                                  is_num_uint32<T>::value || is_num_uint64<T>::value;
    };

    template <typename T>
    struct is_num_int
    {
        static bool const value = is_num_pos_int<T>::value || is_num_neg_int<T>::value;
    };

    template <typename T>
    struct is_num_float
    {
        static bool const value = std::is_same<T, float>::value || std::is_same<T, double>::value || std::is_same<T, long double>::value;
    };

    template <typename T>
    struct is_bool
    {
        static bool const value = std::is_same<T, bool>::value;
    };

    template <typename T>
    struct cs_t
    {
        static bool const value = std::is_same<T, char *>::value;
    };

    template <typename T>
    struct ccs_t
    {
        static bool const value = std::is_same<T, const char *>::value;
    };

    template <typename T>
    struct as_t
    {
        static bool const value = std::is_same<T, String>::value;
    };

    template <typename T>
    struct cas_t
    {
        static bool const value = std::is_same<T, const String>::value;
    };

    template <typename T>
    struct ss_t
    {
#if !defined(__AVR__)
        static bool const value = std::is_same<T, std::string>::value;
#else
        static bool const value = false;
#endif
    };

    template <typename T>
    struct css_t
    {
#if !defined(__AVR__)
        static bool const value = std::is_same<T, const std::string>::value;
#else
        static bool const value = false;
#endif
    };

    template <typename T>
    struct ssh_t
    {
        static bool const value = std::is_same<T, StringSumHelper>::value;
    };

    template <typename T>
    struct fs_t
    {
        static bool const value = std::is_same<T, const __FlashStringHelper *>::value;
    };

    template <typename T>
    struct mbs_t
    {
        static bool const value = std::is_same<T, MB_String>::value;
    };

    template <typename T>
    struct cmbs_t
    {
        static bool const value = std::is_same<T, const MB_String>::value;
    };

    template <typename T>
    struct pgm_t
    {
        static bool const value = std::is_same<T, PGM_P>::value;
    };

    template <typename T>
    struct is_const_chars
    {
        static bool const value = cs_t<T>::value || ccs_t<T>::value;
    };

    template <typename T>
    struct is_arduino_string
    {
        static bool const value = as_t<T>::value || cas_t<T>::value;
    };

    template <typename T>
    struct is_std_string
    {
        static bool const value = ss_t<T>::value || css_t<T>::value;
    };

    template <typename T>
    struct is_mb_string
    {
        static bool const value = mbs_t<T>::value || cmbs_t<T>::value;
    };

    template <typename T>
    struct is_arduino_string_sum_helper
    {
        static bool const value = ssh_t<T>::value;
    };

    template <typename T>
    struct is_arduino_flash_string_helper
    {
        static bool const value = fs_t<T>::value;
    };

    template <typename T>
    struct is_string
    {
        static bool const value = is_const_chars<T>::value || is_arduino_string<T>::value ||
                                  is_arduino_string_sum_helper<T>::value || is_arduino_flash_string_helper<T>::value ||
                                  is_std_string<T>::value || is_mb_string<T>::value;
    };

    template <typename T>
    uint32_t toAddr(T &v) { return reinterpret_cast<uint32_t>(&v); }

#if defined(__AVR__)
    template <typename T>
    T addrTo(int address)
    {
        return reinterpret_cast<T>(address);
    }
#else
    template <typename T>
    auto addrTo(int address) -> typename std::enable_if<!std::is_same<T, nullptr_t>::value, T>::type
    {
        return reinterpret_cast<T>(address);
    }
#endif

    template <typename T>
    auto getSubType(T val) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || std::is_same<T, bool>::value || is_const_chars<T>::value || is_arduino_flash_string_helper<T>::value || is_arduino_string<T>::value || is_std_string<T>::value || is_mb_string<T>::value || std::is_same<T, StringSumHelper>::value, mb_string_sub_type>::type
    {
        if (is_num_uint64<T>::value)
            return mb_string_sub_type_uint64;
        else if (is_num_int64<T>::value)
            return mb_string_sub_type_int64;
        else if (is_num_uint32<T>::value)
            return mb_string_sub_type_uint32;
        else if (is_num_int32<T>::value)
            return mb_string_sub_type_int32;
        else if (is_num_uint16<T>::value)
            return mb_string_sub_type_uint16;
        else if (is_num_int16<T>::value)
            return mb_string_sub_type_int16;
        else if (is_num_uint8<T>::value)
            return mb_string_sub_type_uint8;
        else if (is_num_int8<T>::value)
            return mb_string_sub_type_int8;
        else if (std::is_same<T, bool>::value)
            return mb_string_sub_type_bool;
        else if (std::is_same<T, float>::value)
            return mb_string_sub_type_float;
        else if (std::is_same<T, double>::value)
            return mb_string_sub_type_double;
        else if (is_arduino_string<T>::value)
            return mb_string_sub_type_arduino_string;
        else if (is_std_string<T>::value)
            return mb_string_sub_type_std_string;
        else if (is_mb_string<T>::value)
            return mb_string_sub_type_mb_string;
        else if (is_arduino_flash_string_helper<T>::value)
            return mb_string_sub_type_fptr;
        else if (std::is_same<T, StringSumHelper>::value)
            return mb_string_sub_type_string_sum_helper;
        else if (ccs_t<T>::value)
            return mb_string_sub_type_cstring;
        else if (cs_t<T>::value)
            return mb_string_sub_type_chars;

        return mb_string_sub_type_int8;
    }

    template <typename T>
    auto getSubType(T *val) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || std::is_same<T, bool>::value || is_const_chars<T>::value || is_arduino_flash_string_helper<T>::value || is_arduino_string<T>::value || is_std_string<T>::value || is_mb_string<T>::value || std::is_same<T, StringSumHelper>::value, mb_string_sub_type>::type
    {
        return getSubType(*val);
    }

    template <typename T>
    auto toStringPtr(const T &val) -> typename std::enable_if<is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value, MB_StringPtr>::type
    {
        return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val));
    }

    template <typename T>
    auto toStringPtr(const T &val) -> typename std::enable_if<std::is_same<T, StringSumHelper>::value, MB_StringPtr>::type
    {
#if defined(ESP8266)
        return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val), -1);

#else
        return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val), -1, &val);
#endif
    }

    template <typename T>
    auto toStringPtr(T val) -> typename std::enable_if<is_const_chars<T>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(val), getSubType(val)); }

    template <typename T>
    auto toStringPtr(T &val) -> typename std::enable_if<is_arduino_flash_string_helper<T>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(val), getSubType(val)); }

#if !defined(__AVR__)
    template <typename T>
    auto toStringPtr(T val) -> typename std::enable_if<std::is_same<T, std::nullptr_t>::value, MB_StringPtr>::type
    {
        return MB_StringPtr();
    }
#endif

    template <typename T>
    auto toStringPtr(T val) -> typename std::enable_if<std::is_same<T, MB_StringPtr>::value, MB_StringPtr>::type
    {
        return val;
    }

    template <typename T>
    auto toStringPtr(T &val, int precision = -1) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || std::is_same<T, bool>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val), precision); }
}

using namespace mb_string;

class MB_String
{
public:
    MB_String()
    {
#if defined(ESP8266_USE_EXTERNAL_HEAP)
        // reserve default 1 byte external heap to refer to its pointer later
        reset(1);
#endif
    };

    ~MB_String()
    {
        allocate(0, false);
    };

    MB_String(const char *cstr)
    {
        if (cstr)
            copy(cstr, strlen_P(cstr));
    }

    MB_String(const MB_String &value)
    {
        *this = value;
    }

    MB_String(const __FlashStringHelper *str)
    {
        *this = str;
    }

#if !defined(ESP8266)
    MB_String(StringSumHelper rval)
    {
        *this = rval;
    }
#endif

    MB_String(MB_StringPtr value)
    {
        *this = value;
    }

    MB_String(String value)
    {
        *this = value;
    }

    MB_String(bool value)
    {
        appendNum(value);
    }

    MB_String(unsigned char value, unsigned char base = 10)
    {
        int len = 1 + 8 * sizeof(unsigned char);
        reserve(len);

        if (bufLen > 0)
            utoa(value, buf, base);
    }

    MB_String(int value, unsigned char base = 10)
    {
        int len = 2 + 8 * sizeof(int);
        reserve(len);

        if (bufLen > 0)
        {
            if (base == 10)
                sprintf(buf, (const char *)MBSTRING_FLASH_MCR("%d"), value);
            else
                itoa(value, buf, base);
        }
    }

    MB_String(unsigned int value, unsigned char base = 10)
    {
        int len = 1 + 8 * sizeof(unsigned int);
        reserve(len);

        if (bufLen > 0)
            utoa(value, buf, base);
    }

    MB_String(long value, unsigned char base = 10)
    {
        int len = 2 + 8 * sizeof(long);
        reserve(len);

        if (bufLen > 0)
        {
            if (base == 10)
                sprintf(buf, (const char *)MBSTRING_FLASH_MCR("%ld"), value);
            else
                ltoa(value, buf, base);
        }
    }

    MB_String(unsigned long value, unsigned char base = 10)
    {
        int len = 1 + 8 * sizeof(unsigned long);
        reserve(len);

        if (bufLen > 0)
            ultoa(value, buf, base);
    }

    MB_String(float value, unsigned char decimalPlaces = 2)
    {
        reserve(33);
        if (bufLen > 0)
        {
            char *v = toFloatStr(value, 0, decimalPlaces);
            if (v)
            {
                strcpy(buf, v);
                delP(&v);
            }
        }
    }

    MB_String(double value, unsigned char decimalPlaces = 3)
    {
        reserve(33);

        if (bufLen > 0)
        {
            char *v = toFloatStr(value, 1, decimalPlaces);
            if (v)
            {
                strcpy(buf, v);
                delP(&v);
            }
        }
    }

    MB_String(long double value, unsigned char decimalPlaces = 3)
    {
        reserve(65);
        if (bufLen > 0)
        {
            char *v = toFloatStr(value, 2, decimalPlaces);
            if (v)
            {
                strcpy(buf, v);
                delP(&v);
            }
        }
    }

#if !defined(__AVR__)
    MB_String &operator=(const std::string &rhs)
    {
        if (rhs.length() > 0)
            copy(rhs.c_str(), rhs.length());
        else
            clear();

        return *this;
    }
#endif
    MB_String &operator=(const String &rhs)
    {

        if (rhs.length() > 0)
            copy(rhs.c_str(), rhs.length());
        else
            clear();

        return *this;
    }

    MB_String &operator=(const __FlashStringHelper *str)
    {
        if (str)
            appendF(str, true);

        return *this;
    }

#if !defined(ESP8266)
    MB_String &operator=(StringSumHelper rval)
    {
        String temp = rval;
        *this = temp;
        return *this;
    }

    MB_String &operator+=(StringSumHelper rval)
    {
        String temp = rval;
        *this += temp;
        return *this;
    }
#endif

    MB_String &operator+=(const __FlashStringHelper *str)
    {
        if (str)
            appendF(str);

        return *this;
    }

    unsigned char operator==(const MB_String &rhs) const
    {
        return equals(rhs);
    }

    unsigned char operator==(const char *cstr) const
    {
        return equals(cstr);
    }

    unsigned char operator!=(const MB_String &rhs) const
    {
        return !equals(rhs);
    }

    unsigned char operator!=(const char *cstr) const
    {
        return !equals(cstr);
    }
#if !defined(__AVR__)
    MB_String &operator+=(const std::string &rhs)
    {
        concat(rhs.c_str());
        return (*this);
    }
#endif
    MB_String &operator+=(const String &rhs)
    {
        concat(rhs.c_str());
        return (*this);
    }

    MB_String &operator=(const MB_String &rhs)
    {
        if (this == &rhs)
            return *this;

        if (rhs.length() > 0)
            copy(rhs.buf, rhs.length());
        else
            clear();

        return *this;
    }

    MB_String &operator+=(const MB_String &rhs)
    {
        concat(rhs);
        return (*this);
    }

    MB_String &operator+=(const char *cstr)
    {
        size_t len = strlen_P(cstr);
        size_t slen = length();

        if (_reserve(slen + len, false))
        {
            strcat_P(buf, (PGM_P)cstr);
            *(buf + slen + len) = '\0';
        }

        return (*this);
    }

    MB_String &operator+=(char cstr)
    {
        append(1, cstr);
        return (*this);
    }

    MB_String &operator+=(bool value)
    {
        appendNum(value);
        return (*this);
    }

    MB_String &operator=(MB_StringPtr ptr)
    {
        setPtr(ptr);
        return (*this);
    }

    MB_String &operator+=(MB_StringPtr ptr)
    {
        appendPtr(ptr);
        return (*this);
    }

    template <typename T = int>
    auto operator=(T value) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, MB_String &>::type
    {
        clear();
        appendNum(value);
        return (*this);
    }

    template <typename T = int>
    auto operator+=(T value) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, MB_String &>::type
    {
        appendNum(value);
        return (*this);
    }

    MB_String &appendP(PGM_P pgms, bool clear = false)
    {
        if (clear)
            this->clear();

        char *t = pgmStr(pgms);
        if (t)
        {
            *this += t;
            delP(&t);
        }

        return (*this);
    }

    MB_String &appendF(const __FlashStringHelper *pstr, bool clear = false)
    {
        if (clear)
            this->clear();

        int len = strlen_P((PGM_P)pstr);
        if (len > 0)
        {
            unsigned int newlen = length() + len;
            reserve(newlen);

            if (bufLen > 0)
                memcpy_P(buf + length(), (PGM_P)pstr, len + 1);
        }

        return (*this);
    }

    MB_String &setPtr(MB_StringPtr src)
    {
        clear();
        appendPtr(src);
        return (*this);
    };

    MB_String &appendPtr(MB_StringPtr src)
    {
        if (src.type() == mb_string_sub_type_fptr)
            appendF(addrTo<const __FlashStringHelper *>(src.address()));
        else if (src.type() == mb_string_sub_type_cstring || src.type() == mb_string_sub_type_chars)
            *this += addrTo<const char *>(src.address());
        else if (src.type() == mb_string_sub_type_arduino_string)
            *this += *addrTo<String *>(src.address());
        else if (src.type() == mb_string_sub_type_string_sum_helper)
#if !defined(ESP8266)
            *this += *src.stringsumhelper();
#else
            *this += *addrTo<String *>(src.address());
#endif
#if !defined(__AVR__)
        else if (src.type() == mb_string_sub_type_std_string)
            *this += *addrTo<std::string *>(src.address());
#endif
        else if (src.type() == mb_string_sub_type_mb_string)
            *this += *addrTo<MB_String *>(src.address());
        else if (src.type() == mb_string_sub_type_uint64)
            appendNum(*addrTo<uint64_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_int64)
            appendNum(*addrTo<int64_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_uint32)
            appendNum(*addrTo<uint32_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_int32)
            appendNum(*addrTo<int32_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_uint16)
            appendNum(*addrTo<uint16_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_int16)
            appendNum(*addrTo<int16_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_uint8)
            appendNum(*addrTo<uint8_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_int8)
            appendNum(*addrTo<int8_t *>(src.address()));
        else if (src.type() == mb_string_sub_type_bool)
            appendNum(*addrTo<bool *>(src.address()));
        else if (src.type() == mb_string_sub_type_float)
            appendNum(*addrTo<float *>(src.address()), src.precision());
        else if (src.type() == mb_string_sub_type_double)
            appendNum(*addrTo<double *>(src.address()), src.precision());

        return (*this);
    };

    template <typename T = int>
    auto appendNum(T value, int precision = 0) -> typename std::enable_if<is_num_int<T>::value || is_bool<T>::value, MB_String &>::type
    {
        char *s = NULL;

        if (is_bool<T>::value)
            s = boolStr(value);
        else if (is_num_neg_int<T>::value)
        {
#if defined(ARDUINO_ARCH_SAMD) || defined(__AVR_ATmega4809__) || defined(ARDUINO_NANO_RP2040_CONNECT) || defined(ARDUINO_UNOWIFIR4)
            s = int32Str(value);
#else
            s = int64Str(value);
#endif
        }
        else if (is_num_pos_int<T>::value)
        {
#if defined(ARDUINO_ARCH_SAMD) || defined(__AVR_ATmega4809__) || defined(ARDUINO_NANO_RP2040_CONNECT) || defined(ARDUINO_UNOWIFIR4)
            s = uint32Str(value);
#else
            s = uint64Str(value);
#endif
        }

        if (s)
        {
            *this += s;
            delP(&s);
        }

        return (*this);
    }

    MB_String &appendNum(float value, int precision = 5)
    {
        if (precision < 0)
            precision = 5;

        char *s = toFloatStr(value, 0, precision);
        if (s)
        {
            *this += s;
            delP(&s);
        }
        return (*this);
    }

    MB_String &appendNum(double value, int precision = 9)
    {
        if (precision < 0)
            precision = 9;

        char *s = toFloatStr(value, 1, precision);
        if (s)
        {
            *this += s;
            delP(&s);
        }
        return (*this);
    }

    MB_String &appendNum(long double value, int precision = 9)
    {
        if (precision < 0)
            precision = 9;

        char *s = toFloatStr(value, 2, precision);
        if (s)
        {
            *this += s;
            delP(&s);
        }
        return (*this);
    }

    MB_String &operator=(const char *cstr)
    {
        if (cstr)
            copy(cstr, strlen_P(cstr));
        else
            clear();

        return *this;
    }

    MB_String &operator=(char c)
    {
        clear();
        if (_reserve(1, false))
        {
            *(buf) = c;
            *(buf + 1) = '\0';
        }

        return *this;
    }

    void trim()
    {
        int p1 = 0, p2 = length() - 1;
        while (p1 < (int)length())
        {
            if (buf[p1] > 32)
                break;
            p1++;
        }

        while (p2 >= 0)
        {
            if (buf[p2] > 32)
                break;
            p2--;
        }

        if (p1 == (int)length() && p2 < 0)
        {
            clear();
            return;
        }

        if (p2 >= p1 && p2 >= 0 && p1 < (int)length())
        {
            memmove(buf, buf + p1, p2 - p1 + 1);
            buf[p2 - p1 + 1] = '\0';
            _reserve(p2 - p1 + 1, true);
        }
    }

    void append(const char *cstr, size_t n)
    {
        if (!cstr)
            return;

        size_t slen = length();

        if (n > strlen(cstr))
            n = strlen(cstr);

        if (_reserve(slen + n, false))
        {
            memmove(buf + slen, cstr, n);
            *(buf + slen + n) = '\0';
        }
    }

    void append(size_t n, char c)
    {
        size_t slen = length();

        if (_reserve(slen + n, false))
        {
            for (size_t i = 0; i < n; i++)
                *(buf + slen + i) = c;
            *(buf + slen + n) = '\0';
        }
    }

    void prepend(char c)
    {
        size_t slen = length();
        size_t len = 1;

        if (maxLength() < slen + len)
            _reserve(slen + len, false);

        memmove(buf + len, buf, slen);
        buf[0] = c;
        buf[len + slen] = '\0';
    }

    void prepend(const char *cstr)
    {
        size_t slen = length();
        size_t len = strlen(cstr);

        if (maxLength() < slen + len)
            _reserve(slen + len, false);

        memmove(buf + len, buf, slen);
        memmove(buf, cstr, len);
        buf[len + slen] = '\0';
    }

    const char *c_str() const
    {
        if (!buf)
            return "";
        return (const char *)buf;
    }

    char operator[](size_t index) const
    {
        if (index >= bufLen || !buf)
            return 0;
        return buf[index];
    }

    char &operator[](size_t index)
    {
        static char c;
        if (index >= bufLen || !buf)
        {
            c = '\0';
            return c;
        }
        return buf[index];
    }

    void swap(MB_String &rhs)
    {
        rhs.clear();
    }

    void shrink_to_fit()
    {
        size_t slen = length();
        _reserve(slen, true);
    }

    void pop_back()
    {
        if (length() > 0)
        {
            size_t slen = length();
            if (slen > 0)
                buf[slen - 1] = '\0';
            _reserve(slen, true);
        }
    }

    size_t size() const
    {
        return length();
    }

    size_t bufferLength() const
    {
        return bufLen;
    }

    size_t find(const MB_String &s, size_t index = 0) const
    {
        if (!s.buf)
            return -1;
        return strpos(buf, s.buf, index);
    }

    size_t find(const char *s, size_t index = 0) const
    {
        return strpos(buf, s, index);
    }

    size_t find(char c, size_t index = 0) const
    {
        return strpos(buf, c, index);
    }

    size_t rfind(const char *s, size_t index = npos) const
    {
        return rstrpos(buf, s, index);
    }

    size_t rfind(char c, size_t index = npos) const
    {
        return rstrpos(buf, c, index);
    }

    void erase(size_t index = 0, size_t len = npos)
    {

        if (!buf || index >= length())
            return;

        if (index + len > length() || len == npos)
            len = length() - index;

        int rightLen = length() - index - len;

        memmove(buf + index, buf + index + len, rightLen);

        buf[index + rightLen] = '\0';

        _reserve(length(), true);
    }

    size_t length() const
    {
        if (!buf)
            return 0;
        return strlen(buf);
    }

    MB_String substr(size_t offset, size_t len = npos) const
    {
        MB_String out;
        substr(out, offset, len);
        return out;
    }

    void substr(MB_String &out, size_t offset, size_t len = npos) const
    {
        if (len > 0 && length() > 0 && offset < length())
        {
            if (len > length() - offset)
                len = length() - offset;
            out.copy(buf + offset, len);
        }
    }

    void clear()
    {
#if defined(ESP8266_USE_EXTERNAL_HEAP)
        reset(1);
#else
        allocate(0, false);
#endif
    }

#if defined(ESP8266_USE_EXTERNAL_HEAP)
    void reset(size_t len)
    {
        if (len == 0)
            len = 4;
        ESP.setExternalHeap();
        if (buf)
            buf = (char *)realloc(buf, len);
        else
            buf = (char *)malloc(len);
        ESP.resetHeap();

        if (buf)
        {
            bufLen = len;
            memset(buf, 0, len);
        }
    }
#endif

    void resize(size_t len)
    {
        if (_reserve(len, true))
            buf[len] = '\0';
    }

    MB_String &replace(size_t pos, size_t len, const char *replace)
    {
        size_t repLen = strlen(replace);

        if (length() > 0 && length() > pos && repLen > 0)
        {
            if (pos + len > length())
                len = length() - pos;

            if (repLen > len)
            {
                size_t rightLen = length() - pos - len;

                if (maxLength() < length() + repLen - len)
                    _reserve(length() + repLen - len, false);

                memmove(buf + pos + repLen, buf + pos + len, rightLen);
                buf[pos + repLen + rightLen] = '\0';
            }

            memmove(buf + pos, replace, repLen);
        }

        return *this;
    }

    MB_String &replace(size_t pos, size_t len, const MB_String &replace)
    {
        return this->replace(pos, len, replace.c_str());
    }

    MB_String &insert(size_t pos, size_t n, char c)
    {
        size_t slen = length();

        size_t rightLen = slen - pos;

        if (maxLength() < slen + n)
            _reserve(slen + n, false);

        if (maxLength() >= slen + n)
        {
            memmove(buf + pos + n, buf + pos, rightLen);

            for (size_t i = 0; i < n; i++)
                *(buf + pos + i) = c;

            buf[pos + n + rightLen] = '\0';
        }

        return *this;
    }

    MB_String &insert(size_t pos, const char *cstr)
    {
        size_t insLen = strlen(cstr);

        if (length() > 0 && length() > pos && insLen > 0)
        {

            size_t rightLen = length() - pos;

            if (maxLength() < length() + insLen)
                _reserve(length() + insLen, false);

            memmove(buf + pos + insLen, buf + pos, rightLen);
            buf[pos + insLen + rightLen] = '\0';
            memmove(buf + pos, cstr, insLen);
        }

        return *this;
    }

    MB_String &insert(size_t pos, const MB_String &str)
    {
        return insert(pos, str.c_str());
    }

    MB_String &insert(size_t pos, char c)
    {
        char temp[2]{c, '\0'};
        return insert(pos, temp);
    }

    size_t find_first_of(const char *cstr, size_t pos = 0) const
    {
        if (!cstr)
            return -1;

        return strpos(buf, cstr, pos);
    }

    size_t find_first_of(const MB_String &str, size_t pos = 0) const
    {
        if (length() == 0 || pos >= length())
            return -1;

        return find_first_of(str.buf, pos);
    }

    size_t find_first_not_of(const char *cstr, size_t pos = 0) const
    {
        if (length() == 0 || pos >= length())
            return -1;

        int size = strcspn(buf + pos, cstr);
        if (size == 0)
        {
            while (size == 0 && pos < length())
            {
                size = strcspn(buf + pos, cstr);
                pos++;
            }

            if (pos > 0)
                pos--;
        }

        return pos;
    }

    size_t find_first_not_of(const MB_String &str, size_t pos = 0) const
    {
        if (length() == 0 || pos >= length() || str.length() == 0)
            return -1;

        return find_first_not_of(str.buf, pos);
    }

    size_t find_last_of(const char *cstr, size_t pos = npos) const
    {
        if (!cstr)
            return -1;

        return rstrpos(buf, cstr, pos);
    }

    size_t find_last_of(const MB_String &str, size_t pos = npos) const
    {
        if (str.length() == 0)
            return -1;

        return find_last_of(str.buf, pos);
    }

    size_t find_last_not_of(const char *cstr, size_t pos = npos) const
    {
        if (length() == 0)
            return -1;

        if (pos >= length())
            pos = length() - 1;

        int p = length() - 1;
        int size = strcspn(buf + p, cstr);
        if (size == 0)
        {
            while (size == 0 && p > 0)
            {
                size = strcspn(buf + p, cstr);
                p--;
            }
            p++;
        }

        return p;
    }

    size_t find_last_not_of(const MB_String &str, size_t pos = npos) const
    {
        if (str.length() == 0)
            return -1;

        return find_last_not_of(str.buf, pos);
    }

    MB_String & replaceAll(const char *find, const char *replace)
    {
        if (length() == 0)
            return *this;;

        int i, cnt = 0;
        int repLen = strlen(replace);
        int findLen = strlen(find);

        MB_String temp = buf;
        char *s = temp.buf;
        clear();

        for (i = 0; s[i] != '\0'; i++)
        {
            if (strstr(&s[i], find) == &s[i])
            {
                cnt++;
                i += findLen - 1;
            }
        }

        if (_reserve(i + cnt * (repLen - findLen) + 1, false))
        {
            i = 0;
            while (*s)
            {
                if (strstr(s, find) == s)
                {
                    strcpy(&buf[i], replace);
                    i += repLen;
                    s += findLen;
                }
                else
                    buf[i++] = *s++;
            }

            buf[i] = '\0';
        }

        temp.clear();

        return *this;
    }

    void replaceAll(const MB_String &find, const MB_String &replace)
    {
        replaceAll(find.c_str(), replace.c_str());
    }

    bool empty() const
    {
        return length() == 0;
    }

    void reserve(size_t len)
    {
        if (_reserve(len, false))
            buf[len] = '\0';
    }

    static const size_t npos = -1;

private:
#if defined(ARDUINO_ARCH_SAMD) || defined(__AVR_ATmega4809__) || defined(ARDUINO_NANO_RP2040_CONNECT) || defined(ARDUINO_UNOWIFIR4)

    char *int32Str(signed long value)
    {
        char *t = (char *)newP(64);
        sprintf(t, (const char *)MBSTRING_FLASH_MCR("%ld"), value);
        return t;
    }

    char *uint32Str(unsigned long value)
    {
        char *t = (char *)newP(64);
        sprintf(t, (const char *)MBSTRING_FLASH_MCR("%lu"), value);
        return t;
    }

#endif

    char *int64Str(signed long long value)
    {
        char *t = (char *)newP(64);
        sprintf(t, (const char *)MBSTRING_FLASH_MCR("%lld"), value);
        return t;
    }

    char *uint64Str(unsigned long long value)
    {
        char *t = (char *)newP(64);
        sprintf(t, (const char *)MBSTRING_FLASH_MCR("%llu"), value);
        return t;
    }

    char *boolStr(bool value)
    {
        char *t = (char *)newP(8);
        value ? strcpy(t, (const char *)MBSTRING_FLASH_MCR("true")) : strcpy(t, (const char *)MBSTRING_FLASH_MCR("false"));
        return t;
    }

    char *toFloatStr(long double value, int type, int precision)
    {
        int width = type == 0 ? 32 : 64;

        char *t = (char *)newP(width);

        if (t)
        {
            MB_String fmt = MBSTRING_FLASH_MCR("%.");
            fmt += precision;

            if (type < 2)
            {
                fmt += MBSTRING_FLASH_MCR("f");
                sprintf(t, fmt.c_str(), (double)value);
            }
            else
            {
                fmt += MBSTRING_FLASH_MCR("Lf");
                sprintf(t, fmt.c_str(), value);
            }

            trim(t);
        }

        return t;
    }

    char *nullStr()
    {
        char *t = (char *)newP(6);
        strcpy(t, (const char *)MBSTRING_FLASH_MCR("null"));
        return t;
    }

    char *pgmStr(PGM_P p)
    {
        char *t = (char *)newP(strlen_P(p));
        strcpy_P(t, p);
        return t;
    }

    void trim(char *s)
    {
        if (!s)
            return;
        size_t i = strlen(s) - 1;
        while (s[i] == '0' && i > 0)
        {
            if (s[i - 1] == '.')
            {
                i--;
                break;
            }
            if (s[i - 1] != '0')
                break;
            i--;
        }
        if (i < strlen(s) - 1)
            s[i] = '\0';
    }

    void *newP(size_t len)
    {
        void *p;
        size_t newLen = getReservedLen(len);
#if defined(BOARD_HAS_PSRAM) && defined(MB_STRING_USE_PSRAM)
        if (ESP.getPsramSize() > 0)
            p = (void *)ps_malloc(newLen);
        else
            p = (void *)malloc(newLen);
        if (!p)
            return NULL;

#else

#if defined(ESP8266_USE_EXTERNAL_HEAP)
        ESP.setExternalHeap();
#endif

        p = (void *)malloc(newLen);
        bool nn = p ? true : false;

#if defined(ESP8266_USE_EXTERNAL_HEAP)
        ESP.resetHeap();
#endif

        if (!nn)
            return NULL;

#endif
        memset(p, 0, newLen);
        return p;
    }

    void delP(void *ptr)
    {
        void **p = (void **)ptr;
        if (*p)
        {
            free(*p);
            *p = 0;
        }
    }

    size_t getReservedLen(size_t len)
    {
        int blen = len + 1;

        int newlen = (blen / 4) * 4;

        if (newlen < blen)
            newlen += 4;

        return (size_t)newlen;
    }

    size_t maxLength() const
    {
        if (bufferLength() == 0)
            return 0;
        return bufferLength() - 1;
    }

    void concat(const MB_String &s)
    {
        if (s.length() == 0)
            return;

        if (&s == this)
        {
            size_t slen = length();

            if (2 * slen > maxLength())
            {
                if (!_reserve(2 * slen, false))
                    return;
            }

            memmove(buf + slen, buf, slen);
            buf[2 * slen] = '\0';
        }
        else
        {
            concat(s.buf, s.length());
        }
    }

    void concat(const char *cstr, size_t len)
    {
        if (!cstr)
            return;

        size_t slen = length();

        if (slen + len > maxLength())
        {
            if (!_reserve(slen + len, false))
                return;
        }

        memmove(buf + slen, cstr, len);
        buf[slen + len] = '\0';
    }

    void concat(const char *cstr)
    {
        if (!cstr)
            return;

        concat(cstr, strlen(cstr));
    }

    void move(MB_String &rhs)
    {
        if (buf)
        {
            if (bufLen >= rhs.bufLen)
            {
                strcpy(buf, rhs.buf);
                bufLen = rhs.bufLen;
                rhs.bufLen = 0;
                return;
            }
            else
            {
                free(buf);
            }
        }
        buf = rhs.buf;
        bufLen = rhs.bufLen;
        rhs.buf = NULL;
    }

    void allocate(size_t len, bool shrink)
    {

        if (len == 0)
        {
            if (buf)
                free(buf);
            buf = NULL;
            bufLen = 0;
            return;
        }

        if (len > bufLen || shrink)
        {

#if defined(ESP8266_USE_EXTERNAL_HEAP)
            ESP.setExternalHeap();
#endif

            if (shrink || (bufLen > 0 && buf))
            {
                int slen = length();

#if defined(BOARD_HAS_PSRAM) && defined(MB_STRING_USE_PSRAM)
                if (ESP.getPsramSize() > 0)
                    buf = (char *)ps_realloc(buf, len);
                else
                    buf = (char *)realloc(buf, len);
#else
                buf = (char *)realloc(buf, len);
#endif
                if (buf)
                {
                    buf[slen] = '\0';
                    bufLen = len;
                }
            }
            else
            {
#if defined(BOARD_HAS_PSRAM) && defined(MB_STRING_USE_PSRAM)
                if (ESP.getPsramSize() > 0)
                    buf = (char *)ps_malloc(len);
                else
                    buf = (char *)malloc(len);
#else
                buf = (char *)malloc(len);
#endif
                if (buf)
                {
                    buf[0] = '\0';
                    bufLen = len;
                }
            }

#if defined(ESP8266_USE_EXTERNAL_HEAP)
            ESP.resetHeap();
#endif
        }
    }

    MB_String &copy(const char *cstr, size_t length)
    {

        if (!_reserve(length, false))
        {
            clear();
            return *this;
        }

        memcpy_P(buf, (PGM_P)cstr, length);
        buf[length] = '\0';

        return *this;
    }

    bool _reserve(size_t len, bool shrink)
    {

        size_t newlen = getReservedLen(len);
        if (shrink)
            allocate(newlen, true);
        else if (newlen > bufLen)
            allocate(newlen, false);

        return newlen <= bufLen;
    }

    int strpos(const char *haystack, const char *needle, int offset) const
    {
        if (!haystack || !needle)
            return -1;

        int hlen = strlen(haystack);
        int nlen = strlen(needle);

        if (hlen == 0 || nlen == 0)
            return -1;

        int hidx = offset, nidx = 0;
        while ((*(haystack + hidx) != '\0') && (*(needle + nidx) != '\0') && hidx < hlen)
        {
            if (*(needle + nidx) != *(haystack + hidx))
            {
                hidx++;
                nidx = 0;
            }
            else
            {
                nidx++;
                hidx++;
                if (nidx == nlen)
                    return hidx - nidx;
            }
        }

        return -1;
    }

    int strpos(const char *haystack, char needle, int offset) const
    {
        if (!haystack || needle == 0)
            return -1;

        int hlen = strlen(haystack);

        if (hlen == 0)
            return -1;

        int hidx = offset;
        while ((*(haystack + hidx) != '\0') && hidx < hlen)
        {
            if (needle == *(haystack + hidx))
                return hidx;
            hidx++;
        }

        return -1;
    }

    int rstrpos(const char *haystack, const char *needle, int offset /* start search from this offset to the left string */) const
    {
        if (!haystack || !needle)
            return -1;

        int hlen = strlen(haystack);
        int nlen = strlen(needle);

        if (hlen == 0 || nlen == 0)
            return -1;

        int hidx = offset;

        if (hidx >= hlen || (size_t)offset == npos)
            hidx = hlen - 1;

        int nidx = nlen - 1;

        while (hidx >= 0)
        {
            if (*(needle + nidx) != *(haystack + hidx))
            {
                hidx--;
                nidx = nlen - 1;
            }
            else
            {
                if (nidx == 0)
                    return hidx + nidx;
                nidx--;
                hidx--;
            }
        }

        return -1;
    }

    int rstrpos(const char *haystack, char needle, int offset /* start search from this offset to the left char */) const
    {
        if (!haystack || needle == 0)
            return -1;

        int hlen = strlen(haystack);

        if (hlen == 0)
            return -1;

        int hidx = offset;

        if (hidx >= hlen || (size_t)offset == npos)
            hidx = hlen - 1;

        while (hidx >= 0)
        {
            if (needle == *(haystack + hidx))
                return hidx;
            hidx--;
        }

        return -1;
    }

    int compareTo(const MB_String &s) const
    {
        if (!buf || !s.buf)
        {
            if (s.buf && s.length() > 0)
                return 0 - *(unsigned char *)s.buf;
            if (buf && length() > 0)
                return *(unsigned char *)buf;
            return 0;
        }
        return strcmp(buf, s.buf);
    }

    unsigned char equals(const MB_String &s2) const
    {
        return (length() == s2.length() && compareTo(s2) == 0);
    }

    unsigned char equals(const char *cstr) const
    {
        if (length() == 0)
            return (cstr == NULL || *cstr == 0);
        if (cstr == NULL)
            return buf[0] == 0;
        return strcmp(buf, cstr) == 0;
    }

    char *ultoa(unsigned long value, char *str, int radix)
    {
        const char *format = NULL;

        switch (radix)
        {
        case 8:
            format = "%o";
            break;
        case 10:
            format = "%ul";
            break;
        case 16:
            format = "%x";
            break;
        }

        if (format == NULL)
            return str;

        int size = sprintf(str, format, value);
        return &str[size];
    }

#if (!defined(ESP32) && !defined(ESP8266) && !defined(ARDUINO_ARCH_STM32) && !defined(ARDUINO_ARCH_SAMD)) || defined(ARDUINO_NANO_RP2040_CONNECT)
    char *ltoa(long value, char *str, int radix)
    {
        const char *format = NULL;

        switch (radix)
        {
        case 8:
            format = "%o";
            break;
        case 10:
            format = "%l";
            break;
        case 16:
            format = "%x";
            break;
        }

        if (format == NULL)
            return str;

        int size = sprintf(str, format, value);
        return &str[size];
    }

    char *utoa(unsigned int value, char *str, int radix)
    {
        const char *format = NULL;

        switch (radix)
        {
        case 8:
            format = "%o";
            break;
        case 10:
            format = "%u";
            break;
        case 16:
            format = "%x";
            break;
        }

        if (format == NULL)
            return str;

        int size = sprintf(str, format, value);
        return &str[size];
    }

    char *itoa(int value, char *str, int radix)
    {
        const char *format = NULL;

        switch (radix)
        {
        case 8:
            format = "%o";
            break;
        case 10:
            format = "%d";
            break;
        case 16:
            format = "%x";
            break;
        }

        if (format == NULL)
            return str;

        int size = sprintf(str, format, value);
        return &str[size];
    }
#endif

    char *buf = NULL;
    size_t bufLen = 0;
};

inline MB_String operator+(const MB_String &lhs, const MB_String &rhs)
{
    MB_String res;
    res.reserve(lhs.length() + rhs.length());
    res += lhs;
    res += rhs;
    return res;
}

#if !defined(__AVR__)

inline MB_String operator+(MB_String &&lhs, const MB_String &rhs)
{
    lhs += rhs;
    return std::move(lhs);
}

inline MB_String operator+(MB_String &lhs, MB_String &&rhs)
{
    lhs += rhs;
    return std::move(lhs);
}

inline MB_String operator+(MB_String &lhs, char rhs)
{
    lhs += rhs;
    return std::move(lhs);
}

inline MB_String operator+(char lhs, MB_String &rhs)
{
    rhs.insert(0, lhs);
    return rhs;
}

inline MB_String operator+(MB_String &&lhs, char rhs)
{
    return std::move(lhs.insert(0, rhs));
}

#endif

#endif