/*
    * 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.impl;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Objects;
  import java.util.Optional;
  
  import org.apache.maven.api.Artifact;
  import org.apache.maven.api.Dependency;
  import org.apache.maven.api.Node;
  import org.apache.maven.api.RemoteRepository;
  import org.apache.maven.api.annotations.Nonnull;
  import org.eclipse.aether.graph.DependencyNode;
  import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
  import org.eclipse.aether.util.graph.transformer.ConflictResolver;
  
  public class DefaultNode extends AbstractNode {
  
      protected final @Nonnull InternalSession session;
      protected final @Nonnull org.eclipse.aether.graph.DependencyNode node;
      protected final boolean verbose;
  
      public DefaultNode(
              @Nonnull InternalSession session, @Nonnull org.eclipse.aether.graph.DependencyNode node, boolean verbose) {
          this.session = session;
          this.node = node;
          this.verbose = verbose;
      }
  
      @Override
      DependencyNode getDependencyNode() {
          return node;
      }
  
      @Override
      public Artifact getArtifact() {
          return node.getArtifact() != null ? session.getArtifact(node.getArtifact()) : null;
      }
  
      @Override
      public Dependency getDependency() {
          return node.getDependency() != null ? session.getDependency(node.getDependency()) : null;
      }
  
      @Override
      public List<Node> getChildren() {
          return new MappedList<>(node.getChildren(), n -> session.getNode(n, verbose));
      }
  
      @Override
      public List<RemoteRepository> getRemoteRepositories() {
          return new MappedList<>(node.getRepositories(), session::getRemoteRepository);
      }
  
      @Override
      public Optional<RemoteRepository> getRepository() {
          // TODO: v4: implement
          throw new UnsupportedOperationException("Not implemented yet");
      }
  
      /**
       * Returns a detailed string representation of this dependency node.
       * <p>
       * When verbose mode is disabled, returns the basic string representation in the format:
       * {@code groupId:artifactId:version[:scope]}
       * <p>
       * When verbose mode is enabled, additional details are included with the following format:
       * <ul>
       *   <li>For included dependencies: {@code groupId:artifactId:version[:scope] (details)}</li>
       *   <li>For omitted dependencies: {@code (groupId:artifactId:version[:scope] - details)}</li>
       * </ul>
       * Where details may include:
       * <ul>
       *   <li>Version management information (if the version was managed from a different version)</li>
       *   <li>Scope management information (if the scope was managed from a different scope)</li>
       *   <li>Scope updates (if the scope was changed during resolution)</li>
       *   <li>Conflict resolution information (if the dependency was omitted due to conflicts or duplicates)</li>
       * </ul>
       *
       * @return a string representation of this dependency node with optional detailed information
       */
     @Nonnull
     @Override
     public String asString() {
         StringBuilder sb = new StringBuilder();
         DependencyNode node = getDependencyNode();
         org.eclipse.aether.artifact.Artifact artifact = node.getArtifact();
         org.eclipse.aether.graph.Dependency dependency = node.getDependency();
 
         if (!verbose) {
             sb.append(artifact);
             if (dependency != null) {
                 sb.append(":").append(dependency.getScope());
             }
             return sb.toString();
         }
 
         List<String> details = new ArrayList<>();
         org.eclipse.aether.graph.DependencyNode winner =
                 (org.eclipse.aether.graph.DependencyNode) node.getData().get(ConflictResolver.NODE_DATA_WINNER);
         String winnerVersion = winner != null ? winner.getArtifact().getBaseVersion() : null;
         boolean included = (winnerVersion == null);
 
         String preManagedVersion = DependencyManagerUtils.getPremanagedVersion(node);
         if (preManagedVersion != null) {
             details.add("version managed from " + preManagedVersion);
         }
 
         String preManagedScope = DependencyManagerUtils.getPremanagedScope(node);
         if (preManagedScope != null) {
             details.add("scope managed from " + preManagedScope);
         }
 
         String originalScope = (String) node.getData().get(ConflictResolver.NODE_DATA_ORIGINAL_SCOPE);
         if (originalScope != null && !originalScope.equals(dependency.getScope())) {
             details.add("scope updated from " + originalScope);
         }
 
         if (!included) {
             if (Objects.equals(winnerVersion, artifact.getVersion())) {
                 details.add("omitted for duplicate");
             } else {
                 details.add("omitted for conflict with " + winnerVersion);
             }
         }
 
         if (!included) {
             sb.append('(');
         }
 
         sb.append(artifact);
         if (dependency != null) {
             sb.append(":").append(dependency.getScope());
         }
 
         if (!details.isEmpty()) {
             sb.append(included ? " (" : " - ");
             appendDetails(sb, details);
             if (included) {
                 sb.append(')');
             }
         }
 
         if (!included) {
             sb.append(')');
         }
 
         return sb.toString();
     }
 
     private static void appendDetails(StringBuilder sb, List<String> details) {
         boolean first = true;
         for (String detail : details) {
             if (first) {
                 first = false;
             } else {
                 sb.append("; ");
             }
             sb.append(detail);
         }
     }
 }