/*-
 * #%L
 * Smile CDR - CDR
 * %%
 * Copyright (C) 2016 - 2026 Smile CDR, Inc.
 * %%
 * All rights reserved.
 * #L%
 */
package ca.cdr.test.extensions;

import ca.cdr.test.app.harness.api.HarnessContext;
import ca.cdr.test.app.harness.api.SmileHarness;
import ca.cdr.test.app.harness.impl.LocalhostSmileHarness;
import ca.cdr.test.util.PropertiesTestUtil;
import ca.cdr.test.util.UrlPathUtil;
import jakarta.annotation.Nonnull;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.containers.output.OutputFrame;
import org.testcontainers.containers.output.WaitingConsumer;
import org.testcontainers.containers.wait.strategy.LogMessageWaitStrategy;
import org.testcontainers.utility.DockerImageName;
import org.testcontainers.utility.MountableFile;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Properties;
import java.util.stream.Collectors;

/**
 * SmileCdrContainer is a container abstraction for orchestrating Smile CDR instances
 * within Docker environments.
 * <p>
 * Instances of this container allow for flexible customization and configuration of
 * Smile CDR images, including properties file specifications, logback configurations,
 * and support for customer JAR files. It supports smooth integration and automated
 * provisioning of Smile CDR services for testing and development environments.
 * <p>
 * The design facilitates:
 * - Configuration of Smile CDR version and the corresponding Docker image.
 * - Mounting of custom resources such as properties files, logback configurations, or JARs.
 * - Automatic setup of exposed ports based on specified or default configurations.
 * - Log consumption to aid in debugging and diagnostics during container runtime.
 * - Ensuring modular support with organized port mapping and harness configuration.
 * <p>
 * This class was generated partly with the help of Claude Sonnet 3.7
 */
public class SmileCdrContainer extends GenericContainer<SmileCdrContainer> {

        private static final Logger ourLog = LoggerFactory.getLogger(SmileCdrContainer.class);
        private static final String DEFAULT_REGISTRY = "docker.smilecdr.com";
        private static final String DEFAULT_IMAGE = "smilecdr";
        private static final String DEFAULT_TAG = "latest";
        private static final String HOST_NETWORK_MODE = "host";
        private static final String CDR_HOME = "/home/smile/smilecdr";
        private static final String DEFAULT_ADMIN_JSON_MODULE_ID = "admin_json";
        private static final String CLASSPATH_PREFIX = "classpath:";
        private static final String FILE_PREFIX = "file:";
        private static final DockerImageName DEFAULT_DOCKER_IMAGE_NAME = DockerImageName.parse(DEFAULT_REGISTRY + "/" + DEFAULT_IMAGE + ":" + DEFAULT_TAG);

        private final Map<String, Map<String, Integer>> myPortValues = new HashMap<>();
        private String myResolvedPropertiesFileLocation;
        private HarnessContext myHarnessContext;
        private LocalhostSmileHarness myHarness;
        private String myCustomPropertiesFileLocation;
        private Path myCustomPropertiesFilePath;
        private String myCustomLogbackFile;
        private Path myCustomLogbackFilePath;
        private List<String> myCustomerJarNames;
        private boolean myDebugEnabled = false;
        private boolean myDebugSuspendUntilDebuggerAttached = true;
        private static final int DEBUG_PORT = 5005;

        public SmileCdrContainer() {
                this(DEFAULT_DOCKER_IMAGE_NAME);
        }

        /**
         * Use this constructor to change the version of Smile CDR, but use Smile's container registry.
         */
        public SmileCdrContainer(String theSmileCdrVersion) {
                this(new DockerImageName(DEFAULT_REGISTRY + "/" + DEFAULT_IMAGE + ":" + theSmileCdrVersion));

        }

        /**
         * Use this constructor to provide a completely custom Docker Image Name to use. Use this if you need to use your own private registry
         */
        public SmileCdrContainer(DockerImageName imageName) {
                super(imageName);
                // Wait for startup completion (success or failure)
                LogMessageWaitStrategy logMessageWaitStrategy = new LogMessageWaitStrategy();
                logMessageWaitStrategy.withRegEx(".*(Smile, we're up and running|Smile started with errors).*").withStartupTimeout(Duration.ofMinutes(3));
                waitingFor(logMessageWaitStrategy);

                // Also output logs to stdout to ensure they appear in test output
                withLogConsumer(new WaitingConsumer() {
                        @Override
                        public void accept(OutputFrame theFrame) {
                                System.out.printf("Container[%s]: %s", getContainerName(), theFrame.getUtf8String());
                        }
                });
        }


