prototext 0.2.0

// SPDX-FileCopyrightText: 2025-2026 Frederic Ruget <fred@atlant.is> (GitHub: @douzebis)
// SPDX-FileCopyrightText: 2025-2026 THALES CLOUD SECURISE SAS
//
// SPDX-License-Identifier: MIT

use std::path::{Path, PathBuf};

use prost::Message as ProstMessage;
use prototext_core::{parse_schema, render_as_bytes, render_as_text, RenderOpts};

// ── Fixture helpers ───────────────────────────────────────────────────────────

fn repo_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).to_path_buf()
}

fn schema_path(schema_rel: &str) -> PathBuf {
    // .pb schemas are generated by build.rs into OUT_DIR (not committed to git).
    let generated = ["descriptor.pb", "knife.pb", "enum_collision.pb"];
    if let Some(name) = generated
        .iter()
        .find(|&&n| schema_rel == format!("fixtures/schemas/{n}"))
    {
        return PathBuf::from(env!("OUT_DIR")).join(name);
    }
    repo_root().join(schema_rel)
}

fn load_schema(schema_rel: &str, message: &str) -> prototext_core::ParsedSchema {
    let path = schema_path(schema_rel);
    let bytes = std::fs::read(&path)
        .unwrap_or_else(|e| panic!("cannot read schema {}: {e}", path.display()));
    parse_schema(&bytes, message)
        .unwrap_or_else(|e| panic!("cannot parse schema {schema_rel}:{message}: {e}"))
}

// ── Helpers ───────────────────────────────────────────────────────────────────

fn enum_schema() -> prototext_core::ParsedSchema {
    load_schema("fixtures/schemas/enum_collision.pb", "EnumCollision")
}

// ── §7 Enum rendering tests ───────────────────────────────────────────────────

#[test]
fn enum_known_value_renders_symbolic_name() {
    // EnumCollision field 2 'color' (Color enum): wire value 1 = GREEN.
    // Tag: field 2, wire type varint = 0x10. Value: 0x01.
    let wire = vec![0x10, 0x01];
    let schema = enum_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        text_str.contains("GREEN"),
        "expected symbolic name GREEN in: {text_str}"
    );
    assert!(
        text_str.contains("Color(1)"),
        "expected Color(1) in annotation: {text_str}"
    );
}

#[test]
fn enum_unknown_value_renders_numeric_with_enum_unknown() {
    // EnumCollision field 2 'color' (Color enum): wire value 99 — not in enum.
    let wire = vec![0x10, 0x63]; // field 2 varint, value 99
    let schema = enum_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        text_str.contains("99"),
        "expected numeric 99 in: {text_str}"
    );
    assert!(
        text_str.contains("ENUM_UNKNOWN"),
        "expected ENUM_UNKNOWN in annotation: {text_str}"
    );
}

#[test]
fn packed_enum_renders_symbolic_names() {
    // EnumCollision field 5 'colors_pk' (repeated Color, packed).
    // Tag: field 5, wire type LEN = (5<<3)|2 = 0x2A. Payload: varint 1 (GREEN), varint 2 (BLUE).
    // Per-line format: each element on its own line with per-element enum annotation.
    let wire = vec![0x2A, 0x02, 0x01, 0x02]; // tag, len=2, GREEN=1, BLUE=2
    let schema = enum_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        text_str.contains("GREEN"),
        "expected GREEN in packed: {text_str}"
    );
    assert!(
        text_str.contains("BLUE"),
        "expected BLUE in packed: {text_str}"
    );
    // Per-line format: each element has its own Color(N) annotation.
    assert!(
        text_str.contains("Color(1)"),
        "expected Color(1) per-element annotation: {text_str}"
    );
    assert!(
        text_str.contains("Color(2)"),
        "expected Color(2) per-element annotation: {text_str}"
    );
    assert!(
        text_str.contains("pack_size: 2"),
        "expected pack_size: 2 on first element: {text_str}"
    );
}

#[test]
fn enum_annotation_roundtrips_wire() {
    // EnumCollision field 2 'color' = GREEN (1).
    let wire = vec![0x10, 0x01];
    let schema = enum_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let wire2 = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(wire2, wire, "enum annotation must round-trip byte-for-byte");
}

#[test]
fn no_annotations_omits_unknown_fields() {
    // Unknown field (no schema): wire type varint, field 99.
    let wire = vec![0xb8, 0x06, 0x01]; // field 99, varint, value 1
    let schema = enum_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        !text_str.contains("99"),
        "unknown field should be omitted without annotations: {text_str}"
    );
}

#[test]
fn enum_named_float_roundtrip_is_varint() {
    // EnumCollision field 1 'kind' (enum float): value 1 = FLOAT_ONE.
    // Wire: tag field 1 varint = 0x08, value 0x01. Total 2 bytes.
    let wire = vec![0x08, 0x01];
    let schema = enum_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let wire2 = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        wire2, wire,
        "enum named 'float' must round-trip as varint (2 bytes), not fixed32 (5 bytes)"
    );
    assert_eq!(
        wire2.len(),
        2,
        "re-encoded wire must be 2 bytes (varint), not 5 (fixed32)"
    );
}

// ── §8 NaN encoding tests ────────────────────────────────────────────────────

fn knife_schema() -> prototext_core::ParsedSchema {
    load_schema("fixtures/schemas/knife.pb", "SwissArmyKnife")
}

// Wire helpers: encode a single scalar field.
//   floatOp  = field 22, wire type FIXED32 (5) → tag = (22 << 3) | 5 = 0xB5 0x01
//   doubleOp = field 21, wire type FIXED64 (1) → tag = (21 << 3) | 1 = 0xA9 0x01
fn float_wire(bits: u32) -> Vec<u8> {
    let mut v = vec![0xB5, 0x01]; // tag for floatOp (field 22, FIXED32)
    v.extend_from_slice(&bits.to_le_bytes());
    v
}

fn double_wire(bits: u64) -> Vec<u8> {
    let mut v = vec![0xA9, 0x01]; // tag for doubleOp (field 21, FIXED64)
    v.extend_from_slice(&bits.to_le_bytes());
    v
}

