// C code
typedef struct {
   ValueType type;
   union {
       int i;
       double d;
       const char* s;
       void* ptr;
   } data;
} AnyValue;

typedef struct {
   AnyValue* items;
   size_t size;
} C_Tuple_Like;

C_Tuple_Like* make_sample_tuple() {
   C_Tuple_Like* tuple = malloc(sizeof(C_Tuple_Like));
   tuple->size = 3;
   tuple->items = malloc(sizeof(AnyValue) * 3);
   tuple->items[0] = (AnyValue){ .type = TYPE_INT, .data.i = 42 };
   tuple->items[1] = (AnyValue){ .type = TYPE_DOUBLE, .data.d = 3.14 };
   tuple->items[2] = (AnyValue){ .type = TYPE_STRING, .data.s = strdup("hello") };
   return tuple;
}

// C++ code
std::tuple<int, double, std::string> convert(const C_Tuple_Like* ctuple);

std::tuple<int, double, std::string> convert_to_tuple(const C_Tuple_Like* input) {
   int i = input->items[0].data.i;
   double d = input->items[1].data.d;
   std::string s = input->items[2].data.s;
   return std::make_tuple(i, d, s);
}

// To Python
py::tuple convert_to_py_tuple(const C_Tuple_Like* input) {
   py::tuple result(input->size);
   for (size_t i = 0; i < input->size; ++i) {
       const auto& item = input->items[i];
       switch (item.type) {
           case TYPE_INT:
               result[i] = py::int_(item.data.i);
               break;
           case TYPE_DOUBLE:
               result[i] = py::float_(item.data.d);
               break;
           case TYPE_STRING:
               result[i] = py::str(item.data.s);
               break;
           default:
               result[i] = py::none();  // fallback
       }
   }
   return result;
}

m.def("get_tuple", []() {
   C_Tuple_Like* c_tuple = make_sample_tuple();
   auto py_tuple = convert_to_py_tuple(c_tuple);
   // free if needed
   return py_tuple;
});