        @Override
        public void start() {
                copyCustomLogbackConfiguration();

                // Copy JAR files from cdr-interceptor-starterproject/target to the container
                copyCustomerJars();
                copyPropertiesFileAndResolveReferences();

                if (myDebugEnabled) {
                        ourLog.info("Debug mode enabled - container is accessible for debuggers on port {}", DEBUG_PORT);
                        if (!isHostNetwork()) {
                                addFixedExposedPort(DEBUG_PORT, DEBUG_PORT);
                        }
                        String jvmArgs = buildJvmArgs();
                        ourLog.info("JVMARGS is now set to: {}", jvmArgs);
                        withEnv("JVMARGS", jvmArgs);
                        if (myDebugSuspendUntilDebuggerAttached) {
                                ourLog.warn("==========================================");
                                ourLog.warn("DEBUG MODE(suspend): Container will wait for debugger");
                                ourLog.warn("Connect your IDE debugger to: localhost:{}", DEBUG_PORT);
                                ourLog.warn("Container will resume after debugger attaches");
                                ourLog.warn("==========================================");
                        }
                }
                super.start();
        }

        private void copyCustomLogbackConfiguration() {
                MountableFile mountableFile;
                if (myCustomLogbackFilePath != null) {
                        ourLog.info("Custom logback file provided, using it. [file={}]", myCustomLogbackFilePath);
                        mountableFile = MountableFile.forHostPath(myCustomLogbackFilePath);
                } else if (!StringUtils.isBlank(myCustomLogbackFile)) {
                        ourLog.info("Custom logback file provided, using it. [file={}]", myCustomLogbackFile);
                        mountableFile = MountableFile.forClasspathResource(myCustomLogbackFile);
                } else {
                        ourLog.info("No custom logback file provided, using default logback file. [file={}]", "/all-troubleshooters-enabled-logback.xml");
                        mountableFile = MountableFile.forClasspathResource("/all-troubleshooters-enabled-logback.xml");
                }
                withCopyFileToContainer(mountableFile, CDR_HOME + "/customerlib/logback-smile-custom.xml");
        }

        private void copyPropertiesFileAndResolveReferences() {
                MountableFile mountableFile = resolvePropertiesFile();
                withCopyFileToContainer(mountableFile, CDR_HOME + "/classes/cdr-config-Master.properties");

                myResolvedPropertiesFileLocation = mountableFile.getResolvedPath();
                exposePortsFromPropertiesFile(mountableFile.getResolvedPath());
                bootstrapContainerFilesFromProperties(mountableFile.getResolvedPath());
        }

        private String buildJvmArgs() {
                return new StringBuilder()
                        .append("-agentlib:jdwp=transport=dt_socket,server=y,suspend=")
                        .append(myDebugSuspendUntilDebuggerAttached ? "y": "n")
                        .append(",address=*:")
                        .append(DEBUG_PORT)
                        .toString();
        }

        private void bootstrapContainerFilesFromProperties(String thePropertiesFileLocation) {
                try {
                        // Read the properties file
                        Properties properties = new Properties();
                        try (FileInputStream fis = new FileInputStream(thePropertiesFileLocation)) {
                                properties.load(fis);
                        }

                        // Look for classpath and file references in property values
                        for (String key : properties.stringPropertyNames()) {
                                String value = properties.getProperty(key);
                                if (value != null && (value.startsWith(CLASSPATH_PREFIX) || value.startsWith(FILE_PREFIX))) {
                                        copyReferencedFileToContainer(value);
                                }
                        }
                } catch (IOException e) {
                        throw new IllegalArgumentException("Failed to process properties file for bootstrap files: " + thePropertiesFileLocation, e);
                }
        }

