export module Core.StringJoin;

import Core.Meta;
import Core.Types;

namespace Core {
    template<size_t N>
    struct MergedString {
        char s[N];

        operator const char*() const noexcept {
            return s;
        }
    };

    template<size_t N1, size_t N2>
    consteval auto mergeStringsBase(const char (&a)[N1], const char (&b)[N2]) {
        static_assert(N1 > 0);
        MergedString<N1 + N2 - 1> s;
        for(size_t i = 0; i < N1; i++) {
            s.s[i] = a[i];
        }
        for(size_t i = 0; i < N2; i++) {
            s.s[i + N1 - 1] = b[i];
        }
        return s;
    }

    template<size_t N1, size_t N2>
    consteval auto mergeStringsBase(
        const MergedString<N1>& a, const char (&b)[N2]) {
        return mergeStringsBase<N1, N2>(a.s, b);
    }

    template<size_t N1, size_t N2>
    consteval auto mergeStringsBase(
        const char (&a)[N1], const MergedString<N2>& b) {
        return mergeStringsBase<N1, N2>(a, b.s);
    }

    export template<typename A, typename B>
    consteval auto mergeStrings(const A& a, const B& b) {
        return mergeStringsBase(a, b);
    }

    export template<typename A, typename B, typename... Args>
    consteval auto mergeStrings(const A& a, const B& b, Args&&... args) {
        auto c = mergeStringsBase(a, b);
        return mergeStrings<decltype(c), Args...>(
            c, Core::forward<Args>(args)...);
    }
}