facet_generate 0.17.2

#![allow(
    clippy::must_use_candidate,
    clippy::missing_panics_doc,
    clippy::unsafe_derive_deserialize
)]

use std::collections::BTreeMap;

use facet::Facet;
use maplit::btreemap;
use serde::{Deserialize, Serialize};

use facet_generate as fg;
use facet_generate::{Registry, reflect};

// Simple data formats used to create and test values in each language.
#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Serialize, Deserialize)]
pub struct Test {
    pub a: Vec<u32>,
    pub b: (i64, u64),
    pub c: Choice,
}

#[derive(Facet, Serialize, Deserialize)]
#[repr(C)]
pub enum Choice {
    A,
    B(u64),
    C { x: u8 },
}

pub fn get_simple_registry() -> Registry {
    reflect!(Test).unwrap()
}

// More complex data format used to test re-serialization and basic fuzzing.
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq)]
#[repr(C)]
pub enum SerdeData {
    PrimitiveTypes(PrimitiveTypes),
    OtherTypes(OtherTypes),
    UnitVariant,
    NewTypeVariant(String),
    TupleVariant(u32, u64),
    StructVariant {
        f0: UnitStruct,
        f1: NewTypeStruct,
        f2: TupleStruct,
        f3: Struct,
    },
    ListWithMutualRecursion(List<Box<Self>>),
    TreeWithMutualRecursion(Tree<Box<Self>>),
    TupleArray([u32; 3]),
    UnitVector(Vec<()>),
    SimpleList(SimpleList),
    CStyleEnum(CStyleEnum),
    #[allow(clippy::zero_sized_map_values)]
    ComplexMap(BTreeMap<([u32; 2], [u8; 4]), ()>),
    // TODO: Facet has a problem with empty tuple variants
    // EmptyTupleVariant(),
    EmptyStructVariant {},
}

#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq)]
#[allow(clippy::struct_field_names)]
pub struct PrimitiveTypes {
    f_bool: bool,
    f_u8: u8,
    f_u16: u16,
    f_u32: u32,
    f_u64: u64,
    f_u128: u128,
    f_i8: i8,
    f_i16: i16,
    f_i32: i32,
    f_i64: i64,
    f_i128: i128,
    // The following types are not supported by our bincode runtime, therefore
    // we don't populate them for testing.
    f_f32: Option<f32>,
    f_f64: Option<f64>,
    f_char: Option<char>,
}

#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[allow(clippy::struct_field_names)]
pub struct OtherTypes {
    f_string: String,
    #[facet(fg::bytes)]
    f_bytes: Vec<u8>,
    f_option: Option<Struct>,
    f_unit: (),
    f_seq: Vec<Struct>,
    f_opt_seq: Option<Vec<i32>>,
    f_tuple: (u8, u16),
    f_stringmap: BTreeMap<String, u32>,
    #[allow(clippy::zero_sized_map_values)]
    f_intset: BTreeMap<u64, ()>, // Avoiding BTreeSet because Serde treats them as sequences.
    f_nested_seq: Vec<Vec<Struct>>,
}

#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct UnitStruct;

#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct NewTypeStruct(u64);

#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct TupleStruct(u32, u64);

#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct Struct {
    x: u32,
    y: u64,
}

#[derive(Facet, Debug, Serialize, Deserialize, PartialEq)]
#[repr(C)]
pub enum List<T> {
    Empty,
    Node(T, Box<Self>),
}

#[derive(Facet, Debug, Serialize, Deserialize, PartialEq)]
pub struct Tree<T> {
    value: T,
    children: Vec<Self>,
}

#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq)]
pub struct SimpleList(pub Option<Box<Self>>);

#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[repr(C)]
pub enum CStyleEnum {
    A,
    B,
    C,
    D,
    E = 10,
}

/// The registry corresponding to the test data structures above.
pub fn get_registry() -> Registry {
    reflect!(SerdeData).unwrap()
}