        private void copyReferencedFileToContainer(String theReference) {
                String resourcePath;
                if (theReference.startsWith(CLASSPATH_PREFIX)) {
                        resourcePath = StringUtils.stripStart(theReference.substring(CLASSPATH_PREFIX.length()), "/");
                } else if (theReference.startsWith(FILE_PREFIX)) {
                        String filePath = theReference.substring(FILE_PREFIX.length());
                        if (copyHostFileToContainer(filePath)) {
                                return;
                        }
                        resourcePath = StringUtils.stripStart(filePath, "/");
                } else {
                        return;
                }

                String containerPath = containerPathForReference(theReference);
                try {
                        MountableFile mountableFile = MountableFile.forClasspathResource(resourcePath);
                        withCopyFileToContainer(mountableFile, containerPath);
                        ourLog.info("Copied classpath resource to container: {} -> {}", resourcePath, containerPath);
                } catch (IllegalArgumentException e) {
                        // Many references name resources that ship inside the Smile CDR image itself.
                        ourLog.info("Referenced file is not on the test classpath, leaving it to the image: {}", theReference);
                }
        }

        /**
         * Copies a {@code file:} reference from the host, to the path Smile CDR will read it from:
         * the same absolute path, or a relative path resolved against the Smile CDR home directory.
         * Relative paths are looked up on the host relative to the working directory.
         *
         * @return true if the file was found on the host
         */
        private boolean copyHostFileToContainer(String theFilePath) {
                Path hostPath = Paths.get(theFilePath);
                if (!Files.exists(hostPath)) {
                        return false;
                }
                String containerPath = fileReferenceContainerPath(theFilePath);
                withCopyFileToContainer(MountableFile.forHostPath(hostPath), containerPath);
                ourLog.info("Copied host file to container: {} -> {}", hostPath, containerPath);
                return true;
        }

        /**
         * Where Smile CDR reads a {@code classpath:} or {@code file:} reference from. A {@code file:}
         * reference lands there whether it was found on the host or, failing that, on the classpath.
         *
         * @throws IllegalArgumentException for a value that is neither kind of reference
         */
        static String containerPathForReference(String theReference) {
                if (theReference.startsWith(CLASSPATH_PREFIX)) {
                        return CDR_HOME + "/classes/"
                                + StringUtils.stripStart(theReference.substring(CLASSPATH_PREFIX.length()), "/");
                }
                if (theReference.startsWith(FILE_PREFIX)) {
                        return fileReferenceContainerPath(theReference.substring(FILE_PREFIX.length()));
                }
                throw new IllegalArgumentException("Not a classpath: or file: reference: " + theReference);
        }

        /**
         * Where Smile CDR reads a {@code file:} reference from: the same absolute path, or a relative path
         * resolved against the Smile CDR home directory.
         */
        private static String fileReferenceContainerPath(String theFilePath) {
                return Paths.get(theFilePath).isAbsolute() ? theFilePath : CDR_HOME + "/" + theFilePath;
        }


        private MountableFile resolvePropertiesFile() {
                if (myCustomPropertiesFilePath != null) {
                        ourLog.info("Custom properties file provided, using it. [file={}]", myCustomPropertiesFilePath);
                        return MountableFile.forHostPath(myCustomPropertiesFilePath);
                }
                if (StringUtils.isBlank(myCustomPropertiesFileLocation)) {
                        ourLog.info("No custom properties file provided, using default properties file. [file={}]", "/cdr-config-fallback.properties");
                        return MountableFile.forClasspathResource("/cdr-config-fallback.properties");
                }
                ourLog.info("Custom properties file provided, using it. [file={}]", myCustomPropertiesFileLocation);
                return MountableFile.forClasspathResource(myCustomPropertiesFileLocation);
        }

        /**
         * Binds the target/classes and target/test-classes directories into the container's `/classes` directory.
         * Only mounts directories if they exist and are non-empty.
         * @return the SmileCdrContainer.
         */
        public SmileCdrContainer withBoundProjectClasspath() {
                String root = Paths.get(".").toAbsolutePath().normalize().toString();

                Path classesPath = Paths.get(root, "target", "classes");
                if (Files.exists(classesPath) && isDirectoryNonEmpty(classesPath)) {
                        MountableFile mountableFile = MountableFile.forHostPath(classesPath.toString());
                        withCopyFileToContainer(mountableFile, "/home/smile/smilecdr/classes");
                        ourLog.info("Mounted target/classes directory to container");
                } else {
                        ourLog.info("Skipping target/classes mount - directory does not exist or is empty");
                }

                Path testClassesPath = Paths.get(root, "target", "test-classes");
                if (Files.exists(testClassesPath) && isDirectoryNonEmpty(testClassesPath)) {
                        MountableFile testMountableFile = MountableFile.forHostPath(testClassesPath.toString());
                        withCopyFileToContainer(testMountableFile, "/home/smile/smilecdr/classes");
                        ourLog.info("Mounted target/test-classes directory to container");
                } else {
                        ourLog.info("Skipping target/test-classes mount - directory does not exist or is empty");
                }

                return this;
        }

