#ifndef SRSTRING_H
#define SRSTRING_H

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

enum eRegExp{
    eRe_notMatched,
    eRe_matched,
    eRe_searched
};

template
class SRStringBase : public std::basic_string
{
public:
    SRStringBase() : std::basic_string() {}
    SRStringBase(TChar c) { this->push_back(c); }
    SRStringBase(const TChar * str) : std::basic_string(str) {}
    SRStringBase(TChar * str)  : std::basic_string(str) {}
    SRStringBase(std::basic_string str) : std::basic_string(str) {}
    SRStringBase(const SRStringBase &str) : std::basic_string(str.c_str()) {}

    template
    static SRStringBase sprintf(const SRStringBase &format, Args ... args)
    {
        size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1;
        std::unique_ptr buf( new char[ size ] );
        snprintf( buf.get(), size, format.c_str(), args ... );
        return SRStringBase( buf.get() );
    }

    template
    void format(const SRStringBase &format, Args ... args)
    {
        this->clear();
        size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1;
        std::unique_ptr buf( new char[ size ] );
        snprintf( buf.get(), size, format.c_str(), args ... );
        this->append(SRStringBase( buf.get() ));
    }
    template
    void args(Args ... args)
    {
        size_t size = snprintf( nullptr, 0, this->c_str(), args ... ) + 1;
        std::unique_ptr buf( new char[ size ] );
        snprintf( buf.get(), size, this->c_str(), args ... );
        this->clear();
        this->append(SRStringBase( buf.get() ));
    }

    const SRStringBase toUpper()
    {
        std::transform(this->begin(), this->end(), this->begin(), ::toupper);
        return SRStringBase(*this);
    }
    const SRStringBase toLower()
    {
        std::transform(this->begin(), this->end(), this->begin(), ::tolower);
        return SRStringBase(*this);
    }

    int toInt(int base = 10)
    {
        int ret;
        try {
            ret = std::stoi(std::basic_string(*this), 0, base);
        } catch (std::exception &) {
            ret = std::stoll(std::basic_string(*this), 0, base);
        }
        return ret;
    }
    unsigned int toUInt(int base = 10)
    {
        unsigned int ret;
        try {
            ret = std::stoi(std::basic_string(*this), 0, base);
        } catch (std::exception &) {
            ret = std::stoull(std::basic_string(*this), 0, base);
        }
        return ret;
    }
    long toLong(int base = 10)
    {
        long ret;
        try {
            ret = std::stol(std::basic_string(*this), 0, base);
        } catch (std::exception &) {
            ret = std::stoll(std::basic_string(*this), 0, base);
        }
        return ret;
    }
    long long toLongLong(int base = 10)
    {
        return std::stoll(std::basic_string(*this), 0, base);
    }
    unsigned long toULong(int base = 10)
    {
        unsigned long ret;
        try {
            ret = std::stoul(std::basic_string(*this), 0, base);
        } catch (std::exception &) {
            ret = std::stoull(std::basic_string(*this), 0, base);
        }
        return ret;
    }
    unsigned long long toULongLong(int base = 10)
    {
        return std::stoull(std::basic_string(*this), 0, base);
    }
    float toFloat()
    {
        float ret;
        try {
            ret = std::stof(std::basic_string(*this));
        } catch (std::exception &) {
            ret = std::stod(std::basic_string(*this));
        }
        return ret;
    }
    double toDouble()
    {
        double ret;
        try {
            ret = std::stod(std::basic_string(*this));
        } catch (std::exception &) {
            ret = std::stold(std::basic_string(*this));
        }
        return ret;
    }
    long double toLongDouble()
    {
        return std::stold(std::basic_string(*this));
    }

    const std::deque> split(TChar delimeter)
    {
        std::basic_stringstream ss(*this);
        std::basic_string item;
        std::deque> splittedStrings;
        while (std::getline(ss, item, delimeter))
        {
            splittedStrings.push_back(item);
        }
        return splittedStrings;
    }

    void push_front(TChar __c)
    {
        this->insert(0, std::basic_string(SRStringBase(__c)));
    }
    void pop_front() noexcept
    {
        this->erase(0, 1);
    }

