/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.apache.maven.internal.transformation.impl;
  
  import javax.inject.Inject;
  import javax.inject.Named;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Objects;
  import java.util.stream.Collectors;
  
  import org.apache.maven.api.SessionData;
  import org.apache.maven.api.model.Dependency;
  import org.apache.maven.api.model.DependencyManagement;
  import org.apache.maven.api.model.DistributionManagement;
  import org.apache.maven.api.model.Model;
  import org.apache.maven.api.model.ModelBase;
  import org.apache.maven.api.model.Profile;
  import org.apache.maven.api.model.Repository;
  import org.apache.maven.api.services.ModelBuilder;
  import org.apache.maven.api.services.ModelBuilderException;
  import org.apache.maven.api.services.ModelBuilderRequest;
  import org.apache.maven.api.services.ModelBuilderResult;
  import org.apache.maven.api.services.ModelSource;
  import org.apache.maven.api.services.Source;
  import org.apache.maven.api.services.model.LifecycleBindingsInjector;
  import org.apache.maven.internal.impl.InternalSession;
  import org.apache.maven.model.v4.MavenModelVersion;
  import org.apache.maven.project.MavenProject;
  import org.eclipse.aether.RepositorySystemSession;
  
  @Named
  class DefaultConsumerPomBuilder implements ConsumerPomBuilder {
      private static final String BOM_PACKAGING = "bom";
  
      public static final String POM_PACKAGING = "pom";
  
      private final LifecycleBindingsInjector lifecycleBindingsInjector;
  
      @Inject
      @SuppressWarnings("checkstyle:ParameterNumber")
      DefaultConsumerPomBuilder(LifecycleBindingsInjector lifecycleBindingsInjector) {
          this.lifecycleBindingsInjector = lifecycleBindingsInjector;
      }
  
      @Override
      public Model build(RepositorySystemSession session, MavenProject project, Path src) throws ModelBuilderException {
          Model model = project.getModel().getDelegate();
          String packaging = model.getPackaging();
          String originalPackaging = project.getOriginalModel().getPackaging();
          if (POM_PACKAGING.equals(packaging) && !BOM_PACKAGING.equals(originalPackaging)) {
              return buildPom(session, project, src);
          } else {
              return buildNonPom(session, project, src);
          }
      }
  
      protected Model buildPom(RepositorySystemSession session, MavenProject project, Path src)
              throws ModelBuilderException {
          ModelBuilderResult result = buildModel(session, project, src);
          Model model = result.getRawModel();
          return transform(model, project);
      }
  
      protected Model buildNonPom(RepositorySystemSession session, MavenProject project, Path src)
              throws ModelBuilderException {
          ModelBuilderResult result = buildModel(session, project, src);
          Model model = result.getEffectiveModel();
          return transform(model, project);
      }
  
      private ModelBuilderResult buildModel(RepositorySystemSession session, MavenProject project, Path src)
              throws ModelBuilderException {
          InternalSession iSession = InternalSession.from(session);
          ModelBuilderRequest.ModelBuilderRequestBuilder request = ModelBuilderRequest.builder();
          request.requestType(ModelBuilderRequest.RequestType.CONSUMER_POM);
          request.session(iSession);
         // in order to resolve parents, we need to fake being at the correct location
         request.source(new PomConsumerModelSource(project.getModel().getPomPath(), src));
         request.locationTracking(false);
         request.systemProperties(session.getSystemProperties());
         request.userProperties(session.getUserProperties());
         request.lifecycleBindingsInjector(lifecycleBindingsInjector::injectLifecycleBindings);
         ModelBuilder.ModelBuilderSession mbSession =
                 iSession.getData().get(SessionData.key(ModelBuilder.ModelBuilderSession.class));
         return mbSession.build(request.build());
     }
 
     static Model transform(Model model, MavenProject project) {
         String packaging = model.getPackaging();
         if (POM_PACKAGING.equals(packaging)) {
             // raw to consumer transform
             model = model.withRoot(false).withModules(null).withSubprojects(null);
             if (model.getParent() != null) {
                 model = model.withParent(model.getParent().withRelativePath(null));
             }
 
             if (!model.isPreserveModelVersion()) {
                 model = model.withPreserveModelVersion(false);
                 String modelVersion = new MavenModelVersion().getModelVersion(model);
                 model = model.withModelVersion(modelVersion);
             }
         } else if (BOM_PACKAGING.equals(packaging)) {
             DependencyManagement dependencyManagement =
                     project.getOriginalModel().getDependencyManagement().getDelegate();
             List<Dependency> dependencies = new ArrayList<>();
             String version = model.getVersion();
 
             dependencyManagement
                     .getDependencies()
                     .forEach((dependency) -> dependencies.add(dependency.withVersion(version)));
             Model.Builder builder = prune(
                     Model.newBuilder(model, true)
                             .preserveModelVersion(false)
                             .root(false)
                             .parent(null)
                             .dependencyManagement(dependencyManagement.withDependencies(dependencies))
                             .build(null),
                     model);
             builder.packaging(POM_PACKAGING);
             builder.profiles(prune(model.getProfiles()));
 
             model = builder.build();
             String modelVersion = new MavenModelVersion().getModelVersion(model);
             model = model.withModelVersion(modelVersion);
         } else {
             Model.Builder builder = prune(
                     Model.newBuilder(model, true)
                             .preserveModelVersion(false)
                             .root(false)
                             .parent(null)
                             .build(null),
                     model);
             builder.profiles(prune(model.getProfiles()));
 
             model = builder.build();
             String modelVersion = new MavenModelVersion().getModelVersion(model);
             model = model.withModelVersion(modelVersion);
         }
         return model;
     }
 
     private static List<Profile> prune(List<Profile> profiles) {
         return profiles.stream()
                 .map(p -> {
                     Profile.Builder builder = Profile.newBuilder(p, true);
                     prune((ModelBase.Builder) builder, p);
                     return builder.build(null).build();
                 })
                 .filter(p -> !isEmpty(p))
                 .collect(Collectors.toList());
     }
 
     private static boolean isEmpty(Profile profile) {
         return profile.getActivation() == null
                 && profile.getBuild() == null
                 && profile.getDependencies().isEmpty()
                 && (profile.getDependencyManagement() == null
                         || profile.getDependencyManagement().getDependencies().isEmpty())
                 && profile.getDistributionManagement() == null
                 && profile.getModules().isEmpty()
                 && profile.getSubprojects().isEmpty()
                 && profile.getProperties().isEmpty()
                 && profile.getRepositories().isEmpty()
                 && profile.getPluginRepositories().isEmpty()
                 && profile.getReporting() == null;
     }
 
     private static <T extends ModelBase.Builder> T prune(T builder, ModelBase model) {
         builder.properties(null).reporting(null);
         if (model.getDistributionManagement() != null
                 && model.getDistributionManagement().getRelocation() != null) {
             // keep relocation only
             builder.distributionManagement(DistributionManagement.newBuilder()
                     .relocation(model.getDistributionManagement().getRelocation())
                     .build());
         }
         // only keep repositories other than 'central'
         builder.pluginRepositories(pruneRepositories(model.getPluginRepositories()));
         builder.repositories(pruneRepositories(model.getRepositories()));
         return builder;
     }
 
     private static List<Repository> pruneRepositories(List<Repository> repositories) {
         return repositories.stream()
                 .filter(r -> !org.apache.maven.api.Repository.CENTRAL_ID.equals(r.getId()))
                 .collect(Collectors.toList());
     }
 
     static class PomConsumerModelSource implements ModelSource {
         final Path path;
         final Path src;
 
         PomConsumerModelSource(Path path, Path src) {
             this.path = path;
             this.src = src;
         }
 
         @Override
         public Path getPath() {
             return path;
         }
 
         @Override
         public InputStream openStream() throws IOException {
             return Files.newInputStream(src);
         }
 
         @Override
         public String getLocation() {
             return src.toString();
         }
 
         @Override
         public Source resolve(String relative) {
             return ModelSource.fromPath(path.resolve(relative));
         }
 
         @Override
         public ModelSource resolve(ModelLocator locator, String relative) {
             String norm = relative.replace('\\', File.separatorChar).replace('/', File.separatorChar);
             Path path = getPath().getParent().resolve(norm);
             Path relatedPom = locator.locateExistingPom(path);
             if (relatedPom != null) {
                 return ModelSource.fromPath(relatedPom);
             }
             return null;
         }
 
         @Override
         public boolean equals(Object o) {
             return this == o
                     || o.getClass() == getClass()
                             && Objects.equals(path, ((PomConsumerModelSource) o).path)
                             && Objects.equals(src, ((PomConsumerModelSource) o).src);
         }
 
         @Override
         public int hashCode() {
             return Objects.hash(path, src);
         }
 
         @Override
         public String toString() {
             return "PomConsumerModelSource[" + "path=" + path + ']';
         }
     }
 }