        /**
         * Checks if a directory is non-empty by attempting to read at least one entry.
         * @param thePath the directory path to check
         * @return true if the directory contains at least one file or subdirectory, false otherwise
         */
        private boolean isDirectoryNonEmpty(Path thePath) {
                try (var stream = Files.list(thePath)) {
                        return stream.findFirst().isPresent();
                } catch (IOException e) {
                        ourLog.warn("Error checking if directory is non-empty: {}", thePath, e);
                        return false;
                }
        }

        public SmileCdrContainer withPreseedFiles(String... filesToMount) {
                for (String fileToMount : filesToMount) {
                        MountableFile mountableFile = MountableFile.forClasspathResource(fileToMount);
                        withCopyFileToContainer(mountableFile, "/home/smile/smilecdr/classes/config_seeding/");
                }
                return this;
        }

        /**
         * Sets the {@link HarnessContext} the harness is built from. Discards any harness already handed
         * out, so that a context set after the first {@link #getHarness()} still takes effect rather
         * than being silently ignored.
         */
        public synchronized @Nonnull SmileCdrContainer withCustomHarnessContext(@Nonnull HarnessContext theHarnessContext) {
                closeHarness();
                myHarnessContext = theHarnessContext;
                return this;
        }

        /**
         * Uses a properties file from the classpath as the container's {@code cdr-config-Master.properties}.
         */
        public SmileCdrContainer withPropertiesFile(String thePropertiesFileLocation) {
                myCustomPropertiesFileLocation = thePropertiesFileLocation;
                myCustomPropertiesFilePath = null;
                return this;
        }

        /**
         * Uses a properties file from the host filesystem as the container's
         * {@code cdr-config-Master.properties}, for configuration that is generated or selected at runtime
         * rather than packaged on the test classpath.
         */
        public SmileCdrContainer withPropertiesFile(@Nonnull Path thePropertiesFile) {
                myCustomPropertiesFilePath = thePropertiesFile;
                myCustomPropertiesFileLocation = null;
                return this;
        }

        public SmileCdrContainer withCustomLogback(String theCustomLogbackLocation) {
                requireNoCustomLogback();
                myCustomLogbackFile = theCustomLogbackLocation;
                return this;
        }

        /**
         * Uses a logback configuration from the host filesystem as the container's
         * {@code customerlib/logback-smile-custom.xml}.
         */
        public SmileCdrContainer withCustomLogback(@Nonnull Path theCustomLogbackFile) {
                requireNoCustomLogback();
                myCustomLogbackFilePath = theCustomLogbackFile;
                return this;
        }

        private void requireNoCustomLogback() {
                if (!StringUtils.isBlank(myCustomLogbackFile) || myCustomLogbackFilePath != null) {
                        throw new IllegalStateException("A custom logback file has already been set");
                }
        }

        public SmileCdrContainer withAllTroubleshootingLogsEnabled() {
                requireNoCustomLogback();
                myCustomLogbackFile = "/all-troubleshooters-enabled-logback.xml";
                return this;
        }

        /**
         * Specifies which JAR files from the cdr-interceptor-starterproject's target folder should be copied
         * into the SmileCdrContainer at /home/smile/smilecdr/customerlib/.
         * <p>
         * First looks in the classpath for a jar with a given name. If it does not find one,
         * it also looks in the target/ directory. If it still doesn't find one, then it fails.
         *
         * @param theJarNames A comma-separated list of JAR filenames to copy. If null or empty, all JAR files
         *                    in the target directory will be copied.
         * @return This container instance for method chaining
         */
        public SmileCdrContainer withCustomerJars(String... theJarNames) {
                if (theJarNames != null && theJarNames.length > 0) {
                        myCustomerJarNames = Arrays.stream(theJarNames)
                                .map(String::trim)
                                .filter(s -> !s.isEmpty())
                                .collect(Collectors.toList());

                        ourLog.info("Registered {} JAR file(s) to be mounted into customerlib", myCustomerJarNames.size());
                }
                return this;
        }