    const SRStringBase replace(size_t start, size_t len, SRStringBase new_str)
    {
        this->std::basic_string::replace(start, len, std::basic_string(new_str));
        return SRStringBase(*this);
    }
    const SRStringBase replace(SRStringBase old_str, SRStringBase new_str)
    {
        size_t find_pos = 0;
        while (true){
            size_t pos = this->find(std::basic_string(old_str), find_pos);
            if (pos == this->npos)
                break;
            replace(pos, old_str.length(), new_str);
            find_pos = pos + new_str.length();
        }
        return SRStringBase(*this);
    }
    const SRStringBase replace(TChar old_str, SRStringBase new_str)
    {
        size_t find_pos = 0;
        while (true){
            size_t pos = this->find(std::basic_string(SRStringBase(old_str)), find_pos);
            if (pos == this->npos)
                break;
            replace(pos, 1, new_str);
            find_pos = pos + 1;
        }
        return SRStringBase(*this);
    }
    const SRStringBase replace(SRStringBase old_str, TChar new_str)
    {
        size_t find_pos = 0;
        while (true){
            size_t pos = this->find(std::basic_string(old_str), find_pos);
            if (pos == this->npos)
                break;
            replace(pos, old_str.length(), new_str);
            find_pos = pos + new_str.length();
        }
        return SRStringBase(*this);
    }
    const SRStringBase replace(TChar old_str, TChar new_str)
    {
        size_t find_pos = 0;
        while (true){
            size_t pos = this->find(std::basic_string(SRStringBase(old_str)), find_pos);
            if (pos == this->npos)
                break;
            replace(pos, 1, new_str);
            find_pos = pos + 1;
        }
        return SRStringBase(*this);
    }

    const SRStringBase removeFirst(size_t len = 1)
    {
        std::basic_string::erase(0, len);
        return SRStringBase(*this);
    }
    const SRStringBase removeLast(size_t len = 1)
    {
        std::basic_string::erase(this->length() - len, len);
        return SRStringBase(*this);
    }

    const SRStringBase remove(size_t start, size_t len)
    {
        std::basic_string::erase(start, len);
        return SRStringBase(*this);
    }
    const SRStringBase remove(TChar chr)
    {
        replace(chr, "");
        return SRStringBase(*this);
    }
    const SRStringBase remove(SRStringBase str)
    {
        replace(str, "");
        return SRStringBase(*this);
    }

    const SRStringBase removeOne(TChar chr)
    {
        size_t pos = this->find(std::basic_string(SRStringBase(chr)));
        if (pos != this->npos){
            this->std::basic_string::replace(pos, 1, std::basic_string(""));
        }
        return SRStringBase(*this);
    }
    const SRStringBase removeOne(SRStringBase str)
    {
        size_t pos = this->find(std::basic_string(str));
        if (pos != this->npos){
            this->std::basic_string::replace(pos, str.length(), std::basic_string(""));
        }
        return SRStringBase(*this);
    }

    bool isEmpty()
    {
        return (this->length() == 0);
    }

    bool indexOf(const SRStringBase &str)
    {
        return (this->find(std::basic_string(str)) != this->npos);
    }

    eRegExp indexIn(const std::regex &re)
    {
        if (std::regex_match(this->c_str(), cmatch, re))
            return eRegExp::eRe_matched;
        else if (std::regex_search(this->c_str(), cmatch, re))
            return eRegExp::eRe_searched;
        return eRegExp::eRe_notMatched;
    }
    eRegExp indexIn(const SRStringBase &re, std::regex::flag_type flag = std::regex::ECMAScript)
    {
        std::regex _re(re, flag);
        return indexIn(_re);
    }
    const SRStringBase cap(int id)
    {
        if (id >= cmatch.size())
            return "";
        return cmatch[id].str();
    }
    size_t sizeCap()
    {
        return cmatch.size();
    }
    const std::cmatch lastCmatch()
    {
        return cmatch;
    }

    const SRStringBase toUnicode()
    {
        std::wstring_convert> converter;
        if (typeid (TChar) == typeid (wchar_t))
            return SRStringBase(*this);
        return converter.from_bytes(*this);
    }
    const SRStringBase toAnsi()
    {
        std::wstring_convert> converter;
        if (typeid (TChar) == typeid (char))
            return SRStringBase(*this);
        return converter.to_bytes(*this);
    }

    void fromUnicode(const SRStringBase &str)
    {
        std::wstring_convert> converter;
        this->clear();
        if (typeid (TChar) == typeid (wchar_t))
            this->append((TChar*)str.c_str());
        else this->append((TChar*)converter.to_bytes(str).c_str());
    }
    void fromAnsi(const SRStringBase &str)
    {
        std::wstring_convert> converter;
        this->clear();
        if (typeid (TChar) == typeid (char))
            this->append((TChar*)str.c_str());
        else this->append((TChar*)converter.from_bytes(str).c_str());
    }

    static SRStringBase Ansi2Unicode(const char* str)
    {
        std::wstring_convert> converter;
        return converter.from_bytes(str);
    }
    static SRStringBase Unicode2Ansi(const wchar_t* str)
    {
        std::wstring_convert> converter;
        return converter.to_bytes(str);
    }

private:
    std::cmatch cmatch;
};

typedef SRStringBase SRString;
typedef std::deque SRStringList;
typedef SRStringBase SRWstring;
typedef std::deque SRWstringList;

#endif // SRSTRING_H