public class RequestUtility {

    public static <REQ extends NatsPacket, RES extends NatsPacket> CompletableFuture<RES> sendRequest(
            String channel, REQ packetRequest, int duration, Class<RES> responseType) {
        CompletableFuture<RES> completableFuture = new CompletableFuture<>();

        API.getInstance().getConcurrencyService().executeNats(() -> {
            try {
                API.getInstance().getNatsMessengerAPI().sendCallbackPacket(
                        channel,
                        packetRequest,
                        duration,
                        new NatsCallback<RES>() {
                            @Override
                            public void onHandle(RES response) {
                                completableFuture.complete(response);
                            }

                            @Override
                            public void exit() {
                                completableFuture.completeExceptionally(new Exception("Failed to get a response for the packet on channel: " + channel));
                            }
                        }
                );
            } catch (Exception e) {
                completableFuture.completeExceptionally(e);
            }
        });

        return completableFuture;
    }

    public static <REQ extends NatsPacket, RES extends NatsPacket> CompletableFuture<RES> sendRequests(
            String primaryChannel, String fallbackChannel, REQ packetRequest, int duration, Class<RES> responseType) {
        CompletableFuture<RES> completableFuture = new CompletableFuture<>();

        API.getInstance().getConcurrencyService().executeNats(() -> {
            try {
                API.getInstance().getNatsMessengerAPI().sendCallbackPacket(
                        primaryChannel,
                        packetRequest,
                        duration,
                        new NatsCallback<RES>() {
                            @Override
                            public void onHandle(RES response) {
                                completableFuture.complete(response);
                            }

                            @Override
                            public void exit() {
                                // If the primary channel fails, try the fallback channel
                                API.getInstance().getConcurrencyService().executeNats(() -> {
                                    try {
                                        API.getInstance().getNatsMessengerAPI().sendCallbackPacket(
                                                fallbackChannel,
                                                packetRequest,
                                                duration,
                                                new NatsCallback<RES>() {
                                                    @Override
                                                    public void onHandle(RES response) {
                                                        completableFuture.complete(response);
                                                    }

                                                    @Override
                                                    public void exit() {
                                                        completableFuture.completeExceptionally(
                                                                new Exception("Failed to get a response from both channels: "
                                                                        + primaryChannel + " and " + fallbackChannel));
                                                    }
                                                }
                                        );
                                    } catch (Exception e) {
                                        completableFuture.completeExceptionally(e);
                                    }
                                });
                            }
                        }
                );
            } catch (Exception e) {
                completableFuture.completeExceptionally(e);
            }
        });

        return completableFuture;
    }
}