// Wire helpers: packed repeated fields.
//   floatPk  = field 82, wire type LEN (2) → tag = (82 << 3) | 2 = 0x92 0x05 (varint)
//   doublePk = field 81, wire type LEN (2) → tag = (81 << 3) | 2 = 0x8A 0x05 (varint)
fn float_packed_wire(bits: &[u32]) -> Vec<u8> {
    let payload: Vec<u8> = bits.iter().flat_map(|b| b.to_le_bytes()).collect();
    let mut v = vec![0x92, 0x05]; // tag
    v.push(payload.len() as u8);
    v.extend_from_slice(&payload);
    v
}

fn double_packed_wire(bits: &[u64]) -> Vec<u8> {
    let payload: Vec<u8> = bits.iter().flat_map(|b| b.to_le_bytes()).collect();
    let mut v = vec![0x8A, 0x05]; // tag
    v.push(payload.len() as u8);
    v.extend_from_slice(&payload);
    v
}

// f32 canonical quiet NaN: 0x7FC00000
const F32_CANONICAL_NAN: u32 = 0x7FC00000;
// f32 non-canonical NaNs used in tests
const F32_SIGNALING_NAN: u32 = 0x7F800001; // signaling NaN, payload 1
const F32_SIGNED_NAN: u32 = 0xFFC00000; // quiet NaN with sign bit set
const F32_PAYLOAD_NAN: u32 = 0x7FC0CAFE; // quiet NaN with custom payload

// f64 canonical quiet NaN: 0x7FF8000000000000
const F64_CANONICAL_NAN: u64 = 0x7FF8000000000000;
// f64 non-canonical NaNs used in tests
const F64_SIGNALING_NAN: u64 = 0x7FF0000000000001; // signaling NaN, payload 1
const F64_SIGNED_NAN: u64 = 0xFFF8000000000000; // quiet NaN with sign bit set
const F64_PAYLOAD_NAN: u64 = 0x7FF800000BADC0DE; // quiet NaN with custom payload

#[test]
fn float_canonical_nan_renders_bare_nan() {
    let wire = float_wire(F32_CANONICAL_NAN);
    let schema = knife_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        text_str.contains("nan"),
        "expected bare 'nan' for canonical NaN, got: {text_str}"
    );
    assert!(
        !text_str.contains("nan("),
        "canonical NaN must not have a modifier, got: {text_str}"
    );
}

#[test]
fn float_noncanonical_nan_renders_with_modifier() {
    // With annotations=false non-canonical NaN renders as bare `nan` (no modifier in value).
    // The modifier moves to the annotation (nan_bits: 0x…) which is only present with annotations=true.
    for &bits in &[F32_SIGNALING_NAN, F32_SIGNED_NAN, F32_PAYLOAD_NAN] {
        let wire = float_wire(bits);
        let schema = knife_schema();
        // annotations=false: bare `nan` only
        let text_no_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let text_no_ann_str = String::from_utf8(text_no_ann).unwrap();
        assert!(
            text_no_ann_str.contains("nan"),
            "bits 0x{:08x}: expected 'nan' in no-annotations output: {text_no_ann_str}",
            bits
        );
        assert!(
            !text_no_ann_str.contains("nan("),
            "bits 0x{:08x}: non-canonical NaN must not appear as nan(…) in value: {text_no_ann_str}",
            bits
        );
        // annotations=true: nan_bits modifier in annotation
        let text_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let text_ann_str = String::from_utf8(text_ann).unwrap();
        let expected_mod = format!("nan_bits: 0x{:08x}", bits);
        assert!(
            text_ann_str.contains(&expected_mod),
            "bits 0x{:08x}: expected '{}' in annotation: {text_ann_str}",
            bits,
            expected_mod
        );
    }
}

#[test]
fn float_noncanonical_nan_roundtrips() {
    for &bits in &[F32_SIGNALING_NAN, F32_SIGNED_NAN, F32_PAYLOAD_NAN] {
        let wire = float_wire(bits);
        let schema = knife_schema();
        let text = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let wire2 = render_as_bytes(
            &text,
            RenderOpts {
                assume_binary: false,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            wire2, wire,
            "float NaN 0x{:08x} must round-trip bit-exact",
            bits
        );
    }
}

#[test]
fn double_canonical_nan_renders_bare_nan() {
    let wire = double_wire(F64_CANONICAL_NAN);
    let schema = knife_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        text_str.contains("nan"),
        "expected bare 'nan' for canonical NaN, got: {text_str}"
    );
    assert!(
        !text_str.contains("nan("),
        "canonical NaN must not have a modifier, got: {text_str}"
    );
}

#[test]
fn double_noncanonical_nan_renders_with_modifier() {
    // With annotations=false non-canonical NaN renders as bare `nan`.
    // The modifier moves to the annotation (nan_bits: 0x…) with annotations=true.
    for &bits in &[F64_SIGNALING_NAN, F64_SIGNED_NAN, F64_PAYLOAD_NAN] {
        let wire = double_wire(bits);
        let schema = knife_schema();
        // annotations=false: bare `nan` only
        let text_no_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let text_no_ann_str = String::from_utf8(text_no_ann).unwrap();
        assert!(
            text_no_ann_str.contains("nan"),
            "bits 0x{:016x}: expected 'nan' in no-annotations output: {text_no_ann_str}",
            bits
        );
        assert!(
            !text_no_ann_str.contains("nan("),
            "bits 0x{:016x}: non-canonical NaN must not appear as nan(…) in value: {text_no_ann_str}",
            bits
        );
        // annotations=true: nan_bits modifier in annotation
        let text_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let text_ann_str = String::from_utf8(text_ann).unwrap();
        let expected_mod = format!("nan_bits: 0x{:016x}", bits);
        assert!(
            text_ann_str.contains(&expected_mod),
            "bits 0x{:016x}: expected '{}' in annotation: {text_ann_str}",
            bits,
            expected_mod
        );
    }
}