/// Manually generate sample values.
#[allow(clippy::too_many_lines)]
pub fn get_sample_values() -> Vec<SerdeData> {
    let v0 = SerdeData::PrimitiveTypes(PrimitiveTypes {
        f_bool: false,
        f_u8: 6,
        f_u16: 5,
        f_u32: 4,
        f_u64: 3,
        f_u128: 2,
        f_i8: 1,
        f_i16: 0,
        f_i32: -1,
        f_i64: -2,
        f_i128: -3,
        f_f32: Some(0.4),
        f_f64: Some(35.21),
        f_char: None,
    });

    let v1 = SerdeData::PrimitiveTypes(PrimitiveTypes {
        f_bool: true,
        f_u8: u8::MAX,
        f_u16: u16::MAX,
        f_u32: u32::MAX,
        f_u64: u64::MAX,
        f_u128: u128::MAX,
        f_i8: i8::MIN,
        f_i16: i16::MIN,
        f_i32: i32::MIN,
        f_i64: i64::MIN,
        f_i128: i128::MIN,
        f_f32: Some(-4111.0),
        f_f64: Some(-0.0021),
        f_char: None,
    });

    let v2 = SerdeData::OtherTypes(OtherTypes {
        f_string: "test".to_string(),
        f_bytes: b"bytes".to_vec(),
        f_option: Some(Struct { x: 2, y: 3 }),
        f_unit: (),
        f_seq: vec![Struct { x: 1, y: 3 }],
        f_opt_seq: Some(vec![1]),
        f_tuple: (4, 5),
        f_stringmap: btreemap! {"foo".to_string() => 1},
        #[allow(clippy::zero_sized_map_values)]
        f_intset: BTreeMap::new(),
        f_nested_seq: vec![
            vec![Struct { x: 4, y: 5 }, Struct { x: 6, y: 7 }],
            vec![Struct { x: 8, y: 9 }],
        ],
    });

    let v2bis = SerdeData::OtherTypes(OtherTypes {
        f_string: String::new(),
        f_bytes: b"".to_vec(),
        f_option: None,
        f_unit: (),
        f_seq: Vec::new(),
        f_opt_seq: None,
        f_tuple: (4, 5),
        f_stringmap: BTreeMap::new(),
        f_intset: btreemap! {64 => ()},
        f_nested_seq: vec![],
    });

    let v2ter = SerdeData::OtherTypes(OtherTypes {
        f_string: String::new(),
        f_bytes: vec![1u8; 129],
        f_option: None,
        f_unit: (),
        f_seq: Vec::new(),
        f_opt_seq: None,
        f_tuple: (4, 5),
        f_stringmap: BTreeMap::new(),
        #[allow(clippy::zero_sized_map_values)]
        f_intset: BTreeMap::new(),
        f_nested_seq: vec![],
    });

    let v3 = SerdeData::UnitVariant;

    let v4 =
        SerdeData::NewTypeVariant("test.\u{10348}.\u{00a2}\u{0939}\u{20ac}\u{d55c}..".to_string());

    let v5 = SerdeData::TupleVariant(3, 6);

    let v6 = SerdeData::StructVariant {
        f0: UnitStruct,
        f1: NewTypeStruct(1),
        f2: TupleStruct(2, 3),
        f3: Struct { x: 4, y: 5 },
    };

    let v7 = SerdeData::ListWithMutualRecursion(List::Empty);

    let v8 = SerdeData::TreeWithMutualRecursion(Tree {
        value: Box::new(SerdeData::PrimitiveTypes(PrimitiveTypes {
            f_bool: false,
            f_u8: 0,
            f_u16: 1,
            f_u32: 2,
            f_u64: 3,
            f_u128: 4,
            f_i8: 5,
            f_i16: 6,
            f_i32: 7,
            f_i64: 8,
            f_i128: 9,
            f_f32: None,
            f_f64: None,
            f_char: None,
        })),
        children: vec![Tree {
            value: Box::new(SerdeData::PrimitiveTypes(PrimitiveTypes {
                f_bool: false,
                f_u8: 0,
                f_u16: 0,
                f_u32: 0,
                f_u64: 0,
                f_u128: 0,
                f_i8: 0,
                f_i16: 0,
                f_i32: 0,
                f_i64: 0,
                f_i128: 0,
                f_f32: None,
                f_f64: None,
                f_char: None,
            })),
            children: vec![],
        }],
    });

    let v9 = SerdeData::TupleArray([0, 2, 3]);

    let v10 = SerdeData::UnitVector(vec![(); 1000]);

    let v11 = SerdeData::SimpleList(SimpleList(Some(Box::new(SimpleList(None)))));

    let v12 = SerdeData::CStyleEnum(CStyleEnum::C);

    let v13 = SerdeData::ComplexMap(btreemap! { ([1,2], [3,4,5,6]) => ()});

    // let v14 = SerdeData::EmptyTupleVariant();
    let v15 = SerdeData::EmptyStructVariant {};

    vec![
        v0, v1, v2, v2bis, v2ter, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, //v14,
        v15,
    ]
}

