package org.apache.maven;

/*
 * 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 java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;

import javax.inject.Inject;
import javax.inject.Named;

import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Model;
import org.apache.maven.project.MavenProject;
import org.apache.maven.repository.internal.MavenWorkspaceReader;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.repository.WorkspaceRepository;
import org.eclipse.aether.util.artifact.ArtifactIdUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * An implementation of a workspace reader that knows how to search the Maven reactor for artifacts, either as packaged
 * jar if it has been built, or only compile output directory if packaging hasn't happened yet.
 *
 * @author Jason van Zyl
 */
@Named( ReactorReader.HINT )
@SessionScoped
class ReactorReader
    implements MavenWorkspaceReader
{
    public static final String HINT = "reactor";

    private static final Collection<String> COMPILE_PHASE_TYPES =
        Arrays.asList( "jar", "ejb-client", "war", "rar", "ejb3", "par", "sar", "wsr", "har", "app-client" );

    private static final Logger LOGGER = LoggerFactory.getLogger( ReactorReader.class );

    private MavenSession session;

    private Map<String, MavenProject> projectsByGAV;

    private Map<String, List<MavenProject>> projectsByGA;

    private WorkspaceRepository repository;

    @Inject
    ReactorReader( MavenSession session )
    {
        this.session = session;
        this.projectsByGAV = new HashMap<>( session.getAllProjects().size() * 2 );
        session.getAllProjects().forEach( project ->
        {
            String projectId = ArtifactUtils.key( project.getGroupId(), project.getArtifactId(), project.getVersion() );
            this.projectsByGAV.put( projectId, project );
        } );

        projectsByGA = new HashMap<>( projectsByGAV.size() * 2 );
        for ( MavenProject project : projectsByGAV.values() )
        {
            String key = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() );

            List<MavenProject> projects = projectsByGA.computeIfAbsent( key, k -> new ArrayList<>( 1 ) );

            projects.add( project );
        }

        repository = new WorkspaceRepository( "reactor", new HashSet<>( projectsByGAV.keySet() ) );
    }

    //
    // Public API
    //

    public WorkspaceRepository getRepository()
    {
        return repository;
    }

    public File findArtifact( Artifact artifact )
    {
        String projectKey = ArtifactUtils.key( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion() );

        MavenProject project = projectsByGAV.get( projectKey );

        if ( project != null )
        {
            File file = find( project, artifact );
            if ( file == null && project != project.getExecutionProject() )
            {
                file = find( project.getExecutionProject(), artifact );
            }
            return file;
        }

        return null;
    }

    public List<String> findVersions( Artifact artifact )
    {
        String key = ArtifactUtils.versionlessKey( artifact.getGroupId(), artifact.getArtifactId() );

        List<MavenProject> projects = projectsByGA.get( key );
        if ( projects == null || projects.isEmpty() )
        {
            return Collections.emptyList();
        }

        List<String> versions = new ArrayList<>();

        for ( MavenProject project : projects )
        {
            if ( find( project, artifact ) != null )
            {
                versions.add( project.getVersion() );
            }
        }

        return Collections.unmodifiableList( versions );
    }

    @Override
    public Model findModel( Artifact artifact )
    {
        String projectKey = ArtifactUtils.key( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion() );
        MavenProject project = projectsByGAV.get( projectKey );
        return project == null ? null : project.getModel();
    }

    //
    // Implementation
    //

    private File find( MavenProject project, Artifact artifact )
    {
        if ( "pom".equals( artifact.getExtension() ) )
        {
            return project.getFile();
        }

        Artifact projectArtifact = findMatchingArtifact( project, artifact );
        File packagedArtifactFile = determinePreviouslyPackagedArtifactFile( project, projectArtifact );

        if ( hasArtifactFileFromPackagePhase( projectArtifact ) )
        {
            return projectArtifact.getFile();
        }
        // Check whether an earlier Maven run might have produced an artifact that is still on disk.
        else if ( packagedArtifactFile != null && packagedArtifactFile.exists()
                && isPackagedArtifactUpToDate( project, packagedArtifactFile, artifact ) )
        {
            return packagedArtifactFile;
        }
        else if ( !hasBeenPackagedDuringThisSession( project ) )
        {
            // fallback to loose class files only if artifacts haven't been packaged yet
            // and only for plain old jars. Not war files, not ear files, not anything else.
            return determineBuildOutputDirectoryForArtifact( project, artifact );
        }

        // The fall-through indicates that the artifact cannot be found;
        // for instance if package produced nothing or classifier problems.
        return null;
    }

    private File determineBuildOutputDirectoryForArtifact( final MavenProject project, final Artifact artifact )
    {
        if ( isTestArtifact( artifact ) )
        {
            if ( project.hasLifecyclePhase( "test-compile" ) )
            {
                return new File( project.getBuild().getTestOutputDirectory() );
            }
        }
        else
        {
            String type = artifact.getProperty( "type", "" );
            File outputDirectory = new File( project.getBuild().getOutputDirectory() );

            // Check if the project is being built during this session, and if we can expect any output.
            // There is no need to check if the build has created any outputs, see MNG-2222.
            boolean projectCompiledDuringThisSession
                    = project.hasLifecyclePhase( "compile" ) && COMPILE_PHASE_TYPES.contains( type );

            // Check if the project is part of the session (not filtered by -pl, -rf, etc). If so, we check
            // if a possible earlier Maven invocation produced some output for that project which we can use.
            boolean projectHasOutputFromPreviousSession
                    = !session.getProjects().contains( project ) && outputDirectory.exists();

            if ( projectHasOutputFromPreviousSession || projectCompiledDuringThisSession )
            {
                return outputDirectory;
            }
        }

        // The fall-through indicates that the artifact cannot be found;
        // for instance if package produced nothing or classifier problems.
        return null;
    }

    private File determinePreviouslyPackagedArtifactFile( MavenProject project, Artifact artifact )
    {
        if ( artifact == null )
        {
            return null;
        }

        String fileName = String.format( "%s.%s", project.getBuild().getFinalName(), artifact.getExtension() );
        return new File( project.getBuild().getDirectory(), fileName );
    }

    private boolean hasArtifactFileFromPackagePhase( Artifact projectArtifact )
    {
        return projectArtifact != null && projectArtifact.getFile() != null && projectArtifact.getFile().exists();
    }

    private boolean isPackagedArtifactUpToDate( MavenProject project, File packagedArtifactFile, Artifact artifact )
    {
        Path outputDirectory = Paths.get( project.getBuild().getOutputDirectory() );
        if ( !outputDirectory.toFile().exists() )
        {
            return true;
        }

        try ( Stream<Path> outputFiles = Files.walk( outputDirectory ) )
        {
            // Not using File#lastModified() to avoid a Linux JDK8 milliseconds precision bug: JDK-8177809.
            long artifactLastModified = Files.getLastModifiedTime( packagedArtifactFile.toPath() ).toMillis();

            if ( session.getProjectBuildingRequest().getBuildStartTime() != null )
            {
                long buildStartTime = session.getProjectBuildingRequest().getBuildStartTime().getTime();
                if ( artifactLastModified > buildStartTime )
                {
                    return true;
                }
            }

            Iterator<Path> iterator = outputFiles.iterator();
            while ( iterator.hasNext() )
            {
                Path outputFile = iterator.next();

                if ( Files.isDirectory(  outputFile ) )
                {
                    continue;
                }

                long outputFileLastModified = Files.getLastModifiedTime( outputFile ).toMillis();
                if ( outputFileLastModified > artifactLastModified )
                {
                    File alternative = determineBuildOutputDirectoryForArtifact( project, artifact );
                    if ( alternative != null )
                    {
                        LOGGER.warn( "File '{}' is more recent than the packaged artifact for '{}'; using '{}' instead",
                                relativizeOutputFile( outputFile ), project.getArtifactId(),
                                relativizeOutputFile( alternative.toPath() ) );
                    }
                    else
                    {
                        LOGGER.warn( "File '{}' is more recent than the packaged artifact for '{}'; "
                                + "cannot use the build output directory for this type of artifact",
                                relativizeOutputFile( outputFile ), project.getArtifactId() );
                    }
                    return false;
                }
            }

            return true;
        }
        catch ( IOException e )
        {
            LOGGER.warn( "An I/O error occurred while checking if the packaged artifact is up-to-date "
                    + "against the build output directory. "
                    + "Continuing with the assumption that it is up-to-date.", e );
            return true;
        }
    }

    private boolean hasBeenPackagedDuringThisSession( MavenProject project )
    {
        return project.hasLifecyclePhase( "package" ) || project.hasLifecyclePhase( "install" )
            || project.hasLifecyclePhase( "deploy" );
    }

    private Path relativizeOutputFile( final Path outputFile )
    {
        Path projectBaseDirectory = Paths.get( session.getRequest().getMultiModuleProjectDirectory().toURI() );
        return projectBaseDirectory.relativize( outputFile );
    }

    /**
     * Tries to resolve the specified artifact from the artifacts of the given project.
     *
     * @param project The project to try to resolve the artifact from, must not be <code>null</code>.
     * @param requestedArtifact The artifact to resolve, must not be <code>null</code>.
     * @return The matching artifact from the project or <code>null</code> if not found. Note that this
     */
    private Artifact findMatchingArtifact( MavenProject project, Artifact requestedArtifact )
    {
        String requestedRepositoryConflictId = ArtifactIdUtils.toVersionlessId( requestedArtifact );

        Artifact mainArtifact = RepositoryUtils.toArtifact( project.getArtifact() );
        if ( requestedRepositoryConflictId.equals( ArtifactIdUtils.toVersionlessId( mainArtifact ) ) )
        {
            return mainArtifact;
        }

        for ( Artifact attachedArtifact : RepositoryUtils.toArtifacts( project.getAttachedArtifacts() ) )
        {
            if ( attachedArtifactComparison( requestedArtifact, attachedArtifact ) )
            {
                return attachedArtifact;
            }
        }

        return null;
    }

    private boolean attachedArtifactComparison( Artifact requested, Artifact attached )
    {
        //
        // We are taking as much as we can from the DefaultArtifact.equals(). The requested artifact has no file so
        // we want to remove that from the comparison.
        //
        return requested.getArtifactId().equals( attached.getArtifactId() )
            && requested.getGroupId().equals( attached.getGroupId() )
            && requested.getVersion().equals( attached.getVersion() )
            && requested.getExtension().equals( attached.getExtension() )
            && requested.getClassifier().equals( attached.getClassifier() );
    }

    /**
     * Determines whether the specified artifact refers to test classes.
     *
     * @param artifact The artifact to check, must not be {@code null}.
     * @return {@code true} if the artifact refers to test classes, {@code false} otherwise.
     */
    private static boolean isTestArtifact( Artifact artifact )
    {
        return ( "test-jar".equals( artifact.getProperty( "type", "" ) ) )
            || ( "jar".equals( artifact.getExtension() ) && "tests".equals( artifact.getClassifier() ) );
    }
}