#[test]
fn double_noncanonical_nan_roundtrips() {
    for &bits in &[F64_SIGNALING_NAN, F64_SIGNED_NAN, F64_PAYLOAD_NAN] {
        let wire = double_wire(bits);
        let schema = knife_schema();
        let text = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let wire2 = render_as_bytes(
            &text,
            RenderOpts {
                assume_binary: false,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            wire2, wire,
            "double NaN 0x{:016x} must round-trip bit-exact",
            bits
        );
    }
}

#[test]
fn float_packed_noncanonical_nan_renders_with_modifier() {
    // packed floatPk: canonical NaN, signaling NaN, payload NaN.
    // Per-line format: each element on its own line; non-canonical NaN → nan_bits: 0x… in annotation.
    let wire = float_packed_wire(&[F32_CANONICAL_NAN, F32_SIGNALING_NAN, F32_PAYLOAD_NAN]);
    let schema = knife_schema();
    // annotations=false: all NaN values render as bare `nan` (no per-element annotation).
    let text_no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_no_ann_str = String::from_utf8(text_no_ann).unwrap();
    assert!(
        text_no_ann_str.contains("nan"),
        "expected bare nan in no-annotations packed output, got: {text_no_ann_str}"
    );
    assert!(
        !text_no_ann_str.contains("nan("),
        "packed NaN must not appear as nan(…) without annotations: {text_no_ann_str}"
    );
    // annotations=true: nan_bits modifier on non-canonical element lines.
    let text_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_ann_str = String::from_utf8(text_ann).unwrap();
    assert!(
        text_ann_str.contains(&format!("nan_bits: 0x{:08x}", F32_SIGNALING_NAN)),
        "expected nan_bits for signaling NaN in annotation: {text_ann_str}"
    );
    assert!(
        text_ann_str.contains(&format!("nan_bits: 0x{:08x}", F32_PAYLOAD_NAN)),
        "expected nan_bits for payload NaN in annotation: {text_ann_str}"
    );
}

#[test]
fn float_packed_noncanonical_nan_roundtrips() {
    let wire = float_packed_wire(&[F32_CANONICAL_NAN, F32_SIGNALING_NAN, F32_PAYLOAD_NAN]);
    let schema = knife_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let wire2 = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        wire2, wire,
        "packed float NaN array must round-trip bit-exact"
    );
}

#[test]
fn double_packed_noncanonical_nan_renders_with_modifier() {
    // Per-line format; non-canonical NaN → nan_bits: 0x… in annotation.
    let wire = double_packed_wire(&[F64_CANONICAL_NAN, F64_SIGNALING_NAN, F64_PAYLOAD_NAN]);
    let schema = knife_schema();
    // annotations=false: all NaN values render as bare `nan`.
    let text_no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_no_ann_str = String::from_utf8(text_no_ann).unwrap();
    assert!(
        text_no_ann_str.contains("nan"),
        "expected bare nan in no-annotations packed output, got: {text_no_ann_str}"
    );
    assert!(
        !text_no_ann_str.contains("nan("),
        "packed double NaN must not appear as nan(…) without annotations: {text_no_ann_str}"
    );
    // annotations=true: nan_bits modifier on non-canonical element lines.
    let text_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_ann_str = String::from_utf8(text_ann).unwrap();
    assert!(
        text_ann_str.contains(&format!("nan_bits: 0x{:016x}", F64_SIGNALING_NAN)),
        "expected nan_bits for signaling NaN in annotation: {text_ann_str}"
    );
    assert!(
        text_ann_str.contains(&format!("nan_bits: 0x{:016x}", F64_PAYLOAD_NAN)),
        "expected nan_bits for payload NaN in annotation: {text_ann_str}"
    );
}

#[test]
fn double_packed_noncanonical_nan_roundtrips() {
    let wire = double_packed_wire(&[F64_CANONICAL_NAN, F64_SIGNALING_NAN, F64_PAYLOAD_NAN]);
    let schema = knife_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let wire2 = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        wire2, wire,
        "packed double NaN array must round-trip bit-exact"
    );
}

#[test]
fn float_packed_all_nan_variants_roundtrip() {
    // All four NaN variants together in one packed array.
    let wire = float_packed_wire(&[
        F32_CANONICAL_NAN,
        F32_SIGNALING_NAN,
        F32_SIGNED_NAN,
        F32_PAYLOAD_NAN,
    ]);
    let schema = knife_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let wire2 = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        wire2, wire,
        "packed float all-NaN-variants must round-trip bit-exact"
    );
}

#[test]
fn double_packed_all_nan_variants_roundtrip() {
    // All four NaN variants together in one packed array.
    let wire = double_packed_wire(&[
        F64_CANONICAL_NAN,
        F64_SIGNALING_NAN,
        F64_SIGNED_NAN,
        F64_PAYLOAD_NAN,
    ]);
    let schema = knife_schema();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let wire2 = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        wire2, wire,
        "packed double all-NaN-variants must round-trip bit-exact"
    );
}

// ── §8b Subnormal encoding tests ─────────────────────────────────────────────

