// 简化版 format string 解析状态机
enum class parse_state { normal, align, fill, width, precision, type };

format_spec parse_format_spec(const string& spec) {
    format_spec result;
    parse_state state = parse_state::normal;
    size_t i = 0;
    
    // 处理位置参数
    if (isdigit(spec[i])) {
        result.arg_index = parse_integer(spec, i);
        if (spec[i] == ':') i++;
    }
    
    while (i < spec.size()) {
        char c = spec[i++];
        
        switch (state) {
            case parse_state::normal:
                if (c == '<' || c == '>' || c == '^') {
                    result.align = c;
                    state = parse_state::fill;
                }
                break;
                
            case parse_state::fill:
                result.fill_char = c;
                state = parse_state::normal;
                break;
                
            // ... 其他状态处理
        }
    }
    return result;
}

// 编译时检查（GCC 11+, Clang 13+）
std::format_string<int, double> fmt = "Value: {} and {:.2f}";
//                                    ↑ int    ↑ double

// 编译错误（如果类型不匹配）：
// error: format argument mismatch: expected 'int' but got 'string'
std::format_string<int> bad_fmt = "Value: {} and {:s}";  
//                                         ↑ 期望 int，但提供了 string

// 为自定义类型提供 formatter 特化
struct Point { double x, y; };

// 特化 std::formatter<Point>
template<>
struct std::formatter<Point> {
    // 解析 format spec
    constexpr auto parse(format_parse_context& ctx) {
        return ctx.begin();
    }
    
    // 格式化输出
    auto format(const Point& p, format_context& ctx) const {
        return fmt::format_to(ctx.out(), "({:.2f}, {:.2f})", p.x, p.y);
    }
};

// 使用自定义 formatter
Point origin = {1.234, 5.678};
string result = std::format("Origin: {}", origin);
// 输出: "Origin: (1.23, 5.68)"

// printf 的慢速 locale 查询（每次调用都要查询）
printf("%'.2f", value);  // 需要 localeconv() 查询千位分隔符

// std::format 完全绕过 locale machinery
std::format("{:,.2f}", value);  // 逗号是硬编码的，不查 locale

// 如需真正的 locale 支持，使用 std::locale
std::locale loc = std::locale("");
std::format_to(out, std::formatted_size(loc, "{:L}", value), loc, "{:L}", value);

// printf 格式字符串漏洞（经典攻击）
// 攻击者可以通过 format 参数控制内存读取
printf(user_input);  
// 如果 user_input = "%x %x %x %x"，会打印栈上的 4 个 word

// std::format 完全免疫此类攻击
std::format("{}", user_input);  
// user_input 永远被视为普通字符串参数，不会被解析
// 等价于 printf("%s", user_input)，但更安全

// 游戏引擎日志系统的格式化层（简化实现）
class GameLogger {
    std::pmr::memory_resource* pool_;  // 使用 pmr 减少碎片
    
public:
    void log(const LogLevel& level, const char* fmt, auto&&... args) {
        // 格式化消息（使用栈缓冲区优化小消息）
        char stack_buf[256];
        std::format_to(stack_buf, fmt, std::forward<decltype(args)>(args)...);
        
        // 如果栈缓冲区不够，动态分配
        if (std::formatted_size(fmt, args...) > sizeof(stack_buf)) {
            std::vector<char> dyn_buf(std::formatted_size(fmt, args...));
            std::format_to(dyn_buf.begin(), fmt, std::forward<decltype(args)>(args)...);
            emit(level, dyn_buf.data());
        } else {
            emit(level, stack_buf);
        }
    }
    
    void debug(const char* fmt, auto&&... args) {
        log(LogLevel::DEBUG, fmt, std::forward<decltype(args)>(args)...);
    }
};

// 使用示例 - 在游戏循环中频繁调用
GameLogger logger;
logger.debug("Player {} moved to ({:.1f}, {:.1f})", 
                 player.id(), player.pos().x, player.pos().y);
// 输出: "Player 42 moved to (120.5, 340.2)"