#[cfg(test)]
// Used to test limits on "container depth".
#[must_use]
pub fn get_sample_value_with_container_depth(depth: usize) -> Option<SerdeData> {
    if depth < 2 {
        return None;
    }
    let mut list = List::Empty;
    for _ in 2..depth {
        list = List::Node(Box::new(SerdeData::UnitVariant), Box::new(list));
    }
    Some(SerdeData::ListWithMutualRecursion(list))
}

#[cfg(test)]
// Used to test limits on "container depth".
#[must_use]
pub fn get_alternate_sample_value_with_container_depth(depth: usize) -> Option<SerdeData> {
    if depth < 2 {
        return None;
    }
    let mut list = SimpleList(None);
    for _ in 2..depth {
        list = SimpleList(Some(Box::new(list)));
    }
    Some(SerdeData::SimpleList(list))
}

#[cfg(test)]
// Used to test limits on sequence lengths and container depth.
#[must_use]
pub fn get_sample_value_with_long_sequence(length: usize) -> SerdeData {
    SerdeData::UnitVector(vec![(); length])
}

/// Serialize each sample value with bincode, returning the serialized bytes.
pub fn get_positive_samples() -> Vec<Vec<u8>> {
    get_sample_values()
        .iter()
        .map(|v| bincode::serialize(v).unwrap())
        .collect()
}

/// Construct serialized bytes for a list with the given container depth.
/// Bytes are constructed directly to allow testing depths outside normal limits.
pub fn get_sample_with_container_depth(depth: usize) -> Option<Vec<u8>> {
    if depth < 2 {
        return None;
    }
    let mut e = bincode::serialize::<List<SerdeData>>(&List::Empty).unwrap();

    let f0 = bincode::serialize(&List::Node(
        Box::new(SerdeData::UnitVariant),
        Box::new(List::Empty),
    ))
    .unwrap();
    let f = f0[..f0.len() - e.len()].to_vec();

    let h0 = bincode::serialize(&SerdeData::ListWithMutualRecursion(List::Empty)).unwrap();
    let mut result = h0[..h0.len() - e.len()].to_vec();

    for _ in 2..depth {
        result.append(&mut f.clone());
    }
    result.append(&mut e);
    Some(result)
}

/// Construct serialized bytes for a `SimpleList` with the given container depth.
/// Bytes are constructed directly to allow testing depths outside normal limits.
pub fn get_alternate_sample_with_container_depth(depth: usize) -> Option<Vec<u8>> {
    if depth < 2 {
        return None;
    }
    let mut e = bincode::serialize::<SimpleList>(&SimpleList(None)).unwrap();

    let f0 = bincode::serialize(&SimpleList(Some(Box::new(SimpleList(None))))).unwrap();
    let f = f0[..f0.len() - e.len()].to_vec();

    let h0 = bincode::serialize(&SerdeData::SimpleList(SimpleList(None))).unwrap();
    let mut result = h0[..h0.len() - e.len()].to_vec();

    for _ in 2..depth {
        result.append(&mut f.clone());
    }
    result.append(&mut e);
    Some(result)
}

