package com.atlassian.plugin.metadata;

import com.atlassian.plugin.ModuleDescriptor;
import com.atlassian.plugin.Plugin;
import com.google.common.collect.ImmutableSet;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.List;
import java.util.Set;

import static org.apache.commons.io.IOUtils.readLines;

/**
 * Looks on the classpath for three files named: <ul> <li>application-provided-plugins.txt - used to list the plugin
 * keys of all plugins that are provided by the host application</li> <li>application-required-plugins.txt - used to
 * list the plugin keys that are considered required for the application to function correctly</li>
 * <li>application-required-modules.txt - used to list the module keys that are considered required for the application
 * to function correctly</li> </ul> Note that all files in that package space with those names will be included.
 * <p/>
 * All files contents will be used to inform this implementation of plugin keys. This will read the contents all
 * instances of those files into the structures of this class.
 * <p/>
 * The values will determine the plugin metadata for this implementation.
 *
 * @since 2.6
 */
public class ClasspathFilePluginMetadata implements PluginMetadata, RequiredPluginProvider {
    final static String APPLICATION_PROVIDED_PLUGINS_FILENAME = "application-provided-plugins.txt";
    final static String APPLICATION_REQUIRED_PLUGINS_FILENAME = "application-required-plugins.txt";
    final static String APPLICATION_REQUIRED_MODULES_FILENAME = "application-required-modules.txt";

    private final Set<String> providedPluginKeys;
    private final Set<String> requiredPluginKeys;
    private final Set<String> requiredModuleKeys;
    private final ClassLoader classLoader;

    public ClasspathFilePluginMetadata() {
        this(ClasspathFilePluginMetadata.class.getClassLoader());
    }

    ClasspathFilePluginMetadata(ClassLoader classLoader) {
        this.classLoader = classLoader;
        this.providedPluginKeys = getStringsFromFile(APPLICATION_PROVIDED_PLUGINS_FILENAME);
        this.requiredPluginKeys = getStringsFromFile(APPLICATION_REQUIRED_PLUGINS_FILENAME);
        this.requiredModuleKeys = getStringsFromFile(APPLICATION_REQUIRED_MODULES_FILENAME);
    }

    public boolean applicationProvided(final Plugin plugin) {
        return providedPluginKeys.contains(plugin.getKey());
    }

    public boolean required(final Plugin plugin) {
        return requiredPluginKeys.contains(plugin.getKey());
    }

    public boolean required(final ModuleDescriptor<?> module) {
        return requiredModuleKeys.contains(module.getCompleteKey());
    }

    public Set<String> getRequiredPluginKeys() {
        return requiredPluginKeys;
    }

    public Set<String> getRequiredModuleKeys() {
        return requiredModuleKeys;
    }

    private Set<String> getStringsFromFile(final String fileName) {
        final ImmutableSet.Builder<String> stringsFromFiles = ImmutableSet.builder();

        final Collection<InputStream> fileInputStreams = getInputStreamsForFilename(fileName);
        try {
            for (InputStream fileInputStream : fileInputStreams) {
                if (fileInputStream != null) {
                    try {
                        @SuppressWarnings("unchecked")
                        final List<String> lines = readLines(fileInputStream);

                        // Make sure that we trim the strings that we read from the file and filter out comments and blank lines
                        // NOTE: You could use a filter and a transformation but then you need either a private class
                        // or a single enum which causes WAY TOO MUCH debate.
                        for (String line : lines) {
                            final String processedLine = processedLine(line);
                            if (processedLine != null) {
                                stringsFromFiles.add(processedLine.intern());
                            }
                        }
                    } catch (final IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        } finally {
            for (InputStream fileInputStream : fileInputStreams) {
                IOUtils.closeQuietly(fileInputStream);
            }
        }
        return stringsFromFiles.build();
    }

    /**
     * Checks the input to see if it meets the rules we want to enforce about valid lines. If it does not meet the
     * criteria then null is returned, otherwise a trimmed version of the passed in string is returned.
     *
     * @param rawLine the string of data we are processing
     * @return if rawLine does not meet the criteria then null is returned, otherwise a trimmed version of rawLine is
     * returned.
     */
    private String processedLine(String rawLine) {
        if (rawLine == null) {
            return null;
        }

        final String trimmedLine = rawLine.trim();
        // Lets not include blank lines
        if (StringUtils.isBlank(trimmedLine)) {
            return null;
        }

        // Lets not include comments
        if (trimmedLine.startsWith("#")) {
            return null;
        }
        return trimmedLine;
    }

    Collection<InputStream> getInputStreamsForFilename(final String fileName) {
        final Collection<InputStream> inputStreams = new ArrayList<InputStream>();
        final Class<ClasspathFilePluginMetadata> clazz = ClasspathFilePluginMetadata.class;
        final String resourceName = clazz.getPackage().getName().replace(".", "/") + "/" + fileName;
        try {
            final Enumeration<URL> urlEnumeration = classLoader.getResources(resourceName);
            while (urlEnumeration.hasMoreElements()) {
                inputStreams.add(urlEnumeration.nextElement().openStream());
            }
        } catch (final IOException e) {
            // Close what we had opened before, one bad apple ruins the batch
            for (InputStream inputStream : inputStreams) {
                IOUtils.closeQuietly(inputStream);
            }
            throw new RuntimeException(e);
        }
        return inputStreams;
    }

}