#include <type_traits>
func void format_text2_(s_str_builder<16384>* builder, s_len_str format)
{
    builder->add("%.*s", expand_str(format));
}

// template <int N>
// func void format_text2_(s_str_builder<16384>* builder, s_str_builder<N>* in_builder)
// {
//  s_len_str temp = in_builder->to_len_str();
//  builder->add("%.*s", expand_str(temp));
// }

template <typename t0, typename... targs>
func void format_text2_(s_str_builder<16384>* builder, s_len_str format, t0 val, targs... args)
{
    #define get_next_char(mi) ((mi) < format.count - 1) ? format[mi + 1] : 0;

    for(int i = 0; i < format.count; i += 1) {
        char float_fmt[32] = zero;
        float_fmt[0] = '%';
        float_fmt[1] = 'f';
        char c = format[i];
        char next_c = get_next_char(i);
        if(c == '{') {
            if(is_number(next_c)) {
                i += 1;
                char n = next_c;
                next_c = get_next_char(i);
                if(next_c == 'f') {
                    i += 1;
                    float_fmt[0] = '%';
                    float_fmt[1] = '.';
                    float_fmt[2] = n;
                    float_fmt[3] = 'f';
                    next_c = get_next_char(i);
                }
                else {
                    assert(false);
                }
            }
            if(next_c == '}') {
                if constexpr(is_same<t0, s32>) {
                    builder->add("%i", val);
                }
                else if constexpr(is_same<t0, s_len_str>) {
                    builder->add("%.*s", expand_str(val));
                }
                else if constexpr(is_same<t0, const char*>) {
                    builder->add("%s", val);
                }
                else if constexpr(is_same<t0, char*>) {
                    builder->add("%s", val);
                }
                else if constexpr(is_same<t0, char>) {
                    builder->add("%c", val);
                }
                else if constexpr(is_same<t0, float>) {
                    builder->add(float_fmt, val);
                }
                else if constexpr(is_same<t0, s_v2>) {
                    builder->add("%f, %f", val);
                }
                else if constexpr(is_same<t0, s_v3>) {
                    builder->add("%f, %f, %f", val);
                }
                else if constexpr(is_same<t0, s_v4>) {
                    builder->add("%f, %f, %f, %f", val);
                }
                // nocheckin how to handle str_builder since it has an N template argument??
                else {
                    static_assert(!"Parameter type not handled");
                }

                s_len_str temp_format = str_advance(format, i + 2);
                format_text2_(builder, temp_format, args...);
                return;
            }
        }

        builder->add_char(c);
    }
    #undef get_next_char
}

template <typename... targs>
func s_len_str format_text2(char* format, targs... args)
{
    la_push(&g_string_arena);
    typedef s_str_builder<16384> temp;
    temp* builder = (temp*)la_get(&g_string_arena, sizeof(temp));
    builder->len = 0;
    builder->current_pad = 0;
    builder->num_tabs = 0;
    format_text2_(builder, S(format), args...);
    la_pop(&g_string_arena);
    return builder->to_len_str_alloc(&g_string_arena);
}

template <typename... targs>
func void printf2(char* format, targs... args)
{
    s_len_str str = format_text2(format, args...);
    printf("%.*s\n", expand_str(str));
}