StringUtil.hpp

#pragma once

#include <string>
#include <iostream>
#include <sstream>

#include <samchon/WeakString.hpp>
#include <samchon/IndexPair.hpp>
#include <samchon/library/Math.hpp>

namespace samchon
{
namespace library
{
    class StringUtil
    {
    public:
        /* ----------------------------------------------------------------------
            SUBSTITUTE
        ---------------------------------------------------------------------- */
        template <typename T, typename ... _Args>
        static auto substitute(const std::string &format,
            const T& val, const _Args& ... args) -> std::string
        {
            std::string &res = _substitute(format, val);

            return StringUtil::substitute(res, args...);
        };
        template <typename T> static auto substitute(const std::string &format, const T& val) -> std::string
        {
            return _substitute(format, val);
        };

        template <typename T, typename ... _Args >
        static auto substituteSQL(const std::string &format,
            const T& value, const _Args& ... args) -> std::string
        {
            std::string &res = _substituteSQL(format, value);
            return StringUtil::substituteSQL(res, args...);
        };
        template <typename T> static auto substituteSQL(const std::string &format, const T& value) -> std::string
        {
            return _substituteSQL(format, value);
        };

    protected:
        template <typename T> static auto _substitute(const std::string &format, const T& value) -> std::string
        {
            std::vector<std::string> &parenthesisArray = betweens(format, { (char)'{' }, { (char)'}' });
            std::vector<long> vec;

            for (auto it = parenthesisArray.begin(); it != parenthesisArray.end(); it++)
                if (isNumeric(*it) == true)
                    vec.push_back(stoi(*it));

            size_t index = (size_t)Math::minimum(vec).getValue();

            //replaceAll
            std::string &to = toString(value);
            return replaceAll(format, "{" + std::to_string(index) + "}", to);
        };

        template <typename T> static auto _substituteSQL(const std::string &format, const T& value) -> std::string
        {
            std::vector<std::string> &parenthesisArray = betweens(format, "{", "}");
            std::vector<long> vec;

            for (auto it = parenthesisArray.begin(); it != parenthesisArray.end(); it++)
                if (isNumeric(*it) == true)
                    vec.push_back(stoi(*it));

            size_t index = (size_t)Math::minimum(vec).getValue();

            //replaceAll
            std::string &to = toSQL(value);
            return replaceAll(format, "{" + std::to_string(index) + "}", to);
        };

        /* ----------------------------------------------------------------------
            SUBSTITUTE -> TO_STRING
        ---------------------------------------------------------------------- */
        template <typename T>
        static auto toString(const T &val) -> std::string
        {
            return std::to_string(val);
        };
        template<> static auto toString(const std::string &str) -> std::string
        {
            return str;
        };
        template<> static auto toString(const WeakString &str) -> std::string
        {
            return str.str();
        };
        static auto toString(const char *ptr) -> std::string
        {
            return ptr;
        };

        template <typename T>
        static auto toSQL(const T &val) -> std::string
        {
            if (val == INT_MIN)
                return "NULL";

            return std::to_string(val);
        };
        template<> static auto toSQL(const bool &flag) -> std::string
        {
            return std::to_string(flag);
        };
        template<> static auto toSQL(const char &val) -> std::string
        {
            return toSQL(std::string({ val }));
        };
        template<> static auto toSQL(const std::string &str) -> std::string
        {
            return toSQL(WeakString(str));
        };
        template<> static auto toSQL(const WeakString &wstr) -> std::string
        {
            if (wstr.empty() == true)
                return "NULL";
            else
            {
                if (wstr.find("'") != std::string::npos)
                    return "'" + wstr.replaceAll("'", "''") + "'";
                else
                    return "'" + wstr.str() + "'";
            }
        };
        static auto toSQL(const char *ptr) -> std::string
        {
            return toSQL(std::string(ptr));
        };