/// Construct serialized bytes for a `UnitVector` with the given length.
/// Bytes are constructed directly to allow testing lengths outside normal limits.
pub fn get_sample_with_long_sequence(length: usize) -> Vec<u8> {
    let e = bincode::serialize::<Vec<()>>(&Vec::new()).unwrap();
    let f0 = bincode::serialize(&SerdeData::UnitVector(Vec::new())).unwrap();
    let mut result = f0[..f0.len() - e.len()].to_vec();
    result.append(&mut bincode::serialize(&(length as u64)).unwrap());
    result
}

// ---------------------------------------------------------------------------
// Swift-compatible test fixture
//
// `SerdeData` includes `ComplexMap(BTreeMap<([u32; 2], [u8; 4]), ()>)` whose
// key is a native tuple — valid in Rust but not representable as a Swift
// `Dictionary` key (native tuples do not conform to `Hashable`).
//
// `SwiftSerdeData` covers the same surface area without that variant.
// `SwiftSimpleList` is a recursive struct; it compiles in Swift because the
// emitter generates `@Indirect` for the recursive field.
// ---------------------------------------------------------------------------

#[derive(Facet, Debug, Serialize, Deserialize, PartialEq)]
#[repr(C)]
#[allow(dead_code)]
pub enum SwiftSerdeData {
    PrimitiveTypes(SwiftPrimitiveTypes),
    OtherTypes(SwiftOtherTypes),
    UnitVariant,
    NewTypeVariant(String),
    TupleVariant(u32, u64),
    StructVariant {
        f0: SwiftUnitStruct,
        f1: SwiftNewTypeStruct,
        f2: SwiftTupleStruct,
        f3: SwiftStruct,
    },
    ListWithMutualRecursion(SwiftList<Box<Self>>),
    TreeWithMutualRecursion(Tree<Box<Self>>),
    TupleArray([u32; 3]),
    UnitVector(Vec<()>),
    SimpleList(SwiftSimpleList),
    EmptyStructVariant {},
}

#[allow(dead_code)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq)]
#[allow(clippy::struct_field_names)]
pub struct SwiftPrimitiveTypes {
    pub f_bool: bool,
    pub f_u8: u8,
    pub f_u16: u16,
    pub f_u32: u32,
    pub f_u64: u64,
    pub f_u128: u128,
    pub f_i8: i8,
    pub f_i16: i16,
    pub f_i32: i32,
    pub f_i64: i64,
    pub f_i128: i128,
    pub f_f32: Option<f32>,
    pub f_f64: Option<f64>,
    pub f_char: Option<char>,
}

#[allow(dead_code)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[allow(clippy::struct_field_names)]
pub struct SwiftOtherTypes {
    pub f_string: String,
    #[facet(fg::bytes)]
    pub f_bytes: Vec<u8>,
    pub f_option: Option<SwiftStruct>,
    pub f_unit: (),
    pub f_seq: Vec<SwiftStruct>,
    pub f_opt_seq: Option<Vec<i32>>,
    pub f_tuple: (u8, u16),
    pub f_stringmap: BTreeMap<String, u32>,
    pub f_nested_seq: Vec<Vec<SwiftStruct>>,
}

#[allow(dead_code)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct SwiftUnitStruct;

#[allow(dead_code)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct SwiftNewTypeStruct(pub u64);

#[allow(dead_code)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct SwiftTupleStruct(pub u32, pub u64);

#[allow(dead_code)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct SwiftStruct {
    pub x: u32,
    pub y: u64,
}

#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[repr(C)]
#[allow(dead_code)]
pub enum SwiftList<T> {
    Empty,
    Node(T, Box<Self>),
}

#[allow(dead_code)]
#[derive(Facet, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct SwiftSimpleList(pub Option<Box<Self>>);

// ---------------------------------------------------------------------------
// UUID round-trip fixtures
// ---------------------------------------------------------------------------

/// Two well-known RFC 4122 UUIDs used as pinned test vectors.
/// Using `uuid!` gives a compile-time constant so the bytes are deterministic.
pub const UUID_ID: uuid::Uuid = uuid::uuid!("550e8400-e29b-41d4-a716-446655440000");
pub const UUID_PARENT_ID: uuid::Uuid = uuid::uuid!("6ba7b810-9dad-11d1-80b4-00c04fd430c8");

