package org.eclipse.aether.util.artifact;

/*
 * 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.
 */

import org.eclipse.aether.artifact.Artifact;

import java.util.Objects;

A utility class for artifact identifiers.
/**
 * A utility class for artifact identifiers.
 */
public final class ArtifactIdUtils
{

    private static final char SEP = ':';

    private ArtifactIdUtils()
    {
        // hide constructor
    }

    
Creates an artifact identifier of the form <groupId>:<artifactId>:<extension>[:<classifier>]:<version>. 
Params:
artifact – The artifact to create an identifer for, may be null.
Returns:
The artifact identifier or null if the input was null./**
     * Creates an artifact identifier of the form {@code <groupId>:<artifactId>:<extension>[:<classifier>]:<version>}.
     * 
     * @param artifact The artifact to create an identifer for, may be {@code null}.
     * @return The artifact identifier or {@code null} if the input was {@code null}.
     */
    public static String toId( Artifact artifact )
    {
        String id = null;
        if ( artifact != null )
        {
            id =
                toId( artifact.getGroupId(), artifact.getArtifactId(), artifact.getExtension(),
                      artifact.getClassifier(), artifact.getVersion() );
        }
        return id;
    }

    
Creates an artifact identifier of the form <groupId>:<artifactId>:<extension>[:<classifier>]:<version>. 
Params:
groupId – The group id, may be null.
artifactId – The artifact id, may be null.
extension – The file extensiion, may be null.
classifier – The classifier, may be null.
version – The version, may be null.
Returns:
The artifact identifier, never null./**
     * Creates an artifact identifier of the form {@code <groupId>:<artifactId>:<extension>[:<classifier>]:<version>}.
     * 
     * @param groupId The group id, may be {@code null}.
     * @param artifactId The artifact id, may be {@code null}.
     * @param extension The file extensiion, may be {@code null}.
     * @param classifier The classifier, may be {@code null}.
     * @param version The version, may be {@code null}.
     * @return The artifact identifier, never {@code null}.
     */
    public static String toId( String groupId, String artifactId, String extension, String classifier, String version )
    {
        StringBuilder buffer = concat( groupId, artifactId, extension, classifier );
        buffer.append( SEP );
        if ( version != null )
        {
            buffer.append( version );
        }
        return buffer.toString();
    }

    
Creates an artifact identifier of the form <groupId>:<artifactId>:<extension>[:<classifier>]:<baseVersion>. 
Params:
artifact – The artifact to create an identifer for, may be null.
Returns:
The artifact identifier or null if the input was null./**
     * Creates an artifact identifier of the form
     * {@code <groupId>:<artifactId>:<extension>[:<classifier>]:<baseVersion>}.
     * 
     * @param artifact The artifact to create an identifer for, may be {@code null}.
     * @return The artifact identifier or {@code null} if the input was {@code null}.
     */
    public static String toBaseId( Artifact artifact )
    {
        String id = null;
        if ( artifact != null )
        {
            id =
                toId( artifact.getGroupId(), artifact.getArtifactId(), artifact.getExtension(),
                      artifact.getClassifier(), artifact.getBaseVersion() );
        }
        return id;
    }

    
Creates an artifact identifier of the form <groupId>:<artifactId>:<extension>[:<classifier>]. 
Params:
artifact – The artifact to create an identifer for, may be null.
Returns:
The artifact identifier or null if the input was null./**
     * Creates an artifact identifier of the form {@code <groupId>:<artifactId>:<extension>[:<classifier>]}.
     * 
     * @param artifact The artifact to create an identifer for, may be {@code null}.
     * @return The artifact identifier or {@code null} if the input was {@code null}.
     */
    public static String toVersionlessId( Artifact artifact )
    {
        String id = null;
        if ( artifact != null )
        {
            id =
                toVersionlessId( artifact.getGroupId(), artifact.getArtifactId(), artifact.getExtension(),
                                 artifact.getClassifier() );
        }
        return id;
    }

    
Creates an artifact identifier of the form <groupId>:<artifactId>:<extension>[:<classifier>]. 
Params:
groupId – The group id, may be null.
artifactId – The artifact id, may be null.
extension – The file extensiion, may be null.
classifier – The classifier, may be null.
Returns:
The artifact identifier, never null./**
     * Creates an artifact identifier of the form {@code <groupId>:<artifactId>:<extension>[:<classifier>]}.
     * 
     * @param groupId The group id, may be {@code null}.
     * @param artifactId The artifact id, may be {@code null}.
     * @param extension The file extensiion, may be {@code null}.
     * @param classifier The classifier, may be {@code null}.
     * @return The artifact identifier, never {@code null}.
     */
    public static String toVersionlessId( String groupId, String artifactId, String extension, String classifier )
    {
        return concat( groupId, artifactId, extension, classifier ).toString();
    }