    public:
        /* ----------------------------------------------------------------------
            NUMBER-FORMAT
                IN MONETARY UNIT, ADD DELIMETER ','
                COLOR-FORMAT

            POSITIVE NUMBER IS RED,
                NEGATIVE NUMBER IS BLUE
                ZERO IS BLACK
        ---------------------------------------------------------------------- */
        static auto isNumeric(const std::string &str) -> bool
        {
            try
            {
                stoi(str);
                //stod( replaceAll(str, ",", "") );
            }
            catch (const std::exception &)
            {
                return false;
            }
            catch (...)
            {
                return false;
            }

            return true;
        };

        static auto toNumber(const std::string &str) -> double
        {
            std::string &numStr = replaceAll(str, ",", "");

            return stod(numStr);
        };

        static auto numberFormat(double val, int precision = 2) -> std::string
        {
            std::string str;

            // FIRST, DO ROUND-OFF
            val = round(val * pow(10, precision));
            val = val / pow(10, precision);

            // SEPERATE NUMBERS
            bool is_negative = (val < 0);
            unsigned long long natural = (unsigned long long)abs(val);
            double fraction = abs(val) - (unsigned long long)abs(val);

            // NATURAL NUMBER
            if (natural == 0)
                str = "0";
            else
            {
                // NOT ZERO
                size_t cipher_count = (size_t)log10(natural) + 1;

                for (size_t i = 0; i <= cipher_count; i++)
                {
                    size_t cipher = natural % (size_t)pow(10, i + 1);
                    cipher = (size_t)(cipher / pow(10, i));

                    if (i == cipher_count && cipher == 0)
                        continue;

                    // IS MULTIPLIER OF 3
                    if (i > 0 && i % 3 == 0)
                        str = "," + str;

                    // PUSH FRONT TO THE STRING
                    str = std::to_string(cipher) + str;
                }
            }

            // NEGATIVE SIGN
            if (is_negative == true)
                str = "-" + str;

            // ADD FRACTION
            if (precision > 0 && fraction != 0)
            {
                fraction = (double)(unsigned long long)round(fraction * pow(10, precision));
                size_t zeros = precision - (size_t)log10(fraction) - 1;

                str += "." + std::string(zeros, '0') + std::to_string((unsigned long long)fraction);
            }
            return str;
        };

        static auto percentFormat(double val, int precision = 2) -> std::string
        {
            if (val == INT_MIN)
                return "";
            return numberFormat(val * 100, precision) + "%";
        };

        static auto colorNumberFormat(double value, int precision = 2, double delimiter = 0.0) -> std::string
        {
            std::string color;

            if (value > delimiter)          color = "red";
            else if (value == delimiter)    color = "black";
            else                            color = "blue";

            return substitute
            (
                "<font color='{1}'>{2}</font>",
                color,
                numberFormat(value, precision)
            );
        };

        static auto colorPercentFormat(double value, int precision = 2, double delimiter = 0.0) -> std::string
        {
            std::string color;

            if (value > delimiter)          color = "red";
            else if (value == delimiter)    color = "black";
            else                            color = "blue";

            return substitute
            (
                "<font color='{1}'>{2}</font>",
                color,
                percentFormat(value, precision)
            );
        };

        /* ----------------------------------------------------------------------
            TRIM -> WITH LTRIM & RTRIM
                IT'S RIGHT, THE TRIM OF ORACLE
        ---------------------------------------------------------------------- */
        static auto trim(const std::string &val, const std::vector<std::string> &delims) -> std::string
        {
            return WeakString(val).trim(delims).str();
        };

        static auto ltrim(const std::string &val, const std::vector<std::string> &delims) -> std::string
        {
            return WeakString(val).ltrim(delims).str();
        };

        static auto rtrim(const std::string &val, const std::vector<std::string> &delims) -> std::string
        {
            return WeakString(val).rtrim(delims).str();
        };

        static auto trim(const std::string &str) -> std::string
        {
            return WeakString(str).trim().str();
        };
        static auto ltrim(const std::string &str) -> std::string
        {
            return WeakString(str).ltrim().str();
        };
        static auto rtrim(const std::string &str) -> std::string
        {
            return WeakString(str).rtrim().str();
        };

