/*-
 * #%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.DockerSmileHarness;
import ca.cdr.test.app.harness.api.SmileHarness;
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);
                super.start();
        }

        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");
                // Read the properties file and extract port values
                try (FileInputStream fis = new FileInputStream(mountableFile.getResolvedPath())) {
                        Properties properties = new Properties();
                        properties.load(fis);

                        // Extract port values from keys containing ".port"
                        for (String key : properties.stringPropertyNames()) {
                                if (key.contains(".port")) {
                                        String value = properties.getProperty(key);
                                        try {
                                                int portValue = Integer.parseInt(value.trim());

                                                // Extract Module ID and Module Type
                                                if (key.startsWith("module.")) {
                                                        String[] parts = key.split("\\.");
                                                        if (parts.length >= 3) {
                                                                String moduleId = parts[1];

                                                                // Get the module type from the properties
                                                                String moduleTypeKey = "module." + moduleId + ".type";
                                                                String moduleType = properties.getProperty(moduleTypeKey);

                                                                if (moduleType != null) {
                                                                        // Add to the map: moduleType -> (moduleId -> port)
                                                                        myPortValues.computeIfAbsent(moduleType, k -> new HashMap<>())
                                                                                .put(moduleId, portValue);
                                                                }
                                                        }
                                                }

                                                // Add the port to exposed ports
                                                addExposedPort(portValue);
                                        } catch (NumberFormatException e) {
                                                // Skip if the port value is not a valid integer
                                        }
                                }
                        }
                } catch (IOException e) {
                        throw new RuntimeException("Failed to read properties file: " + thePropertiesFileLocation, e);
                }
        }

        public SmileHarness getHarness() {
                if (myHarnessContext == null) {
                        myHarnessContext = new HarnessContext("http", this.getHost(), null, "admin", "password");
                }
                return new DockerSmileHarness(myHarnessContext, getPortValuesByModuleType(), 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);
                        }
                }
        }
}