        /**
         * Enables remote debugging for the Smile CDR instance running in this container.
         * When enabled, the container will expose port 5005 (fixed mapping) and wait for a debugger to attach
         * before completing startup (suspend=y).
         *
         * <h3>How to Connect IntelliJ IDEA Debugger:</h3>
         * <ol>
         *   <li>Run → Edit Configurations → Add New → Remote JVM Debug</li>
         *   <li>Set Host: localhost (or container host)</li>
         *   <li>Set Port: 5005 (always fixed to this port)</li>
         *   <li>Set Debugger mode: Attach to remote JVM</li>
         *   <li>Click Debug - the container will resume startup once debugger connects</li>
         * </ol>
         *
         * <h3>Example Usage:</h3>
         * <pre>
         * {@code
         * @Container
         * SmileCdrContainer container = new SmileCdrContainer()
         *     .withPropertiesFile("/my-config.properties")
         *     .withDebugEnabled();
         *
         * // Port 5005 is always used - no need to query for mapped port
         * // Just connect your debugger to localhost:5005
         * }
         * </pre>
         *
         * <p><strong>IMPORTANT:</strong> The container will pause during startup until a debugger
         * connects. This is intentional to allow setting breakpoints before code execution begins.
         * Port 5005 must be available on the host machine.</p>
         *
         * @return This container instance for method chaining
         */
        public SmileCdrContainer withDebugEnabled() {
                return withDebugEnabled(true);
        }

        /**
         * Enables remote debugging for the Smile CDR instance running in this container.
         * When enabled, the container will expose port 5005 (fixed mapping).
         *
         * - If `theSuspendUntilDebuggerAttached` is true, the container will pause until a debugger is connected.
         * - If `theSuspendUntilDebuggerAttached` is false, the container will boot without waiting for the debugger.
         *
         *
         * <h3>How to Connect IntelliJ IDEA Debugger:</h3>
         * <ol>
         *   <li>Run → Edit Configurations → Add New → Remote JVM Debug</li>
         *   <li>Set Host: localhost (or container host)</li>
         *   <li>Set Port: 5005 (always fixed to this port)</li>
         *   <li>Set Debugger mode: Attach to remote JVM</li>
         *   <li>Click Debug - the container will resume startup once debugger connects</li>
         * </ol>
         *
         * <h3>Example Usage:</h3>
         * <pre>
         * {@code
         * @Container
         * SmileCdrContainer container = new SmileCdrContainer()
         *     .withPropertiesFile("/my-config.properties")
         *     .withDebugEnabled(false);
         *
         * // Port 5005 is always used - no need to query for mapped port
         * // Just connect your debugger to localhost:5005
         * }
         * </pre>
         *
         * <p><strong>IMPORTANT:</strong> If you have set `theSuspendUntilDebuggerAttached` to True,
         * the container will pause during startup until a debugger
         * connects. This is intentional to allow setting breakpoints before code execution begins.
         * Port 5005 must be available on the host machine.</p>
         *
         * @param theSuspendUntilDebuggerAttached if set to true, blocks the container startup until a debugger connects.
         *
         * @return This container instance for method chaining
         */
        public SmileCdrContainer withDebugEnabled(boolean theSuspendUntilDebuggerAttached) {
                myDebugEnabled = true;
                myDebugSuspendUntilDebuggerAttached = theSuspendUntilDebuggerAttached;
                return this;
        }

        private void exposePortsFromPropertiesFile(String thePropertiesFileLocation) {
                Map<String, Map<String, Integer>> portsByModuleType = PropertiesTestUtil.loadPortsFromPropertiesFile(thePropertiesFileLocation);

                // On the host network the modules bind host ports directly; Docker maps nothing, so
                // exposing ports would leave Testcontainers waiting for mappings that never appear.
                if (!isHostNetwork()) {
                        for (Map<String, Integer> modulePortMap : portsByModuleType.values()) {
                                for (Integer portValue : modulePortMap.values()) {
                                        addExposedPort(portValue);
                                }
                        }
                }

                // Merge the loaded ports into myPortValues
                for (Map.Entry<String, Map<String, Integer>> entry : portsByModuleType.entrySet()) {
                        String moduleType = entry.getKey();
                        Map<String, Integer> modulePorts = entry.getValue();
                        myPortValues.computeIfAbsent(moduleType, k -> new HashMap<>()).putAll(modulePorts);
                }
        }

