module;

export module Core.ToString;

import Core.Math;
import Core.Meta;
import Core.Types;

export namespace Core {
    size_t toString(signed char v, char* s, size_t n);
    size_t toString(char v, char* s, size_t n);
    size_t toString(short v, char* s, size_t n);
    size_t toString(int v, char* s, size_t n);
    size_t toString(long v, char* s, size_t n);
    size_t toString(long long v, char* s, size_t n);
    size_t toString(unsigned char v, char* s, size_t n);
    size_t toString(unsigned short v, char* s, size_t n);
    size_t toString(unsigned int v, char* s, size_t n);
    size_t toString(unsigned long v, char* s, size_t n);
    size_t toString(unsigned long long v, char* s, size_t n);
    size_t toString(float v, char* s, size_t n);
    size_t toString(double v, char* s, size_t n);
    size_t toString(const char* v, char* s, size_t n);
    size_t toString(char* v, char* s, size_t n);
    size_t toString(const unsigned char* v, char* s, size_t n);
    size_t toString(unsigned char* v, char* s, size_t n);
    size_t toString(bool v, char* s, size_t n);

    template<typename T>
    size_t toString(const T& t, char* s, size_t n);

    template<typename T>
    void addString(const T& t, char*& s, size_t& n, size_t& total) {
        size_t w = toString(t, s, n);
        total += w;
        w = Core::min(n, w);
        s += w;
        n -= w;
    }

    template<typename T>
    size_t toString(const T& t, char* s, size_t n) {
        if constexpr(Core::Iterable<T>) {
            size_t total = 0;
            addString("[", s, n, total);
            auto current = t.begin();
            auto end = t.end();
            if(current != end) {
                addString(*current, s, n, total);
                ++current;
            }
            while(current != end) {
                addString(", ", s, n, total);
                addString(*current, s, n, total);
                ++current;
            }
            addString("]", s, n, total);
            return total;
        } else {
            return t.toString(s, n);
        }
    }

    size_t copyFormatUntil(const char*& format, char*& s, size_t& n);

    template<typename T, typename... Args>
    void formatR(
        const char*& format, char*& s, size_t& n, size_t& total, const T& t,
        Args&&... args) {
        total += copyFormatUntil(format, s, n);
        addString(t, s, n, total);
        if constexpr(sizeof...(args) > 0) {
            formatR(format, s, n, total, Core::forward<Args>(args)...);
        }
    }

    template<typename... Args>
    size_t formatBuffer(char* s, size_t n, const char* format, Args&&... args) {
        if constexpr(sizeof...(args) > 0) {
            size_t total = 0;
            formatR(format, s, n, total, Core::forward<Args>(args)...);
            return total + toString(format, s, n);
        }
        return copyFormatUntil(format, s, n);
    }
}