    private static StringBuilder concat( String groupId, String artifactId, String extension, String classifier )
    {
        StringBuilder buffer = new StringBuilder( 128 );

        if ( groupId != null )
        {
            buffer.append( groupId );
        }
        buffer.append( SEP );
        if ( artifactId != null )
        {
            buffer.append( artifactId );
        }
        buffer.append( SEP );
        if ( extension != null )
        {
            buffer.append( extension );
        }
        if ( classifier != null && classifier.length() > 0 )
        {
            buffer.append( SEP ).append( classifier );
        }

        return buffer;
    }

    
Determines whether two artifacts have the same identifier. This method is equivalent to calling String.equals(Object) on the return values from toId(Artifact) for the artifacts but does not incur the overhead of creating temporary strings. 
Params:
artifact1 – The first artifact, may be null.
artifact2 – The second artifact, may be null.
Returns:
true if both artifacts are not null and have equal ids, false otherwise./**
     * Determines whether two artifacts have the same identifier. This method is equivalent to calling
     * {@link String#equals(Object)} on the return values from {@link #toId(Artifact)} for the artifacts but does not
     * incur the overhead of creating temporary strings.
     * 
     * @param artifact1 The first artifact, may be {@code null}.
     * @param artifact2 The second artifact, may be {@code null}.
     * @return {@code true} if both artifacts are not {@code null} and have equal ids, {@code false} otherwise.
     */
    public static boolean equalsId( Artifact artifact1, Artifact artifact2 )
    {
        if ( artifact1 == null || artifact2 == null )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getArtifactId(), artifact2.getArtifactId() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getGroupId(), artifact2.getGroupId() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getExtension(), artifact2.getExtension() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getClassifier(), artifact2.getClassifier() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getVersion(), artifact2.getVersion() ) )
        {
            return false;
        }
        return true;
    }

    
Determines whether two artifacts have the same base identifier. This method is equivalent to calling String.equals(Object) on the return values from toBaseId(Artifact) for the artifacts but does not incur the overhead of creating temporary strings. 
Params:
artifact1 – The first artifact, may be null.
artifact2 – The second artifact, may be null.
Returns:
true if both artifacts are not null and have equal base ids, false otherwise./**
     * Determines whether two artifacts have the same base identifier. This method is equivalent to calling
     * {@link String#equals(Object)} on the return values from {@link #toBaseId(Artifact)} for the artifacts but does
     * not incur the overhead of creating temporary strings.
     * 
     * @param artifact1 The first artifact, may be {@code null}.
     * @param artifact2 The second artifact, may be {@code null}.
     * @return {@code true} if both artifacts are not {@code null} and have equal base ids, {@code false} otherwise.
     */
    public static boolean equalsBaseId( Artifact artifact1, Artifact artifact2 )
    {
        if ( artifact1 == null || artifact2 == null )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getArtifactId(), artifact2.getArtifactId() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getGroupId(), artifact2.getGroupId() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getExtension(), artifact2.getExtension() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getClassifier(), artifact2.getClassifier() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getBaseVersion(), artifact2.getBaseVersion() ) )
        {
            return false;
        }
        return true;
    }

    
Determines whether two artifacts have the same versionless identifier. This method is equivalent to calling String.equals(Object) on the return values from toVersionlessId(Artifact) for the artifacts but does not incur the overhead of creating temporary strings. 
Params:
artifact1 – The first artifact, may be null.
artifact2 – The second artifact, may be null.
Returns:
true if both artifacts are not null and have equal versionless ids, false otherwise./**
     * Determines whether two artifacts have the same versionless identifier. This method is equivalent to calling
     * {@link String#equals(Object)} on the return values from {@link #toVersionlessId(Artifact)} for the artifacts but
     * does not incur the overhead of creating temporary strings.
     * 
     * @param artifact1 The first artifact, may be {@code null}.
     * @param artifact2 The second artifact, may be {@code null}.
     * @return {@code true} if both artifacts are not {@code null} and have equal versionless ids, {@code false}
     *         otherwise.
     */
    public static boolean equalsVersionlessId( Artifact artifact1, Artifact artifact2 )
    {
        if ( artifact1 == null || artifact2 == null )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getArtifactId(), artifact2.getArtifactId() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getGroupId(), artifact2.getGroupId() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getExtension(), artifact2.getExtension() ) )
        {
            return false;
        }
        if ( !Objects.equals( artifact1.getClassifier(), artifact2.getClassifier() ) )
        {
            return false;
        }
        return true;
    }
}