        /**
         * Returns this container's harness, creating it on first call.
         * <p>
         * The harness is cached because it owns an HTTP connection pool and a cookie store: handing
         * out a fresh one per call would mean each caller got its own session, which any multi-request
         * login flow depends on sharing. The cached harness is closed and discarded when the container
         * stops, so a restarted container gets a harness bound to its new port mapping.
         * <p>
         * A harness reads the node's modules and their ports once, when it is built. A test that adds,
         * removes or re-ports a module through the Admin JSON API must therefore call
         * {@link #refreshHarness()}; calling {@code getHarness()} again returns the same harness, still
         * holding the configuration from before the change.
         * <p>
         * A harness a caller closed itself is replaced rather than handed back: {@link SmileHarness} is
         * {@link AutoCloseable}, so a try-with-resources around this call would otherwise shut the
         * connection pool and leave every later call returning a harness whose every request fails.
         */
        public synchronized @Nonnull SmileHarness getHarness() {
                if (myHarness != null && myHarness.isClosed()) {
                        myHarness = null;
                }
                if (myHarness == null) {
                        if (myHarnessContext == null) {
                                // Find the admin JSON port from the discovered ports
                                Optional<Map.Entry<String, Integer>> adminJsonModule = adminJsonModule(myPortValues.get("ADMIN_JSON"));
                                Integer adminJsonPort = null;
                                String adminJsonContextPath = "";
                                if (adminJsonModule.isPresent()) {
                                        Map.Entry<String, Integer> adminJson = adminJsonModule.get();
                                        adminJsonPort = adminJson.getValue();
                                        if (myResolvedPropertiesFileLocation != null) {
                                                adminJsonContextPath = UrlPathUtil.normalizeContextPath(
                                                        PropertiesTestUtil.loadContextPath(myResolvedPropertiesFileLocation, adminJson.getKey()));
                                        }
                                }
                                myHarnessContext = new HarnessContext(
                                        "http", this.getHost(), adminJsonPort, "admin", "password", adminJsonContextPath);
                        }
                        myHarness = new LocalhostSmileHarness(myHarnessContext, getPortMapping());
                }
                return myHarness;
        }

        /**
         * The Admin JSON module the harness is built against when the properties file configures several:
         * {@code admin_json} if present, otherwise the lowest module ID. A properties file has no order
         * of its own to fall back on.
         */
        static Optional<Map.Entry<String, Integer>> adminJsonModule(Map<String, Integer> theAdminJsonPorts) {
                if (theAdminJsonPorts == null || theAdminJsonPorts.isEmpty()) {
                        return Optional.empty();
                }
                if (theAdminJsonPorts.containsKey(DEFAULT_ADMIN_JSON_MODULE_ID)) {
                        return Optional.of(Map.entry(DEFAULT_ADMIN_JSON_MODULE_ID, theAdminJsonPorts.get(DEFAULT_ADMIN_JSON_MODULE_ID)));
                }
                return theAdminJsonPorts.entrySet().stream().min(Map.Entry.comparingByKey()).map(e -> Map.entry(e.getKey(), e.getValue()));
        }

        /**
         * Discards the cached harness and builds a replacement, which rediscovers the node's modules and
         * ports. Call this after changing module configuration through the Admin JSON API.
         * <p>
         * Any session held by the old harness ends with it, and any reference still pointing at it is
         * dead — use the returned harness rather than the one you were holding.
         *
         * @return the replacement harness, already bound to the node's current configuration
         */
        public synchronized @Nonnull SmileHarness refreshHarness() {
                closeHarness();
                return getHarness();
        }

        @Override
        public void stop() {
                closeHarness();
                super.stop();
        }

        private synchronized void closeHarness() {
                if (myHarness == null) {
                        return;
                }
                try {
                        myHarness.close();
                } catch (RuntimeException e) {
                        // Never let a teardown failure mask whatever the caller was actually doing.
                        ourLog.warn("Failed to close the harness", e);
                } finally {
                        myHarness = null;
                }
        }

        /**
         * Maps each port a module listens on inside the container to the port it is reachable on from the
         * host. On the host network ({@code withNetworkMode("host")}) every port maps to itself.
         */
        public Map<Integer, Integer> getPortMapping() {
                if (isHostNetwork()) {
                        return myPortValues.values().stream()
                                .flatMap(modulePorts -> modulePorts.values().stream())
                                .distinct()
                                .collect(Collectors.toMap(port -> port, port -> port));
                }
                return getExposedPorts().stream().collect(Collectors.toMap(port -> port, this::getMappedPort));
        }