#[test]
fn float_subnormals_roundtrip() {
    let cases: &[u32] = &[
        0x00000001, // min positive subnormal
        0x007fffff, // max subnormal
        0x80000001, // min negative subnormal
        0x003fffff, // mid subnormal
    ];
    for &bits in cases {
        let wire = float_wire(bits);
        let schema = knife_schema();
        let text = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let wire2 = render_as_bytes(
            &text,
            RenderOpts {
                assume_binary: false,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            wire2, wire,
            "float subnormal 0x{:08x} must round-trip bit-exact",
            bits
        );
    }
}

#[test]
fn double_subnormals_roundtrip() {
    let cases: &[u64] = &[
        0x0000000000000001, // min positive subnormal
        0x000fffffffffffff, // max subnormal
        0x8000000000000001, // min negative subnormal
        0x0004000000000000, // mid subnormal
    ];
    for &bits in cases {
        let wire = double_wire(bits);
        let schema = knife_schema();
        let text = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        let wire2 = render_as_bytes(
            &text,
            RenderOpts {
                assume_binary: false,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            wire2, wire,
            "double subnormal 0x{:016x} must round-trip bit-exact",
            bits
        );
    }
}

// ── §9 protoc --decode compatibility (spec 0010) ─────────────────────────────
//
// For canonical wire input, prototext output must be byte-for-byte identical
// to `protoc --decode` output (modulo the `#@ …` annotation comments).
//
// Two properties are verified for each case:
//   A) render with annotations=true, then strip the `#@ prototext: protoc`
//      header and all ` #@ …` comment suffixes → must equal protoc output.
//   B) render with annotations=false directly → must equal protoc output.
//
// "protoc output" means the exact text that `protoc --decode SchemaMsg`
// would emit for the given wire bytes.

/// Strip annotation comments from prototext output to get plain protoc-style text.
///
/// Removes:
/// - Any line whose non-whitespace content starts with `#@` (header and
///   comment-only annotation lines such as pack_size:0 lines).
/// - Any `  #@ …` suffix on value lines.
fn strip_annotations(text: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(text.len());
    for line in text.split(|&b| b == b'\n') {
        // Skip lines that are pure annotation comments (no value token).
        if line.iter().all(|&b| b == b' ' || b == b'\t') {
            continue;
        }
        let trimmed = line
            .iter()
            .position(|&b| b != b' ' && b != b'\t')
            .unwrap_or(0);
        if line[trimmed..].starts_with(b"#@") {
            continue;
        }
        // Strip trailing `  #@ …` annotation from value lines.
        let stripped = if let Some(pos) = line.windows(5).rposition(|w| w == b"  #@ ") {
            &line[..pos]
        } else {
            line
        };
        out.extend_from_slice(stripped);
        out.push(b'\n');
    }
    out
}

// Wire helpers for packed int32 (field 85, tag [0xAA, 0x05]).
fn int32_packed_wire(values: &[i32]) -> Vec<u8> {
    let payload: Vec<u8> = values
        .iter()
        .flat_map(|&v| {
            let mut buf = [0u8; 10];
            let n = encode_varint(v as u64, &mut buf);
            buf[..n].to_vec()
        })
        .collect();
    let mut v = vec![0xAA, 0x05]; // tag: field 85, wire type LEN
    v.push(payload.len() as u8);
    v.extend_from_slice(&payload);
    v
}

fn encode_varint(mut val: u64, buf: &mut [u8; 10]) -> usize {
    let mut i = 0;
    loop {
        if val < 0x80 {
            buf[i] = val as u8;
            i += 1;
            break;
        }
        buf[i] = (val as u8) | 0x80;
        val >>= 7;
        i += 1;
    }
    i
}

/// Run `protoc --decode SwissArmyKnife` on `wire` bytes and return its stdout.
///
/// Skips the test (with a warning) if `protoc` is not in PATH, so the test
/// suite still passes in environments where protoc is unavailable.
fn protoc_decode(wire: &[u8]) -> Option<Vec<u8>> {
    use std::io::Write as _;
    use std::process::{Command, Stdio};

    let proto_path = repo_root().join("fixtures/schemas");
    let mut child = match Command::new("protoc")
        .args([
            "--decode=SwissArmyKnife",
            &format!("--proto_path={}", proto_path.display()),
            "knife.proto",
        ])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::null())
        .spawn()
    {
        Ok(c) => c,
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
            eprintln!("SKIP: protoc not found in PATH — skipping compatibility check");
            return None;
        }
        Err(e) => panic!("failed to spawn protoc: {e}"),
    };
    child.stdin.take().unwrap().write_all(wire).unwrap();
    let out = child.wait_with_output().expect("protoc wait failed");
    assert!(
        out.status.success(),
        "protoc --decode failed: {:?}",
        out.status
    );
    Some(out.stdout)
}

// ── Packed field compatibility ─────────────────────────────────────────────────

#[test]
fn packed_int32_matches_protoc_output() {
    // Canonical packed int32 field: int32Pk = [1, 2, 3] (field 85).
    // protoc --decode renders as three separate lines, one per element.
    let wire = int32_packed_wire(&[1, 2, 3]);
    let schema = knife_schema();
    let Some(expected) = protoc_decode(&wire) else {
        return;
    };

    // A) strip annotations from annotated output
    let with_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&with_ann),
        expected,
        "packed int32: stripped annotated output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&strip_annotations(&with_ann)),
    );

    // B) no-annotations output directly
    let no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&no_ann).as_slice(),
        expected,
        "packed int32: no-annotations output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&no_ann),
    );
}

#[test]
fn packed_float_matches_protoc_output() {
    // Canonical packed float field: floatPk = [0.0, 1.0, -1.0] (field 82).
    // protoc --decode renders as three separate lines with field name.
    let wire = float_packed_wire(&[0.0f32.to_bits(), 1.0f32.to_bits(), (-1.0f32).to_bits()]);
    let schema = knife_schema();
    let Some(expected) = protoc_decode(&wire) else {
        return;
    };

    // A) strip annotations
    let with_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&with_ann),
        expected,
        "packed float: stripped annotated output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&strip_annotations(&with_ann)),
    );

    // B) no-annotations
    let no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&no_ann).as_slice(),
        expected,
        "packed float: no-annotations output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&no_ann),
    );
}

#[test]
fn packed_double_matches_protoc_output() {
    // Canonical packed double field: doublePk = [0.0, 1.0, -1.0] (field 81).
    let wire = double_packed_wire(&[0.0f64.to_bits(), 1.0f64.to_bits(), (-1.0f64).to_bits()]);
    let schema = knife_schema();
    let Some(expected) = protoc_decode(&wire) else {
        return;
    };

    // A) strip annotations
    let with_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&with_ann),
        expected,
        "packed double: stripped annotated output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&strip_annotations(&with_ann)),
    );

    // B) no-annotations
    let no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&no_ann).as_slice(),
        expected,
        "packed double: no-annotations output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&no_ann),
    );
}

// ── NaN compatibility ──────────────────────────────────────────────────────────

#[test]
fn canonical_float_nan_matches_protoc_output() {
    // Canonical quiet NaN (0x7FC00000): protoc renders as bare `nan`.
    let wire = float_wire(F32_CANONICAL_NAN);
    let schema = knife_schema();
    let Some(expected) = protoc_decode(&wire) else {
        return;
    };

    // A) strip annotations
    let with_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&with_ann),
        expected,
        "canonical float NaN: stripped annotated output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&strip_annotations(&with_ann)),
    );

    // B) no-annotations
    let no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&no_ann).as_slice(),
        expected,
        "canonical float NaN: no-annotations output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&no_ann),
    );
}

