private static final Logger logger = LoggerFactory.getLogger(DockerTest.class);

public static void main(String[] args) {
    DockerClient dockerClient = null;
    String containerId = null;
    PipedOutputStream ptyStdin = null; // For potential input later
    PipedInputStream ptyStdinPipe = null; // For potential input later

    try {
        // --- 1. Initialize Docker Client ---
        logger.info("Attempting to initialize Docker client using default host detection...");
        DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().build();
        logger.info("DockerClientConfig resolved DOCKER_HOST to: {}", config.getDockerHost());

        DockerHttpClient httpClient = new ApacheDockerHttpClient.Builder()
                .dockerHost(config.getDockerHost())
                .sslConfig(config.getSSLConfig())
                .connectionTimeout(Duration.ofSeconds(30))
                .responseTimeout(Duration.ofSeconds(45))
                .build();

        dockerClient = DockerClientImpl.getInstance(config, httpClient);
        logger.info("Pinging Docker daemon...");
        dockerClient.pingCmd().exec();
        logger.info("Docker Ping Successful!");

        // --- 2. Create and Start a Simple Container ---
        String imageName = "ubuntu:latest"; // Use a simple image
         logger.info("Pulling image {} if not present...", imageName);
         try {
             dockerClient.inspectImageCmd(imageName).exec();
             logger.info("Image {} already present.", imageName);
         } catch (Exception e) { // Catch generic Exception as NotFoundException might not be the only cause
             logger.info("Image {} not found or error inspecting, pulling...", imageName);
             dockerClient.pullImageCmd(imageName).start().awaitCompletion();
             logger.info("Image {} pulled.", imageName);
         }


        logger.info("Creating container from image {}...", imageName);
        HostConfig hostConfig = HostConfig.newHostConfig().withNetworkMode("none"); // No network needed
        CreateContainerResponse container = dockerClient.createContainerCmd(imageName)
                .withHostConfig(hostConfig)
                .withCmd("sleep", "infinity") // Keep container running
                .withTty(true) // Keep TTY for potential exec later
                .withAttachStdin(false) // Stdin attached later via exec
                .withAttachStdout(true)
                .withAttachStderr(true)
                .exec();
        containerId = container.getId();
        logger.info("Created container: {}", containerId);

        dockerClient.startContainerCmd(containerId).exec();
        logger.info("Started container: {}", containerId);

        // --- 3. Create Exec Instance (Shell) ---
        logger.info("Creating exec instance in container {}...", containerId);
        ExecCreateCmdResponse execCreateResponse = dockerClient.execCreateCmd(containerId)
                .withAttachStdout(true)
                .withAttachStderr(true)
                .withAttachStdin(true) // Attach stdin
                .withTty(true) // Allocate TTY
                .withCmd("sh", "-i") // Interactive shell
                .exec();
        String execId = execCreateResponse.getId();
        logger.info("Created exec instance: {}", execId);

        // --- 4. Start Exec and Attach Streams ---
        // Setup pipes for stdin
        ptyStdin = new PipedOutputStream();
        ptyStdinPipe = new PipedInputStream(ptyStdin);

        logger.info("Starting exec instance {} and attaching streams...", execId);

        // Create final references for use in the inner class
        final PipedInputStream finalPtyStdinPipe = ptyStdinPipe;
        final PipedOutputStream finalPtyStdin = ptyStdin;

        ResultCallback.Adapter<Frame> callback = new ResultCallback.Adapter<Frame>() {
            @Override
            public void onStart(Closeable closeable) {
                logger.info("[EXEC CALLBACK] onStart");
            }

            @Override
            public void onNext(Frame frame) {
                logger.info("[EXEC CALLBACK] onNext: Type={}, Payload={}",
                        frame.getStreamType(),
                        new String(frame.getPayload(), StandardCharsets.UTF_8).trim());
                // Simulate the point where the original error occurred
                // If the connection aborts shortly after this log, it matches the pattern
            }

            @Override
            public void onError(Throwable throwable) {
                logger.error("[EXEC CALLBACK] onError:", throwable);
            }

            @Override
            public void onComplete() {
                logger.info("[EXEC CALLBACK] onComplete");
            }

            @Override
            public void close() throws IOException {
                 logger.info("[EXEC CALLBACK] close");
                 if (finalPtyStdinPipe != null) finalPtyStdinPipe.close(); // Use final reference
                 if (finalPtyStdin != null) finalPtyStdin.close(); // Use final reference
            }
        };

        // Start the exec command
        dockerClient.execStartCmd(execId)
                .withDetach(false)
                .withTty(true)
                .withStdIn(ptyStdinPipe) // Attach the input stream
                .exec(callback);

        logger.info("Exec instance started. Waiting for callback events...");

        // Keep the main thread alive briefly to see callbacks
        Thread.sleep(15000); // Wait 15 seconds

        logger.info("Minimal test finished waiting.");


    } catch (Exception e) {
        logger.error("An error occurred during the test:", e);
    } finally {
        // --- 5. Cleanup ---
        logger.info("Starting cleanup...");
        // Close streams using original variables (which might be null if setup failed)
        if (ptyStdin != null) try { ptyStdin.close(); } catch (IOException e) { /* ignore */ }
        if (ptyStdinPipe != null) try { ptyStdinPipe.close(); } catch (IOException e) { /* ignore */ }

        if (dockerClient != null) {
            if (containerId != null) {
                try {
                    logger.info("Stopping container {}...", containerId);
                    dockerClient.stopContainerCmd(containerId).withTimeout(5).exec();
                } catch (Exception e) {
                    logger.warn("Error stopping container {}: {}", containerId, e.getMessage());
                }
                try {
                    logger.info("Removing container {}...", containerId);
                    dockerClient.removeContainerCmd(containerId).withForce(true).exec();
                } catch (Exception e) {
                    logger.warn("Error removing container {}: {}", containerId, e.getMessage());
                }
            }
            try {
                logger.info("Closing Docker client...");
                dockerClient.close();
            } catch (IOException e) {
                logger.error("Error closing Docker client:", e);
            }
        }
        logger.info("Cleanup finished.");
    }
}