        private boolean isHostNetwork() {
                return HOST_NETWORK_MODE.equals(getNetworkMode());
        }

        /**
         * Gets the port values organized by Module Type and Module ID.
         *
         * @return A map where the key is the Module Type and the value is a map of Module ID to port
         */
        public Map<String, Map<String, Integer>> getPortValuesByModuleType() {
                return new HashMap<>(myPortValues);
        }

        /**
         * Copies JAR files from the cdr-interceptor-starterproject's target directory to the container.
         * If myCustomerJarNames is not null, only the specified JAR files will be copied.
         * Otherwise, all JAR files in the target directory will be copied.
         * <p>
         * First attempts to load JAR files from the classpath using MountableFile.forClasspathResource().
         * If that fails (because the JAR file is not on the classpath), falls back to using MountableFile.forHostPath().
         * If a JAR is not found in either location, throws a RuntimeException.
         */
        private void copyCustomerJars() {
                // If specific JAR names are provided, try to load them from the classpath first
                if (myCustomerJarNames != null && !myCustomerJarNames.isEmpty()) {
                        List<String> jarsFoundOnClasspath = new ArrayList<>();
                        List<String> jarsNotFoundOnClasspath = new ArrayList<>();

                        for (String jarName : myCustomerJarNames) {
                                try {
                                        ourLog.info("Attempting to load JAR file from classpath: {}", jarName);
                                        MountableFile mountableFile = MountableFile.forClasspathResource(jarName);
                                        withCopyFileToContainer(mountableFile, "/home/smile/smilecdr/customerlib/" + jarName);
                                        jarsFoundOnClasspath.add(jarName);
                                } catch (IllegalArgumentException e) {
                                        ourLog.info("JAR file not found on classpath: {}. Will try local filesystem.", jarName);
                                        jarsNotFoundOnClasspath.add(jarName);
                                }
                        }

                        // If all JARs were found on the classpath, we're done
                        if (jarsNotFoundOnClasspath.isEmpty()) {
                                ourLog.info("All specified JAR files were loaded from the classpath.");
                                return;
                        }

                        // Fall back to loading from the local filesystem for JARs not found on classpath
                        try {
                                // Find the cdr-interceptor-starterproject directory
                                Path projectRoot = Paths.get(".");
                                Path targetDir = projectRoot.resolve("target");

                                if (!Files.exists(targetDir)) {
                                        throw new IllegalArgumentException("Could not find target directory. The following JAR files were not found on the classpath: " + jarsNotFoundOnClasspath);
                                }

                                // Get all JAR files in the target directory
                                List<File> jarFiles;
                                try (var paths = Files.list(targetDir)) {
                                        jarFiles = paths
                                                .filter(path -> path.toString().endsWith(".jar"))
                                                .map(Path::toFile)
                                                .toList();
                                }

                                if (jarFiles.isEmpty()) {
                                        throw new IllegalArgumentException("No JAR files found in target directory. The following JAR files were not found on the classpath: " + jarsNotFoundOnClasspath);
                                }

                                // Filter JAR files based on jarsNotFoundOnClasspath
                                List<File> filesToCopy = jarFiles.stream()
                                        .filter(file -> jarsNotFoundOnClasspath.contains(file.getName()))
                                        .toList();

                                // Check if all JARs not found on classpath were found in target directory
                                if (filesToCopy.size() < jarsNotFoundOnClasspath.size()) {
                                        List<String> jarsNotFound = new ArrayList<>(jarsNotFoundOnClasspath);
                                        jarsNotFound.removeAll(filesToCopy.stream().map(File::getName).toList());
                                        throw new IllegalArgumentException("The following JAR files were not found in either the classpath or the target directory: " + jarsNotFound);
                                }

                                for (File jarFile : filesToCopy) {
                                        ourLog.info("Copying JAR file from local filesystem to container: {}", jarFile.getName());
                                        MountableFile mountableFile = MountableFile.forHostPath(jarFile.toPath());
                                        withCopyFileToContainer(mountableFile, "/home/smile/smilecdr/customerlib/" + jarFile.getName());
                                }

                                ourLog.info("Copied {} JAR file(s) to container from local filesystem", filesToCopy.size());
                        } catch (IOException e) {
                                throw new IllegalArgumentException("Error copying JAR files to container from local filesystem", e);
                        }
                }
        }
}