package eu.cqse.check.framework.core.registry;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.conqat.lib.commons.collections.CollectionUtils;
import org.conqat.lib.commons.filesystem.ClassPathUtils;
import org.conqat.lib.commons.filesystem.FileSystemUtils;

import com.teamscale.commons.annotation.ClassIndexUtils;

import eu.cqse.check.framework.core.Check;
import eu.cqse.check.framework.core.CheckException;
import eu.cqse.check.framework.core.CheckImplementationBase;
import eu.cqse.check.framework.core.CheckInfo;
import eu.cqse.check.framework.core.CheckInstance;
import eu.cqse.check.framework.core.ECheckParameter;
import eu.cqse.check.framework.core.phase.IGlobalExtractionPhase;
import eu.cqse.check.framework.scanner.ELanguage;
import eu.cqse.check.framework.shallowparser.ShallowParserFactory;
import eu.cqse.check.util.clang.ClangUtils;

/**
 * Registry singleton that manages custom checks.
 */
public class CheckRegistry {

        private static final Logger LOGGER = LogManager.getLogger();

        /** The singleton instance. */
        private static CheckRegistry instance = null;

        /** Mapping from check identifiers to the check information. */
        private final Map<String, CheckInfo> checksInfo = new HashMap<>();

        private final Map<String, Class<? extends IGlobalExtractionPhase<?, ?>>> checkPhases = new HashMap<>();

        /**
         * Hidden constructor to avoid multiple instantiation, should be accessed via
         * {@link #getInstance()} in application code. Test for this package may access
         * the constructor.
         */
        /* package */ CheckRegistry() {
                // do nothing
        }

        /** Returns the singleton instance. */
        public static synchronized CheckRegistry getInstance() {
                if (instance == null) {
                        instance = new CheckRegistry();
                }
                return instance;
        }

        /**
         * Registers custom checks from the given package. Classes are discovered via
         * the service loader mechanism. Therefore the checks must be annotated with
         * {@link Check}.
         * <p>
         * Uses the current thread's class loader for loading the checks. This means the
         * classes directory needs to be already on the class path.
         */
        public void registerChecksByServiceLoader(String fullPackageName) {
                Iterable<Class<?>> classNames = ClassIndexUtils.getAnnotated(Check.class);
                for (Class<?> className : classNames) {
                        try {
                                if (className.getPackage().getName().startsWith(fullPackageName)) {
                                        loadCheckFromClass(className);
                                }
                        } catch (NoClassDefFoundError | IOException e) {
                                LOGGER.error("Failed to load check from class: " + className, e);
                        }
                }
        }

        /**
         * Registers the given bundle and loads all classes from the given bundle that
         * implement {@link CheckImplementationBase} and are annotated with
         * {@link Check}.
         * <p>
         * Uses the current thread's class loader for loading the checks. This means the
         * classes directory needs already on the class path.
         */
        public void registerChecksFromClasspathDirectory(File classesDirectory) {
                ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
                try {
                        registerChecksFromClasspathDirectory(classesDirectory, classLoader);
                } catch (IOException e) {
                        LOGGER.error("Failed to load checks directory: " + classesDirectory, e);
                }
        }

        /**
         * Uses the provided {@link ClassLoader} for loading the checks.
         *
         * @see #registerChecksFromClasspathDirectory(File)
         */
        private void registerChecksFromClasspathDirectory(File classesDirectory, ClassLoader classLoader)
                        throws IOException {
                List<String> classNames = ClassPathUtils.getClassNames(classesDirectory);
                for (String className : classNames) {
                        try {
                                loadCheckFromClass(classLoader.loadClass(className));
                        } catch (ClassNotFoundException | NoClassDefFoundError e) {
                                LOGGER.error("Failed to load check from class: " + className, e);
                        }
                }
        }

        /**
         * Searches the given directory for Jar files or classes directories containing
         * custom checks.
         * <p>
         * This supports registering Jars as well as compiled classes in a 'classes'
         * directory (e.g. from an Eclipse project). Both are searched recursively, but
         * whenever a folder contains a classes directory scanning for Jars and further
         * classes directories is skipped. The restriction results from jar files being
         * placed e.g by Gradle in the 'build' output of source projects, which would
         * then be picked up and lead to problems. The same applies to the classes
         * folder in the Gradle build output.
         * <p>
         * The found jars and classes directories will be put on the classpath (using a
         * separate classloader).
         */
        public void registerCheckDirectory(File customChecksDirectory) {
                if (!customChecksDirectory.canRead()) {
                        LOGGER.error("Cannot read from custom check directory: " + customChecksDirectory.getAbsolutePath());
                        return;
                }

                try {
                        Files.walkFileTree(customChecksDirectory.toPath(), new CustomCheckLoader());
                } catch (IOException e) {
                        LOGGER.error("Cannot traverse custom check directory: " + customChecksDirectory.getAbsolutePath());
                }
        }