        static auto trim(const std::string &str, const std::string &delim) -> std::string
        {
            return WeakString(str).trim(delim).str();
        };
        static auto ltrim(const std::string &str, const std::string &delim) -> std::string
        {
            return WeakString(str).ltrim(delim).str();
        };
        static auto rtrim(const std::string &str, const std::string &delim) -> std::string
        {
            return WeakString(str).rtrim(delim).str();
        };

        /* ----------------------------------------------------------------------
            EXTRACTORS
        ---------------------------------------------------------------------- */
        static auto finds(const std::string &str,
            const std::vector<std::string> &delims, size_t startIndex = 0) -> IndexPair<std::string>
        {
            IndexPair<WeakString> &iPair = WeakString(str).finds(delims, startIndex);

            return { iPair.get_index(), iPair.getValue().str() };
        };

        static auto rfinds(const std::string &str,
            const std::vector<std::string> &delims, size_t endIndex = SIZE_MAX) -> IndexPair<std::string>
        {
            IndexPair<WeakString> &iPair = WeakString(str).rfinds(delims, endIndex);

            return { iPair.get_index(), iPair.getValue().str() };
        };

        static auto substring(const std::string &str,
            size_t startIndex, size_t endIndex = SIZE_MAX) -> std::string
        {
            return WeakString(str).substring(startIndex, endIndex).str();
        };

        static auto between(const std::string &str,
            const std::string &start = "", const std::string &end = "") -> std::string
        {
            return WeakString(str).between(start, end).str();
        };

        //TAB
        static auto addTab(const std::string &str, size_t n = 1) -> std::string
        {
            std::vector<std::string> &lines = split(str, "\n");

            std::string val;
            std::string tab;
            size_t i;

            val.reserve(val.size() + lines.size());
            tab.reserve(n);

            for (i = 0; i < n; i++)
                tab += "\t";

            for (i = 0; i < lines.size(); i++)
                val.append(tab + lines[i] + ((i == lines.size() - 1) ? "" : "\n"));

            return val;
        };

        //MULTIPLE STRINGS
        static auto split(const std::string &str, const std::string &delim) -> std::vector<std::string>
        {
            std::vector<WeakString> &arr = WeakString(str).split(delim);

            std::vector<std::string> resArray(arr.size());
            for (size_t i = 0; i < arr.size(); i++)
                resArray[i] = move(arr[i].str());

            return resArray;
        };

        static auto betweens
            (
                const std::string &str,
                const std::string &start = "", const std::string &end = ""
            ) -> std::vector<std::string>
        {
            std::vector<WeakString> &arr = WeakString(str).betweens(start, end);

            std::vector<std::string> resArray(arr.size());
            for (size_t i = 0; i < arr.size(); i++)
                resArray[i] = move(arr[i].str());

            return resArray;
        };

        /* ----------------------------------------------------------------------
            REPLACERS
        ---------------------------------------------------------------------- */
        //ALPHABET-CONVERSION
        static auto toLowerCase(const std::string &str) -> std::string
        {
            return WeakString(str).toLowerCase();
        };

        static auto yoUpperCase(const std::string &str) -> std::string
        {
            return WeakString(str).yoUpperCase();
        };

        static auto replaceAll
            (
                const std::string &str, 
                const std::string &before, const std::string &after
            ) -> std::string
        {
            return WeakString(str).replaceAll(before, after);
        };

        static auto replaceAll(const std::string &str,
            const std::vector<std::pair<std::string, std::string>> &pairs) -> std::string
        {
            return WeakString(str).replaceAll(pairs);
        };

        static auto removeHTMLSpaces(const std::string &str) -> std::string
        {
            std::vector<std::pair<std::string, std::string>> pairs =
            {
                { "&nbsp;", " " },
                { "\t", " " },
                { "  ", " " }
            };
            return replaceAll(str, pairs);
        };
    };
};
};