// Expect retcode = 0

// 数值/布尔格式化，写入 ByteBuffer。radix 取值 2..36；uppercase 只影响 10..35 的字母形式。
// 整数转换统一复用 MPA。先在临时缓冲区完成转换，再一次性追加，失败不产生部分输出。

type .{ .Error, .Status, .make } = @import("error.spl");
type .{ .ByteBuffer } = @import("byte_buffer.spl");
type .{ .BigInt, .Bits } = @import("mp.spl");

// 注意：radix 边界直接用字面量。stage1 刻意不做常量求值/折叠，
// 顶层 const 不应用于运行时表达式。
fn valid_radix(radix: u8): bool {
    ret radix >= 2 && radix <= 36;
}

fn append_big_int(out: *ByteBuffer, value: BigInt,
                  radix: u8, uppercase: bool): Status {
    if !valid_radix(radix) { ret .Err(make(.InvalidArgument)); }
    var text = ByteBuffer.new();
    defer { ByteBuffer.drop(&text); }
    match BigInt.format(&text, value, radix, uppercase) {
        .Ok => {},
        .Err(error) => { ret .Err(error); },
    }
    ret ByteBuffer.append(out, ByteBuffer.as_slice(text));
}

fn append_bits(out: *ByteBuffer, value: Bits, signed: bool,
               radix: u8, uppercase: bool): Status {
    var integer = BigInt.zero();
    defer { BigInt.drop(&integer); }
    match Bits.to_big(&integer, value, signed) {
        .Ok => {},
        .Err(error) => { ret .Err(error); },
    }
    ret append_big_int(out, integer, radix, uppercase);
}

fn append_u64(out: *ByteBuffer, value: u64, radix: u8, uppercase: bool): Status {
    var integer = BigInt.zero();
    defer { BigInt.drop(&integer); }
    match BigInt.from_u64(&integer, value) {
        .Ok => {},
        .Err(error) => { ret .Err(error); },
    }
    ret append_big_int(out, integer, radix, uppercase);
}

fn append_i64(out: *ByteBuffer, value: i64, radix: u8, uppercase: bool): Status {
    var integer = BigInt.zero();
    defer { BigInt.drop(&integer); }
    match BigInt.from_i64(&integer, value) {
        .Ok => {},
        .Err(error) => { ret .Err(error); },
    }
    ret append_big_int(out, integer, radix, uppercase);
}

fn append_usize(out: *ByteBuffer, value: usize, radix: u8, uppercase: bool): Status {
    ret append_u64(out, value as u64, radix, uppercase);
}

fn append_isize(out: *ByteBuffer, value: isize, radix: u8, uppercase: bool): Status {
    ret append_i64(out, value as i64, radix, uppercase);
}

fn append_bool(out: *ByteBuffer, value: bool): Status {
    if value { ret ByteBuffer.append(out, "true"); }
    ret ByteBuffer.append(out, "false");
}

// ---- 测试辅助 ----

fn expect_ok(result: Status) {
    match result {
        .Ok => {},
        .Err(error) => { @assert(false, "unexpected fmt error"); },
    }
}

fn expect_invalid(result: Status) {
    match result {
        .Ok => { @assert(false, "expected fmt error"); },
        .Err(error) => {
            match error.kind {
                .InvalidArgument => {},
                _ => { @assert(false, "unexpected fmt error kind"); },
            }
        },
    }
}

fn expect_text(buffer: *ByteBuffer, expected: []u8) {
    var actual = ByteBuffer.as_slice(buffer.*);
    @assert(actual.len == expected.len, "formatted length");
    var i: usize = 0;
    while i < expected.len {
        @assert(actual.ptr[i] == expected.ptr[i], "formatted byte");
        i = i + 1;
    }
}

fn test_unsigned() {
    var b = ByteBuffer.new();
    defer { ByteBuffer.drop(&b); }

    expect_ok(append_u64(&b, 0, 10, false));
    expect_text(&b, "0");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 42, 10, false));
    expect_text(&b, "42");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 1234567890, 10, false));
    expect_text(&b, "1234567890");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 18446744073709551615, 10, false));
    expect_text(&b, "18446744073709551615");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 255, 16, false));
    expect_text(&b, "ff");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 255, 16, true));
    expect_text(&b, "FF");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 4096, 16, false));
    expect_text(&b, "1000");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 170, 2, false));
    expect_text(&b, "10101010");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 35, 36, false));
    expect_text(&b, "z");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 18446744073709551615, 2, false));
    expect_text(&b, "1111111111111111111111111111111111111111111111111111111111111111");
    ByteBuffer.clear(&b);
}