        /** Loads custom checks from the given Jar file. */
        public void loadChecksFromJar(File jarFile) {

                try {
                        // Don't use try-with-resources here, because we deliberately want the
                        // URLClassLoader to remain unclosed.
                        // https://docs.oracle.com/javase/7/docs/api/java/net/URLClassLoader.html#close()
                        URLClassLoader classLoader = createClassLoader(jarFile);

                        for (String className : FileSystemUtils.listTopLevelClassesInJarFile(jarFile)) {
                                loadCheckFromClass(classLoader.loadClass(className));
                        }
                } catch (IOException | ClassNotFoundException e) {
                        LOGGER.error("Error loading custom checks from jar '" + jarFile + "': " + e.toString(), e);
                }
        }

        /** Loads custom checks from the given classes directory. */
        private void loadChecksFromClasses(File classesDir) {
                try {
                        registerChecksFromClasspathDirectory(classesDir, createClassLoader(classesDir));
                } catch (IOException e) {
                        LOGGER.error("Error loading custom checks classes dir '" + classesDir + "': " + e.toString(), e);
                }
        }

        /** Creates a class loader for the jar file or directory path. */
        private static URLClassLoader createClassLoader(File classpath) throws MalformedURLException {
                ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
                return new URLClassLoader(new URL[] { classpath.toURI().toURL() }, contextClassLoader);
        }

        /**
         * Creates and registers a custom check instance from the given class. If the
         * given class does not contain a custom check (class not annotated with
         * {@link Check}), this method does nothing.
         */
        private void loadCheckFromClass(Class<?> clazz) throws IOException {
                CheckInfo checkInfo;
                try {
                        checkInfo = CheckLoader.loadFromClass(clazz);
                } catch (CheckException e) {
                        LOGGER.error(e.getMessage(), e);
                        return;
                }

                if (checkInfo == null) {
                        return;
                }

                if (checksInfo.containsKey(checkInfo.getIdentifier())) {
                        LOGGER.error("Check " + checkInfo.getGroupName() + ":" + checkInfo.getName() + " is already registered.");
                        return;
                }
                for (Class<? extends IGlobalExtractionPhase<?, ?>> phase : checkInfo.getRequiredPhases()) {
                        Class<? extends IGlobalExtractionPhase<?, ?>> existingPhase = checkPhases.get(phase.getName());
                        if (existingPhase != null && existingPhase != phase) {
                                throw new IOException(
                                                "Check phase '" + phase.getName() + "' registered twice via different classloaders.");
                        }
                        if (checkPhaseIsValid(phase)) {
                                checkPhases.put(phase.getName(), phase);
                        } else {
                                LOGGER.error("Skipping registration of check phase " + phase.getName());
                        }
                }
                checksInfo.put(checkInfo.getIdentifier(), checkInfo);
        }

        /**
         * Instantiates and validates the given {@link IGlobalExtractionPhase}. Returns
         * false if the phase can't be instantiated or if the check phase is not
         * configured correctly. Logs an error in both cases.
         */
        private static boolean checkPhaseIsValid(Class<? extends IGlobalExtractionPhase<?, ?>> phase) {
                try {
                        IGlobalExtractionPhase<?, ?> phaseInstance = phase.newInstance();
                        for (ECheckParameter parameter : phaseInstance.getRequiredContextParameters()) {
                                if (!checkPhaseParameterIsValid(phaseInstance, parameter)) {
                                        return false;
                                }
                        }
                        return true;
                } catch (IllegalAccessException | InstantiationException e) {
                        LOGGER.error("Could not instantiate check phase " + phase.getName(), e);
                        return false;
                }
        }