#[test]
fn noncanonical_float_nan_matches_protoc_output() {
    // Non-canonical NaN: protoc still renders as bare `nan` (it ignores bit pattern).
    for &bits in &[F32_SIGNALING_NAN, F32_SIGNED_NAN, F32_PAYLOAD_NAN] {
        let wire = float_wire(bits);
        let schema = knife_schema();
        let Some(expected) = protoc_decode(&wire) else {
            return;
        };

        // A) strip annotations
        let with_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            strip_annotations(&with_ann),
            expected,
            "non-canonical float NaN 0x{bits:08x}: stripped annotated output does not match protoc\n  got:\n{}",
            String::from_utf8_lossy(&strip_annotations(&with_ann)),
        );

        // B) no-annotations
        let no_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            strip_annotations(&no_ann).as_slice(),
            expected,
            "non-canonical float NaN 0x{bits:08x}: no-annotations output does not match protoc\n  got:\n{}",
            String::from_utf8_lossy(&no_ann),
        );
    }
}

#[test]
fn canonical_double_nan_matches_protoc_output() {
    let wire = double_wire(F64_CANONICAL_NAN);
    let schema = knife_schema();
    let Some(expected) = protoc_decode(&wire) else {
        return;
    };

    // A) strip annotations
    let with_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&with_ann),
        expected,
        "canonical double NaN: stripped annotated output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&strip_annotations(&with_ann)),
    );

    // B) no-annotations
    let no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&no_ann).as_slice(),
        expected,
        "canonical double NaN: no-annotations output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&no_ann),
    );
}

#[test]
fn noncanonical_double_nan_matches_protoc_output() {
    for &bits in &[F64_SIGNALING_NAN, F64_SIGNED_NAN, F64_PAYLOAD_NAN] {
        let wire = double_wire(bits);
        let schema = knife_schema();
        let Some(expected) = protoc_decode(&wire) else {
            return;
        };

        // A) strip annotations
        let with_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: true,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            strip_annotations(&with_ann),
            expected,
            "non-canonical double NaN 0x{bits:016x}: stripped annotated output does not match protoc\n  got:\n{}",
            String::from_utf8_lossy(&strip_annotations(&with_ann)),
        );

        // B) no-annotations
        let no_ann = render_as_text(
            &wire,
            Some(&schema),
            RenderOpts {
                assume_binary: true,
                include_annotations: false,
                indent: 1,
                expand_any: true,
            },
        )
        .unwrap();
        assert_eq!(
            strip_annotations(&no_ann).as_slice(),
            expected,
            "non-canonical double NaN 0x{bits:016x}: no-annotations output does not match protoc\n  got:\n{}",
            String::from_utf8_lossy(&no_ann),
        );
    }
}

#[test]
fn packed_float_nan_matches_protoc_output() {
    // Mixed canonical and non-canonical NaNs in a packed float field.
    // protoc renders all as bare `nan` regardless of bit pattern.
    let wire = float_packed_wire(&[F32_CANONICAL_NAN, F32_SIGNALING_NAN, F32_PAYLOAD_NAN]);
    let schema = knife_schema();
    let Some(expected) = protoc_decode(&wire) else {
        return;
    };

    // A) strip annotations
    let with_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&with_ann),
        expected,
        "packed float NaN: stripped annotated output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&strip_annotations(&with_ann)),
    );

    // B) no-annotations
    let no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&no_ann).as_slice(),
        expected,
        "packed float NaN: no-annotations output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&no_ann),
    );
}

#[test]
fn packed_double_nan_matches_protoc_output() {
    let wire = double_packed_wire(&[F64_CANONICAL_NAN, F64_SIGNALING_NAN, F64_PAYLOAD_NAN]);
    let schema = knife_schema();
    let Some(expected) = protoc_decode(&wire) else {
        return;
    };

    // A) strip annotations
    let with_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&with_ann),
        expected,
        "packed double NaN: stripped annotated output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&strip_annotations(&with_ann)),
    );

    // B) no-annotations
    let no_ann = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(
        strip_annotations(&no_ann).as_slice(),
        expected,
        "packed double NaN: no-annotations output does not match protoc\n  got:\n{}",
        String::from_utf8_lossy(&no_ann),
    );
}

// ── §9 Extension field round-trip (spec 0012) ────────────────────────────────
//
// Schema:  package acme;
//          message Gadget { extensions 1000 to 1999; }
//          extend Gadget { optional int32 blade_count = 1000; }
//
// Wire bytes for `blade_count = 42`:
//   tag  = (1000 << 3) | 0  = 8000 → varint  [0xC0, 0x3E]
//   value = 42              → varint  [0x2A]

fn gadget_schema() -> prototext_core::ParsedSchema {
    use prost_types::{
        descriptor_proto::ExtensionRange, DescriptorProto, FieldDescriptorProto,
        FileDescriptorProto, FileDescriptorSet,
    };
    let ext_field = FieldDescriptorProto {
        name: Some("blade_count".into()),
        number: Some(1000),
        r#type: Some(5), // TYPE_INT32
        label: Some(1),  // LABEL_OPTIONAL
        extendee: Some(".acme.Gadget".into()),
        ..Default::default()
    };
    let gadget = DescriptorProto {
        name: Some("Gadget".into()),
        extension_range: vec![ExtensionRange {
            start: Some(1000),
            end: Some(2000),
            ..Default::default()
        }],
        ..Default::default()
    };
    let file = FileDescriptorProto {
        name: Some("gadget.proto".into()),
        syntax: Some("proto2".into()),
        package: Some("acme".into()),
        message_type: vec![gadget],
        extension: vec![ext_field],
        ..Default::default()
    };
    let fds = FileDescriptorSet { file: vec![file] };
    let mut desc_bytes = Vec::new();
    fds.encode(&mut desc_bytes).unwrap();
    parse_schema(&desc_bytes, "acme.Gadget").unwrap()
}

