/*
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.basepom.inline.mojo;
  
  import static com.google.common.base.Preconditions.checkState;
  import static java.lang.String.format;
  import static java.nio.file.StandardCopyOption.ATOMIC_MOVE;
  import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
  
  import org.basepom.inline.transformer.ClassPath;
  import org.basepom.inline.transformer.ClassPathResource;
  import org.basepom.inline.transformer.ClassPathTag;
  import org.basepom.inline.transformer.JarTransformer;
  import org.basepom.inline.transformer.TransformerException;
  
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.File;
  import java.io.IOException;
  import java.io.UncheckedIOException;
  import java.nio.charset.StandardCharsets;
  import java.nio.file.Files;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  import java.util.Set;
  import java.util.function.BiConsumer;
  import java.util.function.Consumer;
  import java.util.function.Predicate;
  import java.util.jar.JarEntry;
  import java.util.jar.JarOutputStream;
  import java.util.stream.Collectors;
  import javax.xml.stream.XMLStreamException;
  
  import com.google.common.base.Functions;
  import com.google.common.base.Joiner;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.ImmutableMap;
  import com.google.common.collect.ImmutableSet;
  import com.google.common.collect.ImmutableSetMultimap;
  import com.google.common.collect.ImmutableSortedSet;
  import com.google.common.collect.Iterables;
  import com.google.common.collect.Sets;
  import com.google.common.io.CharStreams;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugins.annotations.Component;
  import org.apache.maven.plugins.annotations.LifecyclePhase;
  import org.apache.maven.plugins.annotations.Mojo;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.plugins.annotations.ResolutionScope;
  import org.apache.maven.project.DependencyResolutionException;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectHelper;
  import org.apache.maven.project.ProjectBuilder;
  import org.apache.maven.project.ProjectBuildingException;
  import org.apache.maven.project.ProjectDependenciesResolver;
  import org.eclipse.aether.RepositorySystem;
  import org.eclipse.aether.artifact.Artifact;
  import org.eclipse.aether.graph.Dependency;
  import org.eclipse.aether.util.artifact.JavaScopes;
  import org.jdom2.JDOMException;
  
  /**
   * Inlines one or more dependencies of the project, relocated the classes and writes a new artifact.
   */
  @Mojo(name = "inline", defaultPhase = LifecyclePhase.PACKAGE,
          requiresProject = true, threadSafe = true,
          requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME,
          requiresDependencyCollection = ResolutionScope.COMPILE_PLUS_RUNTIME)
  public final class InlineMojo extends AbstractMojo {
  
      private static final PluginLog LOG = new PluginLog(InlineMojo.class);
  
      private static final Predicate<Dependency> EXCLUDE_SYSTEM_SCOPE = dependency -> !JavaScopes.SYSTEM.equals(dependency.getScope());
      private static final Predicate<Dependency> EXCLUDE_PROVIDED_SCOPE = dependency -> !JavaScopes.PROVIDED.equals(dependency.getScope());
  
  
      @Parameter(defaultValue = "${project}", readonly = true, required = true)
      private MavenProject project;
  
      @Parameter(defaultValue = "${session}", readonly = true, required = true)
      private MavenSession mavenSession;
  
      @Parameter(defaultValue = "${reactorProjects}", readonly = true, required = true)
      private List<MavenProject> reactorProjects;
 
     @Component
     private ProjectBuilder mavenProjectBuilder;
 
     @Component
     private ProjectDependenciesResolver projectDependenciesResolver;
 
     @Component
     private RepositorySystem repositorySystem;
 
     @Component
     private MavenProjectHelper projectHelper;
 
     /**
      * The destination directory for the inlined artifact.
      */
     @Parameter(defaultValue = "${project.build.directory}")
     private File outputDirectory;
 
     /**
      * The POM file to use.
      */
     @Parameter(property = "inline.pomFile", defaultValue = "${project.file}")
     private File pomFile;
 
     /**
      * Direct dependencies to inline. Each dependency here must be
      * listed in the project POM. Any transitive dependency is added
      * to the final jar, unless it is in {@code RUNTIME} scope.
      * {@code RUNTIME} dependencies become a runtime dependency of the
      * resulting final jar <b>unless</b> they are listed here. In that
      * case, they are inlined in the final jar as well.
      */
     @Parameter
     private List<InlineDependency> inlineDependencies = ImmutableList.of();
 
     // called by maven
     public void setInlineDependencies(List<InlineDependency> inlineDependencies) {
         this.inlineDependencies = ImmutableList.copyOf(inlineDependencies);
     }
 
     /**
      * Include dependencies. A dependency is given as <tt>groupId:artifactId</tt>. The wildcard character '*' is supported for group id and artifact id.
      */
     @Parameter
     private List<ArtifactIdentifier> includes = ImmutableList.of();
 
     // called by maven
     public void setIncludes(List<ArtifactIdentifier> includes) {
         this.includes = ImmutableList.copyOf(includes);
     }
 
     /**
      * Exclude dependencies from inclusion. A dependency is given as <tt>groupId:artifactId</tt>. Any transitive dependency that has been pulled in can be
      * excluded here. The wildcard character '*' is supported for group id and artifact id.
      */
     @Parameter
     private List<ArtifactIdentifier> excludes = ImmutableList.of();
 
     // called by maven
     public void setExcludes(List<ArtifactIdentifier> excludes) {
         this.excludes = ImmutableList.copyOf(excludes);
     }
 
     /**
      * Adds external jar processors. These must be on the dependency path for the plugin. See the "Additional Processors" documentation.
      */
     @Parameter
     private List<String> additionalProcessors = ImmutableList.of();
 
     // called by maven
     public void setAdditionalProcessors(List<String> processors) {
         this.additionalProcessors = ImmutableList.copyOf(processors);
     }
 
     /**
      * Hide inlined classes from IDE autocompletion.
      */
     @Parameter(defaultValue = "true", property = "inline.hide-classes")
     private boolean hideClasses;
 
     /**
      * Skip the execution.
      */
     @Parameter(defaultValue = "false", property = "inline.skip")
     private boolean skip;
 
     /**
      * Silence all non-output and non-error messages.
      */
     @Parameter(defaultValue = "false", property = "inline.quiet")
     private boolean quiet;
 
     /**
      * Defines the package prefix for all relocated classes. This prefix must be a valid package name. All relocated classes are put under this prefix.
      */
     @Parameter(required = true, property = "inline.prefix")
     private String prefix;
 
     /**
      * Fail if an inline dependency is defined but the corresponding dependency is not actually found.
      */
     @Parameter(defaultValue = "true", property = "inline.failOnNoMatch")
     private boolean failOnNoMatch;
 
     /**
      * Fail if any duplicate exists after processing the contents.
      */
     @Parameter(defaultValue = "true", property = "inline.failOnDuplicate")
     private boolean failOnDuplicate;
 
     /**
      * The path to the output file for the inlined artifact. When this parameter is set, the created archive will neither replace the project's main artifact
      * nor will it be attached. Hence, this parameter causes the parameters {@link #inlinedArtifactAttached}, {@link #inlinedClassifierName} to be ignored when
      * used.
      */
     @Parameter
     private File outputJarFile;
 
     /**
      * The path to the output file for the new POM file. When this parameter is set, the created pom file will not replace the project's pom file.
      */
     @Parameter
     private File outputPomFile;
 
 
     /**
      * If true, attach the inlined artifact, if false replace the original artifact.
      */
     @Parameter(defaultValue = "false", property = "inline.attachArtifact")
     private boolean inlinedArtifactAttached;
 
     /**
      * If true, replace the POM file with a new version that has all inlined dependencies removed. It is possible to write a POM file that works to build the
      * jar with inlined dependencies and then use the same POM file for the resulting artifact (by having all dependencies marked as <tt>provided</tt> and
      * ensure that those dependencies do not have additional, transitive dependencies. This tends to be error prone and it is recommended to have the plugin
      * rewrite the POM file.
      */
     @Parameter(defaultValue = "true", property = "inline.replacePomFile")
     private boolean replacePomFile;
 
     /**
      * The name of the classifier used in case the inlined artifact is attached.
      */
     @Parameter(defaultValue = "inlined")
     private String inlinedClassifierName;
 
 
     @Override
     public void execute() throws MojoExecutionException {
 
         if (this.skip) {
             LOG.report(quiet, "skipping plugin execution");
             return;
         }
 
         if ("pom".equals(project.getPackaging())) {
             LOG.report(quiet, "ignoring POM project");
             return;
         }
 
         if (project.getArtifact().getFile() == null) {
             throw new MojoExecutionException("No project artifact found!");
         }
 
         try {
             ImmutableSetMultimap.Builder<InlineDependency, Dependency> dependencyBuilder = ImmutableSetMultimap.builder();
             ImmutableSet.Builder<Dependency> pomDependenciesToAdd = ImmutableSet.builder();
 
             computeDependencyMap(dependencyBuilder, pomDependenciesToAdd);
 
             ImmutableSetMultimap<InlineDependency, Dependency> dependencyMap = dependencyBuilder.build();
 
             rewriteJarFile(dependencyMap);
             rewritePomFile(pomDependenciesToAdd.build(), ImmutableSet.copyOf(dependencyMap.values()));
 
         } catch (UncheckedIOException e) {
             throw new MojoExecutionException(e.getCause());
         } catch (TransformerException | IOException | DependencyResolutionException | ProjectBuildingException | XMLStreamException | JDOMException e) {
             throw new MojoExecutionException(e);
         }
     }
 
     private void computeDependencyMap(
             ImmutableSetMultimap.Builder<InlineDependency, Dependency> dependencyMapBuilder,
             ImmutableSet.Builder<Dependency> pomBuilder)
             throws DependencyResolutionException, ProjectBuildingException {
 
         DependencyBuilder dependencyBuilder = new DependencyBuilder(project, mavenSession, mavenProjectBuilder, projectDependenciesResolver, reactorProjects);
 
         ImmutableSet<ArtifactIdentifier> directArtifacts = project.getDependencyArtifacts().stream()
                 .map(ArtifactIdentifier::new)
                 .collect(ImmutableSet.toImmutableSet());
 
         ImmutableList<Dependency> directDependencies = dependencyBuilder.mapProject(project,
                 (node, parents) -> directArtifacts.contains(new ArtifactIdentifier(node)));
 
         // build the full set of dependencies with all scopes and everything.
         ImmutableList<Dependency> projectDependencies = dependencyBuilder.mapProject(project,
                 ScopeLimitingFilter.computeDependencyScope(ScopeLimitingFilter.COMPILE_PLUS_RUNTIME));
 
         Map<String, Dependency> idMap = projectDependencies.stream()
                 .filter(dependency -> dependency.getArtifact() != null)
                 .collect(ImmutableMap.toImmutableMap(InlineMojo::getId, Functions.identity()));
 
         BiConsumer<InlineDependency, Dependency> dependencyConsumer = (inlineDependency, dependency) -> {
             LOG.debug("%s matches %s for inlining.", inlineDependency, dependency);
             dependencyMapBuilder.put(inlineDependency, dependency);
         };
 
         ImmutableSet.Builder<Dependency> directExcludes = ImmutableSet.builder();
 
         // first find all the direct dependencies. Add anything that is not hit to the additional exclude list
 
         ImmutableSortedSet.Builder<String> directLogBuilder = ImmutableSortedSet.naturalOrder();
 
         directDependencies.stream()
                 // remove anything that does not match the filter set.
                 // optionals also need to be matched by the inline dependency below
                 .filter(createFilterSet(true))
                 .forEach(dependency -> {
                     Optional<InlineDependency> inlineDependency = findInlineDependencyMatch(dependency);
                     if (inlineDependency.isPresent()) {
                         dependencyConsumer.accept(inlineDependency.get(), dependency);
                         directLogBuilder.add(dependency.toString());
                     } else {
                         directExcludes.add(dependency);
                     }
                 });
 
         ImmutableSortedSet<String> directLog = directLogBuilder.build();
 
         if (!quiet) {
             LOG.info("Inlined dependencies");
             LOG.info("====================");
 
             for (String dependency : directLog) {
                 LOG.info("    %s", dependency);
             }
             LOG.info("");
         }
 
         Set<ArtifactIdentifier> excludes = directExcludes.build().stream()
                 .map(ArtifactIdentifier::new)
                 .collect(Collectors.toUnmodifiableSet());
 
         this.excludes = ImmutableList.copyOf(Iterables.concat(this.excludes, excludes));
 
         LOG.debug("Excludes after creating includes: %s", this.excludes);
 
         var directDependencyMap = dependencyMapBuilder.build().asMap();
 
         ImmutableSortedSet.Builder<String> transitiveLogBuilder = ImmutableSortedSet.naturalOrder();
 
         for (var dependencyEntry : directDependencyMap.entrySet()) {
             InlineDependency inlineDependency = dependencyEntry.getKey();
             for (Dependency projectDependency : dependencyEntry.getValue()) {
 
                 Consumer<Dependency> consumer;
                 if (inlineDependency.isInlineTransitive()) {
                     // transitive deps are added to the jar
                     consumer = dependency -> {
                         Optional<InlineDependency> explicitMatch = findInlineDependencyMatch(dependency);
 
                         // If the dependency is not a runtime dependency, it is included in the inline jar
                         // Runtime dependencies are only included if they are explicitly listed as an
                         // included dependency. Otherwise, they are added as a runtime dep to the inline jar.
                         if (!JavaScopes.RUNTIME.equals(dependency.getScope()) || explicitMatch.isPresent()) {
                             dependencyConsumer.accept(inlineDependency, dependency);
                             transitiveLogBuilder.add(dependency.toString());
                         } else {
                             pomBuilder.add(dependency);
                         }
                     };
                 } else {
                     // non-transitive deps need to be written into the POM.
                     consumer = pomBuilder::add;
                 }
 
                 dependencyBuilder.mapDependency(projectDependency, ScopeLimitingFilter.computeTransitiveScope(projectDependency.getScope()))
                         .stream()
                         // replace deps in the transitive set with deps in the root set if present (will
                         // override the scope here with the root scope)
                         .map(dependency -> idMap.getOrDefault(getId(dependency), dependency))
                         // remove system and provided dependencies, keep optionals if allowed
                         .filter(createFilterSet(inlineDependency.isInlineOptionals()))
                         // make sure that the inline dependency actually pulls the dep in.
                         .filter(this::isDependencyIncluded)
                         .forEach(consumer);
             }
         }
 
         if (!quiet) {
             LOG.info("");
             LOG.info("Transitive dependencies");
             LOG.info("=======================");
             for (String dependency : Sets.difference(transitiveLogBuilder.build(), directLog)) {
                 LOG.info("    %s", dependency);
             }
             LOG.info("");
         }
     }
 
     private Optional<InlineDependency> findInlineDependencyMatch(Dependency dependency) {
         for (InlineDependency inlineDependency : inlineDependencies) {
             if (inlineDependency.matchDependency(dependency)) {
                 return Optional.of(inlineDependency);
             }
         }
         return Optional.empty();
     }
 
     private static String getId(Dependency dependency) {
         Artifact artifact = dependency.getArtifact();
         checkState(artifact != null, "Artifact for dependency %s is null!", dependency);
 
         return Joiner.on(':').join(artifact.getGroupId(), artifact.getArtifactId(), artifact.getClassifier());
     }
 
     private Predicate<Dependency> createFilterSet(boolean includeOptional) {
 
         // filter system scope dependencies. Those are never inlined.
         Predicate<Dependency> predicate = EXCLUDE_SYSTEM_SCOPE;
         predicate = predicate.and(EXCLUDE_PROVIDED_SCOPE);
 
         if (!includeOptional) {
             predicate = predicate.and(Predicate.not(Dependency::isOptional));
         }
         return predicate;
     }
 
     public boolean isDependencyIncluded(Dependency dependency) {
 
         boolean included = this.includes.stream()
                 .map(artifactIdentifier -> artifactIdentifier.matchDependency(dependency))
                 .findFirst()
                 .orElse(this.includes.isEmpty());
 
         boolean excluded = this.excludes.stream()
                 .map(artifactIdentifier -> artifactIdentifier.matchDependency(dependency))
                 .findFirst()
                 .orElse(false);
 
         return included && !excluded;
     }
 
 
     private void rewriteJarFile(ImmutableSetMultimap<InlineDependency, Dependency> dependencies) throws TransformerException, IOException {
         File outputJar = (this.outputJarFile != null) ? outputJarFile : inlinedArtifactFileWithClassifier();
 
         doJarTransformation(outputJar, dependencies);
 
         if (this.outputJarFile == null) {
             if (this.inlinedArtifactAttached) {
                 LOG.info("Attaching inlined artifact.");
                 projectHelper.attachArtifact(project, project.getArtifact().getType(), inlinedClassifierName, outputJar);
             } else {
                 LOG.info("Replacing original artifact with inlined artifact.");
                 File originalArtifact = project.getArtifact().getFile();
 
                 if (originalArtifact != null) {
                     File backupFile = new File(originalArtifact.getParentFile(), "original-" + originalArtifact.getName());
                     Files.move(originalArtifact.toPath(), backupFile.toPath(), ATOMIC_MOVE, REPLACE_EXISTING);
                     Files.move(outputJar.toPath(), originalArtifact.toPath(), ATOMIC_MOVE, REPLACE_EXISTING);
                 }
             }
         }
     }
 
     private void rewritePomFile(Set<Dependency> dependenciesToAdd, Set<Dependency> dependenciesToRemove) throws IOException, XMLStreamException, JDOMException {
         String pomContents;
 
         try (BufferedReader reader = Files.newBufferedReader(project.getFile().toPath(), StandardCharsets.UTF_8)) {
             pomContents = CharStreams.toString(reader);
         }
 
         PomUtil pomUtil = new PomUtil(pomContents);
         dependenciesToRemove.forEach(pomUtil::removeDependency);
         dependenciesToAdd.forEach(pomUtil::addDependency);
 
         // some rewriters (maven flatten plugin) rewrites the new pom name as a hidden file.
         String pomName = this.pomFile.getName();
         pomName = "new-" + (pomName.startsWith(".") ? pomName.substring(1) : pomName);
 
         File newPomFile = this.outputPomFile != null ? outputPomFile : new File(this.outputDirectory, pomName);
         try (BufferedWriter writer = Files.newBufferedWriter(newPomFile.toPath(), StandardCharsets.UTF_8)) {
             pomUtil.writePom(writer);
         }
 
         if (this.replacePomFile) {
             project.setPomFile(newPomFile);
         }
     }
 
     private void doJarTransformation(File outputJar, ImmutableSetMultimap<InlineDependency, Dependency> dependencies) throws TransformerException, IOException {
 
         try (JarOutputStream jarOutputStream = new JarOutputStream(Files.newOutputStream(outputJar.toPath()))) {
             Consumer<ClassPathResource> jarConsumer = getJarWriter(jarOutputStream);
             JarTransformer transformer = new JarTransformer(jarConsumer, true, ImmutableSet.copyOf(additionalProcessors));
 
             // Build the class path
             ClassPath classPath = new ClassPath(project.getBasedir());
             // maintain the manifest file for the main artifact
             var artifact = project.getArtifact();
             classPath.addFile(artifact.getFile(), artifact.getGroupId(), artifact.getArtifactId(), ClassPathTag.ROOT_JAR);
 
             dependencies.forEach(
                     (inlineDependency, dependency) -> {
                         var dependencyArtifact = dependency.getArtifact();
                         checkState(dependencyArtifact.getFile() != null, "Could not locate artifact file for %s", dependencyArtifact);
                         classPath.addFile(dependencyArtifact.getFile(), prefix, dependencyArtifact.getGroupId(), dependencyArtifact.getArtifactId(),
                                 hideClasses);
                     });
 
             transformer.transform(classPath);
         }
     }
 
     private Consumer<ClassPathResource> getJarWriter(JarOutputStream jarOutputStream) {
         return classPathResource -> {
             try {
                 String name = classPathResource.getName();
                 LOG.debug(format("Writing '%s' to jar", name));
                 JarEntry outputEntry = new JarEntry(name);
                 outputEntry.setTime(classPathResource.getLastModifiedTime());
                 outputEntry.setCompressedSize(-1);
                 jarOutputStream.putNextEntry(outputEntry);
                 jarOutputStream.write(classPathResource.getContent());
             } catch (IOException e) {
                 throw new UncheckedIOException(e);
             }
         };
     }
 
     private File inlinedArtifactFileWithClassifier() {
         final var artifact = project.getArtifact();
         String inlineName = String.format("%s-%s-%s.%s",
                 project.getArtifactId(),
                 artifact.getVersion(),
                 this.inlinedClassifierName,
                 artifact.getArtifactHandler().getExtension());
 
         return new File(this.outputDirectory, inlineName);
     }
 }