        /**
         * Returns whether the given ECheckParameter is valid in the given
         * {@link IGlobalExtractionPhase}. Logs an error if not.
         */
        private static boolean checkPhaseParameterIsValid(IGlobalExtractionPhase<?, ?> phaseInstance,
                        ECheckParameter parameter) {
                switch (parameter) {
                case ABSTRACT_SYNTAX_TREE:
                        // fall through intended, both need parsing
                case TYPE_RESOLUTION:
                        if (!allPhaseLanguagesSupportParsing(phaseInstance)) {
                                return false;
                        }
                        break;
                case CLANG:
                        if (!allPhaseLanguagesSupportClang(phaseInstance)) {
                                return false;
                        }
                        break;
                default:
                        LOGGER.error(parameter.name() + " must be a new check parameter. Please add validation case.");
                        return false;
                }
                return true;
        }

        /**
         * Returns whether all languages selected by the given phaseInstance support
         * Clang processing. Logs an error if not.
         */
        private static boolean allPhaseLanguagesSupportClang(IGlobalExtractionPhase<?, ?> phaseInstance) {
                EnumSet<ELanguage> invalidLanguages = phaseInstance.getLanguages();
                invalidLanguages.removeAll(ClangUtils.CLANG_ENABLED_LANGUAGES);
                if (!invalidLanguages.isEmpty()) {
                        LOGGER.error("Check phase " + phaseInstance.getClass().getName()
                                        + " requires CLANG but selects languages without clang support: " + invalidLanguages);
                        return false;
                }
                return true;
        }

        /**
         * Returns whether all languages selected by the given phaseInstance have a
         * ShallowParser. Logs an error if not.
         */
        private static boolean allPhaseLanguagesSupportParsing(IGlobalExtractionPhase<?, ?> phaseInstance) {
                EnumSet<ELanguage> invalidLanguages = phaseInstance.getLanguages();
                invalidLanguages.removeAll(ShallowParserFactory.getSupportedLanguages());
                if (!invalidLanguages.isEmpty()) {
                        LOGGER.error("Check phase " + phaseInstance.getClass().getName()
                                        + " requires AST but selects languages without parser: " + invalidLanguages);
                        return false;
                }
                return true;
        }

        /**
         * Returns the check phase class with the given full qualified name or
         * <code>null</code> if no such phase exists.
         */
        public Class<? extends IGlobalExtractionPhase<?, ?>> getCheckPhase(String phaseName) {
                return checkPhases.get(phaseName);
        }

        /**
         * Creates check instances for the given check identifiers.
         *
         * @throws CheckException
         *             if there is no check for one of the given identifiers
         */
        public Collection<CheckInstance> instantiateChecks(List<String> identifiers) throws CheckException {
                List<CheckInstance> instances = new ArrayList<>();
                for (String identifier : identifiers) {
                        if (identifier.equals(
                                        "Code Anomalies#:#Readability#:#Switch statement should have a default label as last switch label")) {
                                // Old check that has been removed in TS-19527, but the migration was not
                                // drop-in, so drop-in upgraded 5.2.0-5.2.5 instances might be affected.
                                // This can removed in 5.3.0+
                                continue;
                        }
                        CheckInfo checkInfo = checksInfo.get(identifier);
                        if (checkInfo == null) {
                                LOGGER.error("No check with identifier '" + identifier + "' exists, skipping...");
                                continue;
                        }
                        instances.add(new CheckInstance(checkInfo));
                }
                return instances;
        }

        /** Returns a list of all registered checks. */
        public Collection<CheckInfo> getChecksInfos() {
                return CollectionUtils.asUnmodifiable(checksInfo.values());
        }

        /**
         * File visitor that scans a file tree and loads custom checks from classes
         * directories and jar files.
         */
        private final class CustomCheckLoader extends SimpleFileVisitor<Path> {
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                        Path classes = dir.resolve("classes/java/main");
                        if (Files.isDirectory(classes)) {
                                LOGGER.info("Registering custom checks from classes: " + classes);
                                loadChecksFromClasses(classes.toFile());
                                return FileVisitResult.SKIP_SUBTREE;
                        }
                        classes = dir.resolve("classes");
                        if (Files.isDirectory(classes)
                                        && !FileSystemUtils.normalizeSeparators(classes.toString()).contains("/test/")) {
                                LOGGER.info("Registering custom checks from classes: " + classes);
                                loadChecksFromClasses(classes.toFile());
                                return FileVisitResult.SKIP_SUBTREE;
                        }
                        return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                        if (file.toString().endsWith(".jar")) {
                                LOGGER.info("Registering custom checks from jar: " + file);
                                loadChecksFromJar(file.toFile());
                        }
                        return FileVisitResult.CONTINUE;
                }
        }
}