/*

  * 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.archetype.mojos;

 import org.apache.commons.collections.CollectionUtils;

 import org.apache.maven.archetype.common.Constants;

 import org.apache.maven.archetype.exception.ArchetypeGenerationFailure;

 import org.apache.maven.archetype.exception.ArchetypeNotConfigured;

 import org.apache.maven.archetype.exception.OutputFileExists;

 import org.apache.maven.archetype.exception.PomFileExists;

 import org.apache.maven.archetype.exception.ProjectDirectoryExists;

 import org.apache.maven.archetype.exception.UnknownArchetype;

 import org.apache.maven.archetype.generator.FilesetArchetypeGenerator;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.project.MavenProject;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.io.StringWriter;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Properties;

 /**

  * Execute the archetype integration tests.

  *

  * @author rafale

  * @requiresProject true

  * @goal integration-test

  */

 public class IntegrationTestMojo

     extends AbstractMojo

 {

     /** @component */

     FilesetArchetypeGenerator filesetGenerator;

     /**

      * The archetype project to execute the integration tests on.

      *

      * @parameter expression="${project}"

      * @required

      * @readonly

      */

     private MavenProject project;

     /**

      * Skip the integration test.

      *

      * @parameter expression="${archetype.test.skip}"

      * @readonly

      */

     private boolean skip = false;

     public void execute()

         throws

         MojoExecutionException,

         MojoFailureException

     {

         if ( !skip )

         {

             try

             {

                 File projectsDirectory =

                     new File( project.getBasedir(), "target/test-classes/projects" );

                 if ( projectsDirectory.exists() )

                 {

                     File archetypeFile = project.getArtifact().getFile();

                     List projectsGoalFiles =

                         FileUtils.getFiles( projectsDirectory, "*/goal.txt", "" );

                     Iterator goalFiles = projectsGoalFiles.iterator();

                     StringWriter errorWriter = new StringWriter();

                     while ( goalFiles.hasNext() )

                     {

                         File goalFile = (File) goalFiles.next();

                         try

                         {

                             processIntegrationTest( goalFile, archetypeFile );

                         }

                         catch ( IntegrationTestFailure ex )

                         {

                             errorWriter.write(

                                 "Test " + goalFile.getParentFile().getName() + " failed\n"

                             );

                             errorWriter.write( ex.getStackTrace() + "\n" );

                             errorWriter.write( ex.getMessage() + "\n" );

                             errorWriter.write( "\n" );

                         }

                     }

                     String errors = errorWriter.toString();

                     if ( !StringUtils.isEmpty( errors ) )

                     {

                         throw new MojoExecutionException( errors );

                     }

                 }

             }

             catch ( IOException ex )

             {

                 throw new MojoFailureException( ex, ex.getMessage(), ex.getMessage() );

             }

         }

     }

     private void assertTest( File reference,

                              File basedir )

         throws

         IntegrationTestFailure,

         IOException

     {

         List referenceFiles = FileUtils.getFileNames( reference, "**", null, false );

         List projectFiles = FileUtils.getFileNames( basedir, "**", null, false );

         boolean fileNamesEquals =

             CollectionUtils.isEqualCollection( referenceFiles, projectFiles );

         {

             Iterator refs = referenceFiles.iterator();

             while ( refs.hasNext() )

             {

                 String ref = (String) refs.next();

                 if ( projectFiles.contains( ref ) )

                 {

                     projectFiles.remove( ref );

                     getLog().debug( "Contained " + ref );

                 }

                 else

                 {

                     getLog().debug( "Not contained " + ref );

                 }

             }

             getLog().debug( "Remains " + projectFiles );

         }

         if ( !fileNamesEquals )

         {

             throw new IntegrationTestFailure( "Reference and generated project differs" );

         }

         boolean contentEquals = true;

         Iterator files = referenceFiles.iterator();

         while ( files.hasNext() )

         {

             String file = (String) files.next();

             if ( file.endsWith( "pom.xml" ) )

             {

                 if ( !modelEquals( new File( reference, file ), new File( basedir, file ) ) )

                 {

                     getLog().warn( "Contents of file " + file + " are not equal" );

                     contentEquals = false;

                 }

             }

             else

             {

                 if ( !FileUtils.contentEquals(

                     new File( reference, file ),

                     new File( basedir, file )

                 )

                     )

                 {

                     getLog().warn( "Contents of file " + file + " are not equal" );

                     contentEquals = false;

                 }

             }

         }

         if ( !contentEquals )

         {

             throw new IntegrationTestFailure( "Some content are not equals" );

         }

     }

     private Properties loadProperties( final File propertiesFile )

         throws

         IOException,

         FileNotFoundException

     {

         Properties properties = new Properties();

         properties.load( new FileInputStream( propertiesFile ) );

         return properties;

     }

     private boolean modelEquals( File referencePom,

                                  File generatedPom )

         throws

         IOException

     {

         return FileUtils.contentEquals( referencePom, generatedPom );

     }

     private void processIntegrationTest( File goalFile,

                                          File archetypeFile )

         throws

         IntegrationTestFailure

     {

         try

         {

             Properties testProperties = getTestProperties( goalFile );

             Properties properties = getProperties( goalFile );

             String basedir = goalFile.getParentFile().getPath() + "/project";

             FileUtils.mkdir( basedir );

 //TODO: fix this to use request

             filesetGenerator.generateArchetype( null, archetypeFile, basedir );

             File reference = new File( goalFile.getParentFile(), "reference" );

             assertTest(

                 reference,

                 new File( basedir, properties.getProperty( Constants.ARTIFACT_ID ) )

             );

         }

         catch ( ArchetypeNotConfigured ex )

         {

             throw new IntegrationTestFailure( ex );

         }

         catch ( UnknownArchetype ex )

         {

             throw new IntegrationTestFailure( ex );

         }

         catch ( PomFileExists ex )

         {

             throw new IntegrationTestFailure( ex );

         }

         catch ( ProjectDirectoryExists ex )

         {

             throw new IntegrationTestFailure( ex );

         }

         catch ( ArchetypeGenerationFailure ex )

         {

             throw new IntegrationTestFailure( ex );

         }

         catch ( IOException ex )

         {

             throw new IntegrationTestFailure( ex );

         }

         catch ( OutputFileExists ex )

         {

             throw new IntegrationTestFailure( ex );

         }

     }

     private Properties getProperties( File goalFile )

         throws

         IOException

     {

         File propertiesFile = new File( goalFile.getParentFile(), "archetype.properties" );

         return loadProperties( propertiesFile );

     }

     private Properties getTestProperties( File goalFile )

         throws

         IOException

     {

         return loadProperties( goalFile );

     }

     class IntegrationTestFailure

         extends Exception

     {

         IntegrationTestFailure()

         {

             super();

         }

         IntegrationTestFailure( String message )

         {

             super( message );

         }

         IntegrationTestFailure( Throwable cause )

         {

             super( cause );

         }

         IntegrationTestFailure( String message,

                                 Throwable cause )

         {

             super( message, cause );

         }

     }

 }