/*-
 * #%L
 * Smile CDR - CDR
 * %%
 * Copyright (C) 2016 - 2025 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.impl.LocalhostSmileHarness;
import ca.cdr.test.app.harness.api.SmileHarness;
import ca.cdr.test.util.PropertiesTestUtil;
import com.apicatalog.jsonld.StringUtils;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.containers.output.OutputFrame;
import org.testcontainers.containers.wait.strategy.LogMessageWaitStrategy;
import org.testcontainers.utility.DockerImageName;
import org.testcontainers.utility.MountableFile;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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.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 DockerImageName DEFAULT_DOCKER_IMAGE_NAME = DockerImageName.parse(DEFAULT_REGISTRY + "/" + DEFAULT_IMAGE + ":" + DEFAULT_TAG);


        private final Map<String, Map<String, Integer>> myPortValues = new HashMap<>();
        private HarnessContext myHarnessContext;
        private String myCustomPropertiesFileLocation;
        private String myCustomLogbackFile;
        private List<String> myCustomerJarNames;

        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 on successful boot message
                LogMessageWaitStrategy logMessageWaitStrategy = new LogMessageWaitStrategy();
                logMessageWaitStrategy.withRegEx(".*Smile, we're up and running.*").withStartupTimeout(Duration.ofMinutes(10));
                waitingFor(logMessageWaitStrategy);

                // Also output logs to stdout to ensure they appear in test output
                withLogConsumer(SmileCdrContainer::accept);
        }


        @Override
        public void start() {
                String logbackXmlFile;

                if (!StringUtils.isBlank(myCustomLogbackFile)) {
                        ourLog.info("Custom properties file provided, using it. [file={}]", myCustomPropertiesFileLocation);
                        logbackXmlFile = myCustomPropertiesFileLocation;
                        MountableFile mountableFile = MountableFile.forClasspathResource(logbackXmlFile);
                        withCopyFileToContainer(mountableFile, "/home/smile/smilecdr/customerlib/all-troubleshooters-enabled-logback.xml");
                } else {
                        ourLog.error("No custom logback file provided, using default logback file. [file={}]", "/all-troubleshooters-enabled-logback.xml");
                }

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

                String propertiesFileLocation = resolvePropertiesFile();
                exposePortsFromPropertiesFile(propertiesFileLocation);
                bootstrapContainerFilesFromProperties(propertiesFileLocation);
                super.start();
        }

        private void bootstrapContainerFilesFromProperties(String thePropertiesFileLocation) {
                try {
                        MountableFile mountableFile = MountableFile.forClasspathResource(thePropertiesFileLocation);

                        // Read the properties file
                        Properties properties = new Properties();
                        try (FileInputStream fis = new FileInputStream(mountableFile.getResolvedPath())) {
                                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:") || value.startsWith("file:"))) {
                                        copyReferencedFileToContainer(value);
                                }
                        }
                } catch (IOException e) {
                        throw new RuntimeException("Failed to process properties file for bootstrap files: " + thePropertiesFileLocation, e);
                }
        }

        private void copyReferencedFileToContainer(String theReference) {
                try {
                        String resourcePath;

                        if (theReference.startsWith("classpath:")) {
                                // Remove "classpath:" prefix and handle leading slash
                                resourcePath = theReference.substring("classpath:".length());
                                if (resourcePath.startsWith("/")) {
                                        resourcePath = resourcePath.substring(1);
                                }
                        } else if (theReference.startsWith("file:")) {
                                // Remove "file:" prefix
                                resourcePath = theReference.substring("file:".length());
                        } else {
                                return; // Not a reference we handle
                        }

                        // Try to find the file on the classpath first
                        try {
                                MountableFile mountableFile = MountableFile.forClasspathResource(resourcePath);
                                String containerPath = "/home/smile/smilecdr/classes/" + resourcePath;
                                withCopyFileToContainer(mountableFile, containerPath);
                                ourLog.info("Copied classpath resource to container: {} -> {}", resourcePath, containerPath);
                        } catch (IllegalArgumentException e) {
                                ourLog.warn("Referenced file not found on classpath: {}", resourcePath);
                        }
                } catch (Exception e) {
                        ourLog.error("Failed to copy referenced file to container: {}", theReference, e);
                }
        }


        private String resolvePropertiesFile() {
                String propertiesFile;
                if (StringUtils.isBlank(myCustomPropertiesFileLocation)) {
                        ourLog.info("No custom properties file provided, using default properties file. [file={}]", "/cdr-config-fallback.properties");
                        propertiesFile = "/cdr-config-fallback.properties";
                } else {
                        ourLog.info("Custom properties file provided, using it. [file={}]", myCustomPropertiesFileLocation);
                        propertiesFile = myCustomPropertiesFileLocation;
                }
                return propertiesFile;
        }

        public SmileCdrContainer withBoundProjectClasspath() {
                String root = Paths.get(".").toAbsolutePath().normalize().toString();
                MountableFile mountableFile = MountableFile.forHostPath(root + "/target/classes");
                withCopyFileToContainer(mountableFile, "/home/smile/smilecdr/classes");
                return this;
        }

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

        public SmileCdrContainer withCustomHarnessContext(HarnessContext theHarnessContext) {
                myHarnessContext = theHarnessContext;
                return this;
        }

        public SmileCdrContainer withPropertiesFile(String thePropertiesFileLocation) {
                myCustomPropertiesFileLocation = thePropertiesFileLocation;
                return this;
        }

        public SmileCdrContainer withCustomLogback(String theCustomLogbackLocation) {
                if (!StringUtils.isBlank(myCustomLogbackFile)) {
                        throw new IllegalStateException("Cannot set a custom logback file when a custom properties file is provided!");
                }
                myCustomLogbackFile = theCustomLogbackLocation;
                return this;
        }

        public SmileCdrContainer withAllTroubleshootingLogsEnabled() {
                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;
        }

        private void exposePortsFromPropertiesFile(String thePropertiesFileLocation) {
                MountableFile mountableFile = MountableFile.forClasspathResource(thePropertiesFileLocation);
                withCopyFileToContainer(mountableFile, "/home/smile/smilecdr/classes/cdr-config-Master.properties");

                Map<String, Map<String, Integer>> portsByModuleType = PropertiesTestUtil.loadPortsFromPropertiesFile(mountableFile.getResolvedPath());

                // Add all ports to myPortValues and expose them
                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);
                }
        }

        public SmileHarness getHarness() {
                if (myHarnessContext == null) {
                        // Find the admin JSON port from the discovered ports
                        Map<String, Integer> adminJsonPorts = myPortValues.get("ADMIN_JSON");
                        Integer adminJsonPort = null;
                        if (adminJsonPorts != null && !adminJsonPorts.isEmpty()) {
                                adminJsonPort = adminJsonPorts.values().iterator().next();
                        }
                        myHarnessContext = new HarnessContext("http", this.getHost(), adminJsonPort, "admin", "password");
                }
                return new LocalhostSmileHarness(myHarnessContext, getPortMapping());
        }

        public Map<Integer, Integer> getPortMapping() {
                return getExposedPorts().stream().collect(Collectors.toMap(port -> port, this::getMappedPort));
        }

        /**
         * 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);
        }

        private static void accept(OutputFrame outputFrame) {
                System.out.print(outputFrame.getUtf8String());
        }

        /**
         * 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 RuntimeException("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 RuntimeException("Error copying JAR files to container from local filesystem", e);
                        }
                }
        }
}