fn test_signed() {
    var b = ByteBuffer.new();
    defer { ByteBuffer.drop(&b); }

    expect_ok(append_i64(&b, 0, 10, false));
    expect_text(&b, "0");
    ByteBuffer.clear(&b);

    expect_ok(append_i64(&b, -123, 10, false));
    expect_text(&b, "-123");
    ByteBuffer.clear(&b);

    expect_ok(append_i64(&b, 9223372036854775807, 10, false));
    expect_text(&b, "9223372036854775807");
    ByteBuffer.clear(&b);

    expect_ok(append_i64(&b, -9223372036854775808, 10, false));
    expect_text(&b, "-9223372036854775808");
    ByteBuffer.clear(&b);

    expect_ok(append_isize(&b, -16, 16, false));
    expect_text(&b, "-10");
    ByteBuffer.clear(&b);

    expect_ok(append_u64(&b, 48879, 16, true));
    expect_text(&b, "BEEF");
    ByteBuffer.clear(&b);
}

fn test_usize_bool_and_errors() {
    var b = ByteBuffer.new();
    defer { ByteBuffer.drop(&b); }

    expect_ok(append_usize(&b, 1000 as usize, 10, false));
    expect_text(&b, "1000");
    ByteBuffer.clear(&b);

    expect_ok(append_bool(&b, true));
    expect_text(&b, "true");
    ByteBuffer.clear(&b);

    expect_ok(append_bool(&b, false));
    expect_text(&b, "false");
    ByteBuffer.clear(&b);

    expect_invalid(append_u64(&b, 1, 0, false));
    expect_invalid(append_u64(&b, 1, 1, false));
    expect_invalid(append_u64(&b, 1, 37, false));
    expect_invalid(append_i64(&b, -1, 0, false));
    @assert(ByteBuffer.size(b) == 0, "invalid radix writes nothing");

    expect_ok(ByteBuffer.append(&b, "prefix"));
    expect_invalid(append_i64(&b, -123, 1, false));
    expect_text(&b, "prefix");
}

fn test_mpa_integer_formatting() {
    var b = ByteBuffer.new();
    defer { ByteBuffer.drop(&b); }

    var huge = BigInt.zero();
    defer { BigInt.drop(&huge); }
    expect_ok(BigInt.parse(&huge, "1234567890123456789012345678901234567890", 10));
    expect_ok(append_big_int(&b, huge, 10, false));
    expect_text(&b, "1234567890123456789012345678901234567890");
    ByteBuffer.clear(&b);

    expect_ok(BigInt.parse(&huge, "-ffffffffffffffffffffffffffffffff", 16));
    expect_ok(append_big_int(&b, huge, 16, true));
    expect_text(&b, "-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
    ByteBuffer.clear(&b);

    var raw = BigInt.zero();
    defer { BigInt.drop(&raw); }
    expect_ok(BigInt.from_u64(&raw, 255));
    var bits: Bits = undefined;
    match Bits.new(8) {
        .Ok(value) => { bits = value; },
        .Err(error) => { @assert(false, "Bits construction"); },
    }
    defer { Bits.drop(&bits); }
    expect_ok(Bits.from_big_checked(&bits, raw, 8, false));

    expect_ok(append_bits(&b, bits, false, 10, false));
    expect_text(&b, "255");
    ByteBuffer.clear(&b);
    expect_ok(append_bits(&b, bits, true, 10, false));
    expect_text(&b, "-1");
}

fn test_composition_and_growth() {
    var b = ByteBuffer.new();
    defer { ByteBuffer.drop(&b); }

    expect_ok(ByteBuffer.append(&b, "x="));
    expect_ok(append_i64(&b, -42, 10, false));
    expect_ok(ByteBuffer.append(&b, " hex="));
    expect_ok(append_u64(&b, 255, 16, false));
    expect_ok(ByteBuffer.append(&b, " ok="));
    expect_ok(append_bool(&b, true));
    expect_text(&b, "x=-42 hex=ff ok=true");
    ByteBuffer.clear(&b);

    // 反复写入触发 ByteBuffer 扩容，校验累积内容。
    var i: i32 = 0;
    while i < 200 {
        expect_ok(append_i64(&b, i as i64, 10, false));
        expect_ok(ByteBuffer.append_byte(&b, ',')); // ','
        i = i + 1;
    }
    expect_ok(append_i64(&b, 200, 10, false));
    @assert(ByteBuffer.size(b) > 0, "growth content");
    var s = ByteBuffer.as_slice(b);
    @assert(s.ptr[0] == '0', "starts with 0");
    @assert(s.ptr[1] == ',', "0 then comma");
}

fn main() {
    test_unsigned();
    test_signed();
    test_usize_bool_and_errors();
    test_mpa_integer_formatting();
    test_composition_and_growth();
}