// Spec 0012 §render: extension fields render as `[fully.qualified.name]: value`.
#[test]
fn extension_field_renders_with_bracketed_fqn() {
    let schema = gadget_schema();
    // Wire bytes: field 1000 (varint), value 42
    //   tag = (1000 << 3) | 0 = 8000 → [0xC0, 0x3E]; val = 42 → [0x2A]
    let wire = vec![0xC0u8, 0x3E, 0x2A];
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();

    assert!(
        text_str.contains("[acme.blade_count]"),
        "expected bracketed FQN [acme.blade_count] in: {text_str}"
    );
    assert!(text_str.contains("42"), "expected value 42 in: {text_str}");
    assert!(
        text_str.contains("int32"),
        "expected type int32 in annotation: {text_str}"
    );
    assert!(
        text_str.contains("= 1000"),
        "expected field number = 1000 in annotation: {text_str}"
    );
}

// Spec 0012 §encode: text with `[fully.qualified.name]` field re-encodes to the
// original wire bytes (lossless round-trip for extension fields).
#[test]
fn extension_field_roundtrip() {
    let schema = gadget_schema();
    // Wire bytes: field 1000 (varint), value 42
    let wire_orig = vec![0xC0u8, 0x3E, 0x2A];

    // Render to annotated text.
    let text = render_as_text(
        &wire_orig,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();

    // Re-encode back to binary.
    let wire_roundtrip = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();

    assert_eq!(
        wire_roundtrip,
        wire_orig,
        "extension field round-trip failed\n  text:\n{}",
        String::from_utf8_lossy(&text),
    );
}

// ── §10 google.protobuf.Any expansion (spec 0089) ────────────────────────────
//
// Schema:
//   package acme;
//   import "google/protobuf/any.proto";
//   message Payload  { optional string label = 1; }
//   message Container { optional google.protobuf.Any payload = 1; }
//
// Wire bytes for Container { payload: Any { type_url: "type.googleapis.com/acme.Payload"
//                                           value: Payload { label: "hello" } } }:
//
//   Payload { label: "hello" }:
//     tag field 1 LEN = 0x0a, len 5, "hello" = [0x0a, 0x05, 0x68,0x65,0x6c,0x6c,0x6f]
//
//   Any { type_url: "type.googleapis.com/acme.Payload", value: <above> }:
//     field 1 LEN (type_url): 0x0a, len 31, "type.googleapis.com/acme.Payload"
//     field 2 LEN (value):    0x12, len 7,  <payload bytes>
//
//   Container { payload: <any_bytes> }:
//     field 1 LEN: 0x0a, len <any_len>, <any_bytes>

fn any_schema() -> prototext_core::ParsedSchema {
    use prost::Message as _;
    use prost_reflect::DescriptorPool;
    use prost_types::{DescriptorProto, FieldDescriptorProto, FileDescriptorProto};
    use prototext_core::schema_from_pool;

    // Seed pool with WKTs from descriptor.pb (descriptor.proto only).
    let descriptor_pb =
        std::fs::read(std::path::PathBuf::from(env!("OUT_DIR")).join("descriptor.pb"))
            .expect("cannot read descriptor.pb from OUT_DIR");
    let mut pool =
        DescriptorPool::decode(descriptor_pb.as_slice()).expect("cannot decode descriptor.pb");

    // Add a minimal google/protobuf/any.proto — two fields: type_url and value.
    let any_msg = DescriptorProto {
        name: Some("Any".into()),
        field: vec![
            FieldDescriptorProto {
                name: Some("type_url".into()),
                number: Some(1),
                r#type: Some(9), // TYPE_STRING
                label: Some(1),  // LABEL_OPTIONAL
                ..Default::default()
            },
            FieldDescriptorProto {
                name: Some("value".into()),
                number: Some(2),
                r#type: Some(12), // TYPE_BYTES
                label: Some(1),   // LABEL_OPTIONAL
                ..Default::default()
            },
        ],
        ..Default::default()
    };
    let any_file = FileDescriptorProto {
        name: Some("google/protobuf/any.proto".into()),
        syntax: Some("proto3".into()),
        package: Some("google.protobuf".into()),
        message_type: vec![any_msg],
        ..Default::default()
    };
    let mut any_file_bytes = Vec::new();
    any_file.encode(&mut any_file_bytes).unwrap();
    pool.decode_file_descriptor_proto(any_file_bytes.as_slice())
        .expect("cannot add google/protobuf/any.proto to pool");

    // acme.Payload: message Payload { optional string label = 1; }
    let payload_msg = DescriptorProto {
        name: Some("Payload".into()),
        field: vec![FieldDescriptorProto {
            name: Some("label".into()),
            number: Some(1),
            r#type: Some(9), // TYPE_STRING
            label: Some(1),  // LABEL_OPTIONAL
            ..Default::default()
        }],
        ..Default::default()
    };

    // acme.Container: message Container { optional google.protobuf.Any payload = 1; }
    let container_msg = DescriptorProto {
        name: Some("Container".into()),
        field: vec![FieldDescriptorProto {
            name: Some("payload".into()),
            number: Some(1),
            r#type: Some(11), // TYPE_MESSAGE
            label: Some(1),   // LABEL_OPTIONAL
            type_name: Some(".google.protobuf.Any".into()),
            ..Default::default()
        }],
        ..Default::default()
    };

    let acme_file = FileDescriptorProto {
        name: Some("acme.proto".into()),
        syntax: Some("proto2".into()),
        package: Some("acme".into()),
        dependency: vec!["google/protobuf/any.proto".into()],
        message_type: vec![payload_msg, container_msg],
        ..Default::default()
    };

    let mut acme_bytes = Vec::new();
    acme_file.encode(&mut acme_bytes).unwrap();
    pool.decode_file_descriptor_proto(acme_bytes.as_slice())
        .expect("cannot add acme.proto to pool");

    schema_from_pool(pool, "acme.Container").expect("cannot build any_schema")
}

/// Build the wire bytes for:
///   Container { payload: Any { type_url: "type.googleapis.com/acme.Payload"
///                              value: Payload { label: "hello" } } }
fn any_wire_bytes() -> Vec<u8> {
    // Payload { label: "hello" } — field 1 LEN
    let label = b"hello";
    let mut payload_bytes = vec![0x0a, label.len() as u8];
    payload_bytes.extend_from_slice(label);

    // type_url string
    let type_url = b"type.googleapis.com/acme.Payload";

    // Any wire: field 1 (type_url) + field 2 (value)
    let mut any_bytes = Vec::new();
    any_bytes.push(0x0a); // field 1, LEN
    any_bytes.push(type_url.len() as u8);
    any_bytes.extend_from_slice(type_url);
    any_bytes.push(0x12); // field 2, LEN
    any_bytes.push(payload_bytes.len() as u8);
    any_bytes.extend_from_slice(&payload_bytes);

    // Container { payload: <any_bytes> } — field 1 LEN
    let mut wire = vec![0x0a, any_bytes.len() as u8];
    wire.extend_from_slice(&any_bytes);
    wire
}

#[test]
fn any_field_expands_type_url_and_value() {
    let schema = any_schema();
    let wire = any_wire_bytes();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        text_str.contains("type_url:"),
        "expected type_url line in Any expansion: {text_str}"
    );
    assert!(
        text_str.contains("type.googleapis.com/acme.Payload"),
        "expected type_url value in Any expansion: {text_str}"
    );
    assert!(
        text_str.contains("value {"),
        "expected value block in Any expansion: {text_str}"
    );
    assert!(
        text_str.contains("hello"),
        "expected Payload.label value in Any expansion: {text_str}"
    );
}

