use roto_codegen::generator::generate_rust_code;
use roto_codegen::google::protobuf::descriptor::FileDescriptorSet;
use std::fs;

#[test]
fn test_nested_proto_generation_contains_modules() {
    let request_path = "data/request.bin";
    if !std::path::Path::new(request_path).exists() {
        panic!("data/request.bin not found. This test requires the sample request binary.");
    }

    let data = fs::read(request_path).expect("Failed to read request.bin");

    // The existing test logic to build a FileDescriptorSet from CodeGeneratorRequest
    // We can simplify this by just wrapping the data if it's already a FileDescriptorSet,
    // but request.bin is usually a CodeGeneratorRequest.

    // Let's use the same logic as build_generated_code.rs to get a FileDescriptorSet
    let request =
        roto_codegen::google::protobuf::compiler::plugin::CodeGeneratorRequest::new(&data)
            .expect("Failed to parse CodeGeneratorRequest");

    let mut set_buf = Vec::new();
    for file_res in request.proto_file() {
        let (file_data, _) = file_res.expect("Failed to iterate proto_file");
        set_buf.push(10);
        let len = file_data.len() as u64;
        let mut len_buf = [0u8; 10];
        let len_size =
            roto_runtime::write_varint(len, &mut len_buf).expect("Failed to write varint length");
        set_buf.extend_from_slice(&len_buf[..len_size]);
        set_buf.extend_from_slice(file_data);
    }
    let set = FileDescriptorSet::new(&set_buf).expect("Failed to create FileDescriptorSet");

    let generated_files = generate_rust_code(&set, None, false);

    let all_code: String = generated_files
        .into_iter()
        .map(|(_, content)| content)
        .collect();
    println!("Generated Code:\n{}", all_code);

    // We want to see if any message has a nested module.
    // Since we don't know exactly what's in request.bin, we'll look for ANY 'pub mod' inside the generated code
    // that isn't at the top level (though the generator puts them inside the message definition).
    assert!(
        all_code.contains("pub mod "),
        "Generated code should contain at least one nested module for nested types"
    );
    assert!(
        all_code.contains("pub struct "),
        "Generated code should contain structs"
    );
}