/// A struct with a required and an optional UUID field.
#[derive(Facet, Serialize, Deserialize, Debug, PartialEq, Eq)]
pub struct UuidData {
    pub id: uuid::Uuid,
    pub parent_id: Option<uuid::Uuid>,
}

/// Returns a registry containing only [`UuidData`].
pub fn get_uuid_registry() -> Registry {
    reflect!(UuidData).unwrap()
}

/// Serialize the canonical UUID test value with bincode.
/// The resulting bytes are used as the reference wire encoding in all
/// language round-trip tests.
pub fn get_uuid_reference_bytes() -> Vec<u8> {
    bincode::serialize(&UuidData {
        id: UUID_ID,
        parent_id: Some(UUID_PARENT_ID),
    })
    .unwrap()
}

/// Registry used for Swift compilation and runtime tests.
///
/// Excludes `ComplexMap(BTreeMap<([u32; 2], [u8; 4]), ()>)` because native
/// Swift tuples are not `Hashable` and cannot be used as `Dictionary` keys.
/// Includes `SwiftSimpleList` which the Swift emitter handles with selective
/// `@Indirect` on the recursive field.
pub fn get_swift_registry() -> Registry {
    reflect!(SwiftSerdeData).unwrap()
}

/// Sample values for [`SwiftSerdeData`], serialised with bincode.
#[allow(clippy::too_many_lines)]
pub fn get_swift_positive_samples() -> Vec<Vec<u8>> {
    let values: Vec<SwiftSerdeData> = vec![
        SwiftSerdeData::UnitVariant,
        SwiftSerdeData::NewTypeVariant("test.\u{10348}".to_string()),
        SwiftSerdeData::TupleVariant(3, 6),
        SwiftSerdeData::PrimitiveTypes(SwiftPrimitiveTypes {
            f_bool: false,
            f_u8: 6,
            f_u16: 5,
            f_u32: 4,
            f_u64: 3,
            f_u128: 2,
            f_i8: 1,
            f_i16: 0,
            f_i32: -1,
            f_i64: -2,
            f_i128: -3,
            f_f32: Some(0.4),
            f_f64: Some(35.21),
            f_char: None,
        }),
        SwiftSerdeData::OtherTypes(SwiftOtherTypes {
            f_string: "test".to_string(),
            f_bytes: b"bytes".to_vec(),
            f_option: Some(SwiftStruct { x: 2, y: 3 }),
            f_unit: (),
            f_seq: vec![SwiftStruct { x: 1, y: 3 }],
            f_opt_seq: Some(vec![1]),
            f_tuple: (4, 5),
            f_stringmap: {
                let mut m = BTreeMap::new();
                m.insert("foo".to_string(), 1u32);
                m
            },
            f_nested_seq: vec![vec![SwiftStruct { x: 4, y: 5 }]],
        }),
        SwiftSerdeData::OtherTypes(SwiftOtherTypes {
            f_string: String::new(),
            f_bytes: b"".to_vec(),
            f_option: None,
            f_unit: (),
            f_seq: Vec::new(),
            f_opt_seq: None,
            f_tuple: (0, 0),
            f_stringmap: BTreeMap::new(),
            f_nested_seq: vec![],
        }),
        SwiftSerdeData::StructVariant {
            f0: SwiftUnitStruct,
            f1: SwiftNewTypeStruct(1),
            f2: SwiftTupleStruct(2, 3),
            f3: SwiftStruct { x: 4, y: 5 },
        },
        SwiftSerdeData::TupleArray([0, 2, 3]),
        SwiftSerdeData::UnitVector(vec![(); 3]),
        SwiftSerdeData::SimpleList(SwiftSimpleList(Some(Box::new(SwiftSimpleList(None))))),
        SwiftSerdeData::EmptyStructVariant {},
    ];
    values
        .iter()
        .map(|v| bincode::serialize(v).unwrap())
        .collect()
}