#[test]
fn any_field_no_expand_renders_value_as_bytes() {
    // With expand_any: false the value field is rendered as raw bytes (not
    // as an expanded sub-message), and there is no nested `value {` block.
    let schema = any_schema();
    let wire = any_wire_bytes();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: false,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    // value is a bytes field — rendered as a quoted string, not a `{` block.
    assert!(
        !text_str.contains("value {"),
        "value should not be an expanded block when expand_any=false: {text_str}"
    );
    assert!(
        text_str.contains("value:"),
        "value field should still be present as raw bytes: {text_str}"
    );
}

#[test]
fn any_field_roundtrip() {
    let schema = any_schema();
    let wire = any_wire_bytes();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let wire2 = render_as_bytes(
        &text,
        RenderOpts {
            assume_binary: false,
            include_annotations: false,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    assert_eq!(wire2, wire, "Any field must round-trip byte-for-byte");
}

#[test]
fn any_field_golden_annotated_output() {
    // TC-1b: compare against a hard-coded golden #@ string so that regressions
    // in indentation, annotation format, or field ordering are caught.
    let schema = any_schema();
    let wire = any_wire_bytes();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let expected = concat!(
        "#@ prototext: protoc\n",
        "payload {  #@ Any = 1\n",
        " type_url: \"type.googleapis.com/acme.Payload\"  #@ string = 1\n",
        " value {  #@ Payload = 2\n",
        "  label: \"hello\"  #@ string = 1\n",
        " }\n",
        "}\n",
    );
    assert_eq!(
        String::from_utf8(text).unwrap(),
        expected,
        "Any expansion golden output mismatch",
    );
}

#[test]
fn any_field_unresolvable_type_url_renders_value_as_bytes() {
    // When type_url names a type not present in the schema pool, the renderer
    // partially expands: type_url and value are rendered (the schema knows
    // the Any field structure), but value is a raw bytes literal — not a
    // nested { } block — because the payload type cannot be resolved.
    // Build a schema that has Container+Any but NOT acme.Payload.
    let schema = {
        use prost::Message as _;
        use prost_reflect::DescriptorPool;
        use prost_types::{DescriptorProto, FieldDescriptorProto, FileDescriptorProto};
        use prototext_core::schema_from_pool;

        let descriptor_pb =
            std::fs::read(std::path::PathBuf::from(env!("OUT_DIR")).join("descriptor.pb"))
                .expect("cannot read descriptor.pb from OUT_DIR");
        let mut pool =
            DescriptorPool::decode(descriptor_pb.as_slice()).expect("cannot decode descriptor.pb");

        let any_msg = DescriptorProto {
            name: Some("Any".into()),
            field: vec![
                FieldDescriptorProto {
                    name: Some("type_url".into()),
                    number: Some(1),
                    r#type: Some(9),
                    label: Some(1),
                    ..Default::default()
                },
                FieldDescriptorProto {
                    name: Some("value".into()),
                    number: Some(2),
                    r#type: Some(12),
                    label: Some(1),
                    ..Default::default()
                },
            ],
            ..Default::default()
        };
        let any_file = FileDescriptorProto {
            name: Some("google/protobuf/any.proto".into()),
            syntax: Some("proto3".into()),
            package: Some("google.protobuf".into()),
            message_type: vec![any_msg],
            ..Default::default()
        };
        let mut any_file_bytes = Vec::new();
        any_file.encode(&mut any_file_bytes).unwrap();
        pool.decode_file_descriptor_proto(any_file_bytes.as_slice())
            .expect("cannot add google/protobuf/any.proto to pool");

        // Container only — acme.Payload is absent from the pool.
        let container_msg = DescriptorProto {
            name: Some("Container".into()),
            field: vec![FieldDescriptorProto {
                name: Some("payload".into()),
                number: Some(1),
                r#type: Some(11),
                label: Some(1),
                type_name: Some(".google.protobuf.Any".into()),
                ..Default::default()
            }],
            ..Default::default()
        };
        let acme_file = FileDescriptorProto {
            name: Some("acme.proto".into()),
            syntax: Some("proto2".into()),
            package: Some("acme".into()),
            dependency: vec!["google/protobuf/any.proto".into()],
            message_type: vec![container_msg],
            ..Default::default()
        };
        let mut acme_bytes = Vec::new();
        acme_file.encode(&mut acme_bytes).unwrap();
        pool.decode_file_descriptor_proto(acme_bytes.as_slice())
            .expect("cannot add acme.proto to pool");

        schema_from_pool(pool, "acme.Container").expect("cannot build schema")
    };

    let wire = any_wire_bytes();
    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        text_str.contains("type_url:"),
        "type_url field should still be rendered: {text_str}"
    );
    assert!(
        !text_str.contains("value {"),
        "value should be raw bytes, not a nested block, when type is unresolvable: {text_str}"
    );
    assert!(
        text_str.contains("value:"),
        "value field should be rendered as raw bytes: {text_str}"
    );
}

#[test]
fn any_field_value_before_type_url_renders_as_raw_len() {
    // scan_any_fields returns None when field 2 (value) precedes field 1
    // (type_url) in the wire encoding — the renderer falls back to raw LEN.
    let schema = any_schema();

    // Craft an Any wire payload with value before type_url.
    let label = b"hello";
    let mut payload_bytes = vec![0x0a, label.len() as u8];
    payload_bytes.extend_from_slice(label);
    let type_url = b"type.googleapis.com/acme.Payload";
    // Swap order: field 2 (value) first, then field 1 (type_url).
    let mut any_bytes = Vec::new();
    any_bytes.push(0x12); // field 2, LEN (value)
    any_bytes.push(payload_bytes.len() as u8);
    any_bytes.extend_from_slice(&payload_bytes);
    any_bytes.push(0x0a); // field 1, LEN (type_url)
    any_bytes.push(type_url.len() as u8);
    any_bytes.extend_from_slice(type_url);
    let mut wire = vec![0x0a, any_bytes.len() as u8];
    wire.extend_from_slice(&any_bytes);

    let text = render_as_text(
        &wire,
        Some(&schema),
        RenderOpts {
            assume_binary: true,
            include_annotations: true,
            indent: 1,
            expand_any: true,
        },
    )
    .unwrap();
    let text_str = String::from_utf8(text).unwrap();
    assert!(
        !text_str.contains("value {"),
        "value block should not appear when value precedes type_url: {text_str}"
    );
}

// ── Selftest: randomised round-trip stress test ───────────────────────────────

/// Xorshift64 — fast, deterministic, period 2^64 - 1.
fn xorshift64(state: &mut u64) -> u64 {
    *state ^= *state << 13;
    *state ^= *state >> 7;
    *state ^= *state << 17;
    *state
}

/// Generate a random byte string of length 0–63.
fn random_bytes(rng: &mut u64) -> Vec<u8> {
    let len = (xorshift64(rng) % 64) as usize;
    (0..len).map(|_| (xorshift64(rng) & 0xff) as u8).collect()
}

/// Randomised round-trip stress test: `binary → text → binary` must be
/// byte-for-byte identical for N random inputs.
///
/// Override defaults via env vars:
///   PROTOTEXT_SELFTEST_N    — number of iterations (default 10 000)
///   PROTOTEXT_SELFTEST_SEED — PRNG seed as decimal u64 (default 0xDEAD_BEEF_CAFE_1234)
#[test]
fn selftest_roundtrip() {
    let n: usize = std::env::var("PROTOTEXT_SELFTEST_N")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(1_000_000);
    let seed: u64 = std::env::var("PROTOTEXT_SELFTEST_SEED")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(0xDEAD_BEEF_CAFE_1234);

    let schema = knife_schema();
    let opts_enc = RenderOpts {
        assume_binary: true,
        include_annotations: true,
        indent: 1,
        expand_any: true,
    };
    let opts_dec = RenderOpts {
        assume_binary: false,
        include_annotations: false,
        indent: 1,
        expand_any: true,
    };

    let mut rng = seed;
    let mut failures = 0;

    for i in 0..n {
        let wire = random_bytes(&mut rng);
        let text = render_as_text(&wire, Some(&schema), opts_enc.clone())
            .expect("render_as_text panicked");
        let wire2 = render_as_bytes(&text, opts_dec.clone()).expect("render_as_bytes panicked");

        if wire2 != wire {
            eprintln!(
                "FAIL iteration {i}: wire={} reenc={}",
                wire.iter().map(|b| format!("{b:02x}")).collect::<String>(),
                wire2.iter().map(|b| format!("{b:02x}")).collect::<String>(),
            );
            eprintln!("  text:\n{}", String::from_utf8_lossy(&text));
            failures += 1;
            if failures >= 5 {
                panic!("selftest: too many failures, stopping early (seed={seed:#x})");
            }
        }
    }

    assert_eq!(
        failures, 0,
        "selftest: {failures} failures in {n} iterations (seed={seed:#x})"
    );
    eprintln!("selftest: {n} iterations passed (seed={seed:#x})");
}

// ── §bug: LEN wire type on a varint-declared field ────────────────────────────

/// Regression test for the missing `proto2_has_type_mismatch` flag in
/// `decode_len_field`'s wire-type-mismatch fallback path.
///
/// `SwissArmyKnife.int32Op` (field 25) is declared as `int32` (wire type 0,
/// varint).  When the wire message carries field 25 with wire type 2
/// (length-delimited), the decoder reaches the fallback branch in
/// `decode_len_field` and emits `WireBytes`.  That branch must also set
/// `proto2_has_type_mismatch = true` — without it the type conflict is
/// silently lost and the field is indistinguishable from an unknown field.
///
#[test]
fn len_wire_type_on_varint_field_sets_type_mismatch_flag() {
    // Tag: field 25, wire type LEN (2) → (25 << 3) | 2 = 202 → 0xCA 0x01
    // Length: 3 bytes → 0x03
    // Payload: arbitrary bytes 0x01 0x02 0x03
    let wire: Vec<u8> = vec![0xCA, 0x01, 0x03, 0x01, 0x02, 0x03];
    let schema = knife_schema();
    let msg = prototext_core::decoder::ingest_pb(&wire, &schema, false);

    assert_eq!(msg.fields.len(), 1, "expected exactly one field");
    let field = &msg.fields[0];

    assert_eq!(
        field.field_number,
        Some(25),
        "field number must be 25 (int32Op)"
    );
    assert!(
        matches!(
            field.content,
            prototext_core::decoder::ProtoTextContent::WireBytes(_)
        ),
        "content must be WireBytes (LEN fallback), got: {:?}",
        field.content
    );
    assert!(
        field.proto2_has_type_mismatch,
        "proto2_has_type_mismatch must be true for LEN wire type on int32 field"
    );
}