/*
 * 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.codehaus.mojo.archetypeng.creator;

import org.apache.maven.model.Build;
import org.apache.maven.model.Extension;
import org.apache.maven.model.Model;
import org.apache.maven.model.Plugin;
import org.apache.maven.project.MavenProject;

import org.codehaus.mojo.archetypeng.ArchetypeConfiguration;
import org.codehaus.mojo.archetypeng.ArchetypeDefinition;
import org.codehaus.mojo.archetypeng.ArchetypeFactory;
import org.codehaus.mojo.archetypeng.ArchetypeFilesResolver;
import org.codehaus.mojo.archetypeng.ArchetypePropertiesManager;
import org.codehaus.mojo.archetypeng.Constants;
import org.codehaus.mojo.archetypeng.FileCharsetDetector;
import org.codehaus.mojo.archetypeng.ListScanner;
import org.codehaus.mojo.archetypeng.PathUtils;
import org.codehaus.mojo.archetypeng.PomManager;
import org.codehaus.mojo.archetypeng.archetype.filesets.ArchetypeDescriptor;
import org.codehaus.mojo.archetypeng.archetype.filesets.FileSet;
import org.codehaus.mojo.archetypeng.archetype.filesets.ModuleDescriptor;
import org.codehaus.mojo.archetypeng.archetype.filesets.RequiredProperty;
import org.codehaus.mojo.archetypeng.archetype.filesets.io.xpp3.ArchetypeDescriptorXpp3Writer;
import org.codehaus.mojo.archetypeng.creator.olddescriptor.OldArchetypeDescriptor;
import org.codehaus.mojo.archetypeng.creator.olddescriptor.OldArchetypeDescriptorXpp3Writer;
import org.codehaus.mojo.archetypeng.exception.ArchetypeNotConfigured;
import org.codehaus.mojo.archetypeng.exception.ArchetypeNotDefined;
import org.codehaus.mojo.archetypeng.exception.TemplateCreationException;

import org.codehaus.plexus.logging.AbstractLogEnabled;
import org.codehaus.plexus.util.DirectoryScanner;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * @plexus.component  role-hint="fileset"
 */
public class FilesetArchetypeCreator
extends AbstractLogEnabled
implements ArchetypeCreator
{
    /**
     * @plexus.requirement
     */
    private ArchetypeFactory archetypeFactory;

    /**
     * @plexus.requirement
     */
    private ArchetypeFilesResolver archetypeFilesResolver;

    /**
     * @plexus.requirement
     */
    private ArchetypePropertiesManager archetypePropertiesManager;

    /**
     * @plexus.requirement
     */
    private PomManager pomManager;

    public void createArchetype (
        MavenProject project,
        File propertyFile,
        List languages,
        List filtereds,
        String defaultEncoding
    )
    throws IOException,
        ArchetypeNotDefined,
        ArchetypeNotConfigured,
        TemplateCreationException,
        XmlPullParserException
    {
        Properties properties = initialiseArchetypeProperties ( propertyFile );

        ArchetypeDefinition archetypeDefinition =
            archetypeFactory.createArchetypeDefinition ( properties );
        if ( !archetypeDefinition.isDefined () )
        {
            throw new ArchetypeNotDefined ( "The archetype is not defined" );
        }

        ArchetypeConfiguration archetypeConfiguration =
            archetypeFactory.createArchetypeConfiguration ( archetypeDefinition, properties );
        if ( !archetypeConfiguration.isConfigured () )
        {
            throw new ArchetypeNotConfigured ( "The archetype is not configured" );
        }

        File basedir = project.getBasedir ();
        File generatedSourcesDirectory =
            FileUtils.resolveFile ( basedir, getGeneratedSourcesDirectory () );
        generatedSourcesDirectory.mkdirs ();
        getLogger ().debug ( "Creating archetype in " + generatedSourcesDirectory );

        Model model = new Model ();
        model.setModelVersion ( "4.0.0" );
        model.setGroupId ( archetypeDefinition.getGroupId () );
        model.setArtifactId ( archetypeDefinition.getArtifactId () );
        model.setVersion ( archetypeDefinition.getVersion () );
        model.setPackaging ( "maven-archetype" );

        Build build = new Build ();
        model.setBuild ( build );

        Extension extension = new Extension ();
        extension.setGroupId ( "org.codehaus.mojo" );
        extension.setArtifactId ( "maven-archetypeng-plugin" );
        extension.setVersion ( "1.0-SNAPSHOT" );
        model.getBuild ().addExtension ( extension );

        Plugin plugin = new Plugin ();
        plugin.setGroupId ( "org.codehaus.mojo" );
        plugin.setArtifactId ( "maven-archetypeng-plugin" );
        plugin.setVersion ( "1.0-SNAPSHOT" );
        plugin.setExtensions ( true );
        model.getBuild ().addPlugin ( plugin );
        getLogger ().debug ( "Creating archetype's pom" );

        File archetypePomFile = FileUtils.resolveFile ( basedir, getArchetypePom () );
        archetypePomFile.getParentFile ().mkdirs ();
        pomManager.writePom ( model, archetypePomFile );

        File archetypeResourcesDirectory =
            FileUtils.resolveFile ( generatedSourcesDirectory, getTemplateOutputDirectory () );
        archetypeResourcesDirectory.mkdirs ();

        File archetypeFilesDirectory =
            FileUtils.resolveFile ( archetypeResourcesDirectory, Constants.ARCHETYPE_RESOURCES );
        archetypeFilesDirectory.mkdirs ();
        getLogger ().debug ( "Archetype's files output directory " + archetypeFilesDirectory );

        File replicaMainDirectory =
            FileUtils.resolveFile (
                generatedSourcesDirectory,
                getReplicaOutputDirectory () + File.separator
                + archetypeDefinition.getArtifactId ()
            );
        replicaMainDirectory.mkdirs ();

        File replicaFilesDirectory = FileUtils.resolveFile ( replicaMainDirectory, "reference" );
        replicaFilesDirectory.mkdirs ();

        File archetypeDescriptorFile =
            FileUtils.resolveFile ( archetypeResourcesDirectory, Constants.ARCHETYPE_DESCRIPTOR );
        archetypeDescriptorFile.getParentFile ().mkdirs ();

        ArchetypeDescriptor archetypeDescriptor = new ArchetypeDescriptor ();
        archetypeDescriptor.setId ( archetypeDefinition.getArtifactId () );
        getLogger ().debug (
            "Starting archetype's descriptor " + archetypeDefinition.getArtifactId ()
        );
        archetypeDescriptor.setPartial ( false );

        addRequiredProperties ( archetypeDescriptor, properties );

        // TODO ensure reversedproperties contains NO dotted properties
        Properties reverseProperties = getRequiredProperties ( archetypeDescriptor, properties );
        reverseProperties.remove ( Constants.GROUP_ID );

        // TODO ensure pomReversedProperties contains NO dotted properties
        Properties pomReversedProperties =
            getRequiredProperties ( archetypeDescriptor, properties );
        pomReversedProperties.remove ( Constants.PACKAGE );

        String packageName = archetypeConfiguration.getProperty ( Constants.PACKAGE );

        Model pom =
            pomManager.readPom ( FileUtils.resolveFile ( basedir, Constants.ARCHETYPE_POM ) );

        List fileNames = resolveFileNames ( pom, basedir );

        List filesets =
            resolveFileSets ( packageName, fileNames, languages, filtereds, defaultEncoding );
        getLogger ().debug ( "Resolved filesets for " + archetypeDescriptor.getId () );

        archetypeDescriptor.setFileSets ( filesets );

        createArchetypeFiles (
            reverseProperties,
            filesets,
            packageName,
            basedir,
            archetypeFilesDirectory,
            defaultEncoding
        );
        getLogger ().debug ( "Created files for " + archetypeDescriptor.getId () );

        createReplicaFiles ( filesets, basedir, replicaFilesDirectory );
        getLogger ().debug ( "Created replica files for " + archetypeDescriptor.getId () );

        FileUtils.copyFile (
            propertyFile,
            new File ( replicaMainDirectory, "archetype.properties" )
        );
        new File ( replicaMainDirectory, "goal.txt" ).createNewFile ();

        setParentArtifactId (
            reverseProperties,
            pomReversedProperties,
            archetypeConfiguration.getProperty ( Constants.ARTIFACT_ID )
        );

        Iterator modules = pom.getModules ().iterator ();
        while ( modules.hasNext () )
        {
            String moduleId = (String) modules.next ();

            setArtifactId ( reverseProperties, pomReversedProperties, moduleId );

            getLogger ().debug ( "Creating module " + moduleId );

            ModuleDescriptor moduleDescriptor =
                createModule (
                    reverseProperties,
                    pomReversedProperties,
                    moduleId,
                    packageName,
                    FileUtils.resolveFile ( basedir, moduleId ),
                    FileUtils.resolveFile ( archetypeFilesDirectory, moduleId ),
                    FileUtils.resolveFile ( replicaFilesDirectory, moduleId ),
                    languages,
                    filtereds,
                    defaultEncoding
                );

            archetypeDescriptor.addModule ( moduleDescriptor );
            getLogger ().debug (
                "Added module " + moduleDescriptor.getId () + " in "
                + archetypeDescriptor.getId ()
            );
        }
        restoreParentArtifactId ( reverseProperties, pomReversedProperties, null );
        restoreArtifactId (
            reverseProperties,
            pomReversedProperties,
            archetypeConfiguration.getProperty ( Constants.ARTIFACT_ID )
        );

        createArchetypePom (
            pom,
            archetypeFilesDirectory,
            pomReversedProperties,
            FileUtils.resolveFile ( basedir, Constants.ARCHETYPE_POM )
        );
        getLogger ().debug ( "Created Archetype " + archetypeDescriptor.getId () + " pom" );

        ArchetypeDescriptorXpp3Writer writer = new ArchetypeDescriptorXpp3Writer ();
        writer.write ( new FileWriter ( archetypeDescriptorFile ), archetypeDescriptor );
        getLogger ().debug ( "Archetype " + archetypeDescriptor.getId () + " descriptor written" );

        OldArchetypeDescriptor oldDescriptor = convertToOldDescriptor (archetypeDescriptor.getId (), packageName, basedir);
        File oldDescriptorFile =
            FileUtils.resolveFile ( archetypeResourcesDirectory, Constants.OLD_ARCHETYPE_DESCRIPTOR );
        archetypeDescriptorFile.getParentFile ().mkdirs ();
        writeOldDescriptor(oldDescriptor, oldDescriptorFile);
        getLogger ().debug ( "Archetype " + archetypeDescriptor.getId () + " old descriptor written" );

    }

    private void addRequiredProperties (
        ArchetypeDescriptor archetypeDescriptor,
        Properties properties
    )
    {
        Properties requiredProperties = new Properties ();
        requiredProperties.putAll ( properties );
        requiredProperties.remove ( Constants.ARCHETYPE_GROUP_ID );
        requiredProperties.remove ( Constants.ARCHETYPE_ARTIFACT_ID );
        requiredProperties.remove ( Constants.ARCHETYPE_VERSION );
        requiredProperties.remove ( Constants.GROUP_ID );
        requiredProperties.remove ( Constants.ARTIFACT_ID );
        requiredProperties.remove ( Constants.VERSION );
        requiredProperties.remove ( Constants.PACKAGE );

        Iterator propertiesIterator = requiredProperties.keySet ().iterator ();
        while ( propertiesIterator.hasNext () )
        {
            String propertyKey = (String) propertiesIterator.next ();
            RequiredProperty requiredProperty = new RequiredProperty ();
            requiredProperty.setKey ( propertyKey );
            requiredProperty.setDefaultValue ( requiredProperties.getProperty ( propertyKey ) );
            archetypeDescriptor.addRequiredProperty ( requiredProperty );

            getLogger ().debug (
                "Adding requiredProperty " + propertyKey + "="
                + requiredProperties.getProperty ( propertyKey ) + "to archetype's descriptor"
            );
        }
    }

    private String getArchetypePom ()
    {
        return getGeneratedSourcesDirectory () + File.separator + Constants.ARCHETYPE_POM;
    }

    private void setArtifactId (
        Properties reverseProperties,
        Properties pomReversedProperties,
        String artifactId
    )
    {
        reverseProperties.setProperty ( Constants.ARTIFACT_ID, artifactId );
        pomReversedProperties.setProperty ( Constants.ARTIFACT_ID, artifactId );
    }

    private List concatenateToList ( List toConcatenate, String with )
    {
        List result = new ArrayList ( toConcatenate.size () );
        Iterator iterator = toConcatenate.iterator ();
        while ( iterator.hasNext () )
        {
            String concatenate = (String) iterator.next ();
            result.add ( ( ( with.length () > 0 ) ? ( with + "/" + concatenate ) : concatenate ) );
        }
        return result;
    }

    private void copyFiles (
        File basedir,
        File archetypeFilesDirectory,
        String directory,
        List fileSetResources,
        boolean packaged,
        String packageName
    )
    throws IOException
    {
        Iterator iterator = fileSetResources.iterator ();

        while ( iterator.hasNext () )
        {
            String inputFileName = (String) iterator.next ();

            String packageAsDirectory = StringUtils.replace ( packageName, ".", "/" );

            String outputFileName =
                packaged ? StringUtils.replace ( inputFileName, packageAsDirectory + "/", "" )
                         : inputFileName;

            File outputFile = new File ( archetypeFilesDirectory, outputFileName );

            File inputFile = new File ( basedir, inputFileName );

            outputFile.getParentFile ().mkdirs ();

            FileUtils.copyFile ( inputFile, outputFile );
        } // end while
    }

    private void copyPom ( File basedir, File replicaFilesDirectory )
    throws IOException
    {
        FileUtils.copyFileToDirectory (
            new File ( basedir, Constants.ARCHETYPE_POM ),
            replicaFilesDirectory
        );
    }

    private void createArchetypeFiles (
        Properties reverseProperties,
        List fileSets,
        String packageName,
        File basedir,
        File archetypeFilesDirectory,
        String defaultEncoding
    )
    throws IOException
    {
        getLogger ().debug (
            "Creating Archetype/Module files from " + basedir + " to " + archetypeFilesDirectory
        );

        Iterator iterator = fileSets.iterator ();

        while ( iterator.hasNext () )
        {
            FileSet fileSet = (FileSet) iterator.next ();

            DirectoryScanner scanner = new DirectoryScanner ();
            scanner.setBasedir ( basedir );
            scanner.setIncludes (
                (String[]) concatenateToList ( fileSet.getIncludes (), fileSet.getDirectory () )
                .toArray ( new String[fileSet.getIncludes ().size ()] )
            );
            scanner.setExcludes (
                (String[]) fileSet.getExcludes ().toArray (
                    new String[fileSet.getExcludes ().size ()]
                )
            );
            scanner.addDefaultExcludes ();
            getLogger ().debug ( "Using fileset " + fileSet );
            scanner.scan ();

            List fileSetResources = Arrays.asList ( scanner.getIncludedFiles () );

            if ( fileSet.isFiltered () )
            {
                processFileSet (
                    basedir,
                    archetypeFilesDirectory,
                    fileSet.getDirectory (),
                    fileSetResources,
                    fileSet.isPackaged (),
                    packageName,
                    reverseProperties,
                    defaultEncoding
                );
                getLogger ().debug ( "Processed " + fileSet.getDirectory () + " files" );
            }
            else
            {
                copyFiles (
                    basedir,
                    archetypeFilesDirectory,
                    fileSet.getDirectory (),
                    fileSetResources,
                    fileSet.isPackaged (),
                    packageName
                );
                getLogger ().debug ( "Copied " + fileSet.getDirectory () + " files" );
            }
        } // end while
    }

    private void createArchetypePom (
        Model pom,
        File archetypeFilesDirectory,
        Properties pomReversedProperties,
        File initialPomFile
    )
    throws IOException
    {
//        pom.setParent ( null );
//        pom.setModules ( null );
//        pom.setGroupId ( "${" + Constants.GROUP_ID + "}" );
//        pom.setArtifactId ( "${" + Constants.ARTIFACT_ID + "}" );
//        pom.setVersion ( "${" + Constants.VERSION + "}" );

        File outputFile =
            FileUtils.resolveFile ( archetypeFilesDirectory, Constants.ARCHETYPE_POM );

        File inputFile =
            FileUtils.resolveFile ( archetypeFilesDirectory, Constants.ARCHETYPE_POM + ".tmp" );

        FileUtils.copyFile ( initialPomFile, inputFile );

//        pomManager.writePom ( pom, inputFile );

        String initialcontent = FileUtils.fileRead ( inputFile );

        String content = getReversedContent ( initialcontent, pomReversedProperties );

        outputFile.getParentFile ().mkdirs ();

        FileUtils.fileWrite ( outputFile.getAbsolutePath (), content );

        inputFile.delete ();
    }

    private FileSet createFileSet (
        final List excludes,
        final boolean packaged,
        final boolean filtered,
        final String group,
        final List includes,
        String defaultEncoding
    )
    {
        FileSet fileSet = new FileSet ();

        fileSet.setDirectory ( group );
        fileSet.setPackaged ( packaged );
        fileSet.setFiltered ( filtered );
        fileSet.setIncludes ( includes );
        fileSet.setExcludes ( excludes );
        fileSet.setEncoding ( defaultEncoding );

        getLogger ().debug ( "Created Fileset " + fileSet );

        return fileSet;
    }

    private List createFileSets (
        List files,
        int level,
        boolean packaged,
        String packageName,
        boolean filtered,
        String defaultEncoding
    )
    {
        List fileSets = new ArrayList ();

        if ( !files.isEmpty () )
        {
            getLogger ().debug (
                "Creating filesets" + ( packaged ? ( " packaged (" + packageName + ")" ) : "" )
                + ( filtered ? " filtered" : "" ) + " at level " + level
            );
            if ( level == 0 )
            {
                List includes = new ArrayList ();
                List excludes = new ArrayList ();

                Iterator filesIterator = files.iterator ();
                while ( filesIterator.hasNext () )
                {
                    String file = (String) filesIterator.next ();

                    includes.add ( file );
                }

                if ( !includes.isEmpty () )
                {
                    fileSets.add (
                        createFileSet (
                            excludes,
                            packaged,
                            filtered,
                            "",
                            includes,
                            defaultEncoding
                        )
                    );
                }
            }
            else
            {
                Map groups = getGroupsMap ( files, level );

                Iterator groupIterator = groups.keySet ().iterator ();
                while ( groupIterator.hasNext () )
                {
                    String group = (String) groupIterator.next ();

                    getLogger ().debug ( "Creating filesets for group " + group );

                    if ( !packaged )
                    {
                        fileSets.add (
                            getUnpackagedFileSet (
                                filtered,
                                group,
                                (List) groups.get ( group ),
                                defaultEncoding
                            )
                        );
                    }
                    else
                    {
                        fileSets.addAll (
                            getPackagedFileSets (
                                filtered,
                                group,
                                (List) groups.get ( group ),
                                packageName,
                                defaultEncoding
                            )
                        );
                    }
                }
            } // end if

            getLogger ().debug ( "Resolved " + fileSets.size () + " filesets" );
        } // end if
        return fileSets;
    }

    private ModuleDescriptor createModule (
        Properties reverseProperties,
        Properties pomReversedProperties,
        String moduleId,
        String packageName,
        File basedir,
        File archetypeFilesDirectory,
        File replicaFilesDirectory,
        List languages,
        List filtereds,
        String defaultEncoding
    )
    throws IOException, XmlPullParserException
    {
        ModuleDescriptor archetypeDescriptor = new ModuleDescriptor ();
        archetypeDescriptor.setId ( moduleId );
        getLogger ().debug ( "Starting module's descriptor " + moduleId );

        archetypeFilesDirectory.mkdirs ();
        getLogger ().debug ( "Module's files output directory " + archetypeFilesDirectory );

        Model pom =
            pomManager.readPom ( FileUtils.resolveFile ( basedir, Constants.ARCHETYPE_POM ) );

        List fileNames = resolveFileNames ( pom, basedir );

        List filesets =
            resolveFileSets ( packageName, fileNames, languages, filtereds, defaultEncoding );
        getLogger ().debug ( "Resolved filesets for module " + archetypeDescriptor.getId () );

        archetypeDescriptor.setFileSets ( filesets );

        createArchetypeFiles (
            reverseProperties,
            filesets,
            packageName,
            basedir,
            archetypeFilesDirectory,
            defaultEncoding
        );
        getLogger ().debug ( "Created files for module " + archetypeDescriptor.getId () );

        createReplicaFiles ( filesets, basedir, replicaFilesDirectory );
        getLogger ().debug ( "Created replica files for " + archetypeDescriptor.getId () );

        String parentArtifactId = reverseProperties.getProperty ( Constants.PARENT_ARTIFACT_ID );
        setParentArtifactId ( reverseProperties, pomReversedProperties, moduleId );

        Iterator modules = pom.getModules ().iterator ();
        while ( modules.hasNext () )
        {
            String subModuleId = (String) modules.next ();

            setArtifactId ( reverseProperties, pomReversedProperties, subModuleId );

            getLogger ().debug ( "Creating module " + subModuleId );

            ModuleDescriptor moduleDescriptor =
                createModule (
                    reverseProperties,
                    pomReversedProperties,
                    subModuleId,
                    packageName,
                    FileUtils.resolveFile ( basedir, subModuleId ),
                    FileUtils.resolveFile ( archetypeFilesDirectory, subModuleId ),
                    FileUtils.resolveFile ( replicaFilesDirectory, subModuleId ),
                    languages,
                    filtereds,
                    defaultEncoding
                );

            archetypeDescriptor.addModule ( moduleDescriptor );
            getLogger ().debug (
                "Added module " + moduleDescriptor.getId () + " in "
                + archetypeDescriptor.getId ()
            );
        }
        restoreParentArtifactId ( reverseProperties, pomReversedProperties, parentArtifactId );
        restoreArtifactId ( reverseProperties, pomReversedProperties, moduleId );

        createModulePom (
            pom,
            archetypeFilesDirectory,
            pomReversedProperties,
            FileUtils.resolveFile ( basedir, Constants.ARCHETYPE_POM )
        );
        getLogger ().debug ( "Created Module " + archetypeDescriptor.getId () + " pom" );

        return archetypeDescriptor;
    }

    private void createModulePom (
        Model pom,
        File archetypeFilesDirectory,
        Properties pomReversedProperties,
        File initialPomFile
    )
    throws IOException
    {
//        pom.setParent ( null );
//        pom.setModules ( null );
//        pom.setGroupId ( "${" + Constants.GROUP_ID + "}" );
//        pom.setArtifactId ( "${" + Constants.ARTIFACT_ID + "}" );
//        pom.setVersion ( "${" + Constants.VERSION + "}" );

        File outputFile =
            FileUtils.resolveFile ( archetypeFilesDirectory, Constants.ARCHETYPE_POM );

        File inputFile =
            FileUtils.resolveFile ( archetypeFilesDirectory, Constants.ARCHETYPE_POM + ".tmp" );

        FileUtils.copyFile ( initialPomFile, inputFile );

//        pomManager.writePom ( pom, inputFile );

        String initialcontent = FileUtils.fileRead ( inputFile );

        String content = getReversedContent ( initialcontent, pomReversedProperties );

        outputFile.getParentFile ().mkdirs ();

        FileUtils.fileWrite ( outputFile.getAbsolutePath (), content );

        inputFile.delete ();
    }

    private void createReplicaFiles ( List filesets, File basedir, File replicaFilesDirectory )
    throws IOException
    {
        getLogger ().debug (
            "Creating Archetype/Module replica files from " + basedir + " to "
            + replicaFilesDirectory
        );

        copyPom ( basedir, replicaFilesDirectory );

        Iterator iterator = filesets.iterator ();

        while ( iterator.hasNext () )
        {
            FileSet fileset = (FileSet) iterator.next ();

            DirectoryScanner scanner = new DirectoryScanner ();
            scanner.setBasedir ( basedir );
            scanner.setIncludes (
                (String[]) concatenateToList ( fileset.getIncludes (), fileset.getDirectory () )
                .toArray ( new String[fileset.getIncludes ().size ()] )
            );
            scanner.setExcludes (
                (String[]) fileset.getExcludes ().toArray (
                    new String[fileset.getExcludes ().size ()]
                )
            );
            scanner.addDefaultExcludes ();
            getLogger ().debug ( "Using fileset " + fileset );
            scanner.scan ();

            List fileSetResources = Arrays.asList ( scanner.getIncludedFiles () );

            copyFiles (
                basedir,
                replicaFilesDirectory,
                fileset.getDirectory (),
                fileSetResources,
                false,
                null
            );
            getLogger ().debug ( "Copied " + fileset.getDirectory () + " files" );
        }
    }

    private Set getExtensions ( List files )
    {
        Set extensions = new HashSet ();
        Iterator filesIterator = files.iterator ();
        while ( filesIterator.hasNext () )
        {
            String file = (String) filesIterator.next ();

            extensions.add ( FileUtils.extension ( file ) );
        }

        return extensions;
    }

    private String getGeneratedSourcesDirectory ()
    {
        return "target" + File.separator + "generated-sources" + File.separator + "archetypeng";
    }

    private Map getGroupsMap ( final List files, final int level )
    {
        Map groups = new HashMap ();
        Iterator fileIterator = files.iterator ();
        while ( fileIterator.hasNext () )
        {
            String file = (String) fileIterator.next ();

            String directory = PathUtils.getDirectory ( file, level );

            if ( !groups.containsKey ( directory ) )
            {
                groups.put ( directory, new ArrayList () );
            }

            List group = (List) groups.get ( directory );

            String innerPath = file.substring ( directory.length () + 1 );

            group.add ( innerPath );
        }
        getLogger ().debug (
            "Sorted " + groups.size () + " groups in " + files.size () + " files"
        );
        return groups;
    }

    private Properties initialiseArchetypeProperties ( File propertyFile )
    throws IOException
    {
        Properties properties = new Properties ();
        archetypePropertiesManager.readProperties ( properties, propertyFile );
        return properties;
    }

    private FileSet getPackagedFileSet (
        final boolean filtered,
        final Set packagedExtensions,
        final String group,
        final Set unpackagedExtensions,
        final List unpackagedFiles,
        String defaultEncoding
    )
    {
        List includes = new ArrayList ();
        List excludes = new ArrayList ();

        Iterator extensionsIterator = packagedExtensions.iterator ();
        while ( extensionsIterator.hasNext () )
        {
            String extension = (String) extensionsIterator.next ();

            includes.add ( "**/*." + extension );

            if ( unpackagedExtensions.contains ( extension ) )
            {
                excludes.addAll (
                    archetypeFilesResolver.getFilesWithExtension ( unpackagedFiles, extension )
                );
            }
        }

        FileSet fileset =
            createFileSet ( excludes, true, filtered, group, includes, defaultEncoding );
        return fileset;
    }

    private List getPackagedFileSets (
        final boolean filtered,
        final String group,
        final List groupFiles,
        final String packageName,
        String defaultEncoding
    )
    {
        String packageAsDir = StringUtils.replace ( packageName, ".", "/" );
        List packagedFileSets = new ArrayList ();
        List packagedFiles = archetypeFilesResolver.getPackagedFiles ( groupFiles, packageAsDir );

        List unpackagedFiles =
            archetypeFilesResolver.getUnpackagedFiles ( groupFiles, packageAsDir );

        Set packagedExtensions = getExtensions ( packagedFiles );
        getLogger ().debug ( "Found packaged extensions " + packagedExtensions );

        Set unpackagedExtensions = getExtensions ( unpackagedFiles );

        packagedFileSets.add (
            getPackagedFileSet (
                filtered,
                packagedExtensions,
                group,
                unpackagedExtensions,
                unpackagedFiles,
                defaultEncoding
            )
        );

        if ( !unpackagedExtensions.isEmpty () )
        {
            getLogger ().debug ( "Found unpackaged extensions " + unpackagedExtensions );
            packagedFileSets.add (
                getUnpackagedFileSet (
                    filtered,
                    unpackagedExtensions,
                    unpackagedFiles,
                    group,
                    packagedExtensions,
                    defaultEncoding
                )
            );
        }
        return packagedFileSets;
    }

    private void setParentArtifactId (
        Properties reverseProperties,
        Properties pomReversedProperties,
        String parentArtifactId
    )
    {
        reverseProperties.setProperty ( Constants.PARENT_ARTIFACT_ID, parentArtifactId );
        pomReversedProperties.setProperty ( Constants.PARENT_ARTIFACT_ID, parentArtifactId );
    }

    private void processFileSet (
        File basedir,
        File archetypeFilesDirectory,
        String directory,
        List fileSetResources,
        boolean packaged,
        String packageName,
        Properties reverseProperties,
        String defaultEncoding
    )
    throws IOException
    {
        Iterator iterator = fileSetResources.iterator ();

        while ( iterator.hasNext () )
        {
            String inputFileName = (String) iterator.next ();

            String packageAsDirectory = StringUtils.replace ( packageName, ".", "/" );

            String outputFileName =
                packaged ? StringUtils.replace ( inputFileName, packageAsDirectory + "/", "" )
                         : inputFileName;

            File outputFile = new File ( archetypeFilesDirectory, outputFileName );
            File inputFile = new File ( basedir, inputFileName );

            FileCharsetDetector detector = new FileCharsetDetector ( inputFile );

            String fileEncoding = detector.isFound () ? detector.getCharset () : defaultEncoding;

            String initialcontent =
                org.apache.commons.io.IOUtils.toString (
                    new FileInputStream ( inputFile ),
                    fileEncoding
                );
//            String initialcontent = FileUtils.fileRead ( inputFile );
            String content = getReversedContent ( initialcontent, reverseProperties );
            outputFile.getParentFile ().mkdirs ();
            org.apache.commons.io.IOUtils.write (
                content,
                new FileOutputStream ( outputFile ),
                fileEncoding
            );
//            FileUtils.fileWrite ( outputFile.getAbsolutePath (), content );
        } // end while
    }

    private String getReplicaOutputDirectory ()
    {
        return
            Constants.SRC + File.separator + Constants.TEST + File.separator + Constants.RESOURCES
            + File.separator + "projects";
    }

    private Properties getRequiredProperties (
        ArchetypeDescriptor archetypeDescriptor,
        Properties properties
    )
    {
        Properties reversedProperties = new Properties ();

        reversedProperties.putAll ( properties );
        reversedProperties.remove ( Constants.ARCHETYPE_GROUP_ID );
        reversedProperties.remove ( Constants.ARCHETYPE_ARTIFACT_ID );
        reversedProperties.remove ( Constants.ARCHETYPE_VERSION );
//        reversedProperties.remove ( Constants.GROUP_ID );
//        reversedProperties.remove ( Constants.ARTIFACT_ID );
//        reversedProperties.remove ( Constants.VERSION );

        return reversedProperties;
    }

    private List resolveFileNames ( final Model pom, final File basedir )
    throws IOException
    {
        getLogger ().debug ( "Resolving files for " + pom.getId () + " in " + basedir );

        Iterator modules = pom.getModules ().iterator ();
        String excludes = "pom.xml*,archetype.properties*,target/**,";
        while ( modules.hasNext () )
        {
            excludes += "," + (String) modules.next () + "/**";
        }

        Iterator defaultExcludes = Arrays.asList ( ListScanner.DEFAULTEXCLUDES ).iterator ();
        while ( defaultExcludes.hasNext () )
        {
            excludes += "," + (String) defaultExcludes.next () + "/**";
        }

        List fileNames = FileUtils.getFileNames ( basedir, "**", excludes, false );

        getLogger ().debug ( "Resolved " + fileNames.size () + " files" );

        return fileNames;
    }

    private List resolveFileSets (
        String packageName,
        List fileNames,
        List languages,
        List filtereds,
        String defaultEncoding
    )
    {
        List resolvedFileSets = new ArrayList ();
        getLogger ().debug (
            "Resolving filesets with package=" + packageName + ", languages=" + languages
            + " and extentions=" + filtereds
        );

        List files = new ArrayList ( fileNames );

        String languageIncludes = "";
        Iterator languagesIterator = languages.iterator ();
        while ( languagesIterator.hasNext () )
        {
            String language = (String) languagesIterator.next ();

            languageIncludes +=
                ( ( languageIncludes.length () == 0 ) ? "" : "," ) + language + "/**";
        }

        String filteredIncludes = "";
        Iterator filteredsIterator = filtereds.iterator ();
        while ( filteredsIterator.hasNext () )
        {
            String filtered = (String) filteredsIterator.next ();

            filteredIncludes +=
                ( ( filteredIncludes.length () == 0 ) ? "" : "," ) + "**/"
                + ( filtered.startsWith ( "." ) ? "" : "*." ) + filtered;
        }

        /*sourcesMainFiles*/
        List sourcesMainFiles =
            archetypeFilesResolver.findSourcesMainFiles ( files, languageIncludes );
        if ( !sourcesMainFiles.isEmpty () )
        {
            files.removeAll ( sourcesMainFiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles ( sourcesMainFiles, filteredIncludes ),
                    3,
                    true,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        sourcesMainFiles,
                        filteredIncludes
                    ),
                    3,
                    true,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /*resourcesMainFiles*/
        List resourcesMainFiles =
            archetypeFilesResolver.findResourcesMainFiles ( files, languageIncludes );
        if ( !resourcesMainFiles.isEmpty () )
        {
            files.removeAll ( resourcesMainFiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles (
                        resourcesMainFiles,
                        filteredIncludes
                    ),
                    3,
                    false,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        resourcesMainFiles,
                        filteredIncludes
                    ),
                    3,
                    false,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /*sourcesTestFiles*/
        List sourcesTestFiles =
            archetypeFilesResolver.findSourcesTestFiles ( files, languageIncludes );
        if ( !sourcesTestFiles.isEmpty () )
        {
            files.removeAll ( sourcesTestFiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles ( sourcesTestFiles, filteredIncludes ),
                    3,
                    true,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        sourcesTestFiles,
                        filteredIncludes
                    ),
                    3,
                    true,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /*ressourcesTestFiles*/
        List resourcesTestFiles =
            archetypeFilesResolver.findResourcesTestFiles ( files, languageIncludes );
        if ( !resourcesTestFiles.isEmpty () )
        {
            files.removeAll ( resourcesTestFiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles (
                        resourcesTestFiles,
                        filteredIncludes
                    ),
                    3,
                    false,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        resourcesTestFiles,
                        filteredIncludes
                    ),
                    3,
                    false,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /*siteFiles*/
        List siteFiles = archetypeFilesResolver.findSiteFiles ( files, languageIncludes );
        if ( !siteFiles.isEmpty () )
        {
            files.removeAll ( siteFiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles ( siteFiles, filteredIncludes ),
                    2,
                    false,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles ( siteFiles, filteredIncludes ),
                    2,
                    false,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /*thirdLevelSourcesfiles*/
        List thirdLevelSourcesfiles =
            archetypeFilesResolver.findOtherSources ( 3, files, languageIncludes );
        if ( !thirdLevelSourcesfiles.isEmpty () )
        {
            files.removeAll ( thirdLevelSourcesfiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles (
                        thirdLevelSourcesfiles,
                        filteredIncludes
                    ),
                    3,
                    true,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        thirdLevelSourcesfiles,
                        filteredIncludes
                    ),
                    3,
                    true,
                    packageName,
                    false,
                    defaultEncoding
                )
            );

            /*thirdLevelResourcesfiles*/
            List thirdLevelResourcesfiles =
                archetypeFilesResolver.findOtherResources (
                    3,
                    files,
                    thirdLevelSourcesfiles,
                    languageIncludes
                );
            if ( !thirdLevelResourcesfiles.isEmpty () )
            {
                files.removeAll ( thirdLevelResourcesfiles );
                resolvedFileSets.addAll (
                    createFileSets (
                        archetypeFilesResolver.getFilteredFiles (
                            thirdLevelResourcesfiles,
                            filteredIncludes
                        ),
                        3,
                        false,
                        packageName,
                        true,
                        defaultEncoding
                    )
                );
                resolvedFileSets.addAll (
                    createFileSets (
                        archetypeFilesResolver.getUnfilteredFiles (
                            thirdLevelResourcesfiles,
                            filteredIncludes
                        ),
                        3,
                        false,
                        packageName,
                        false,
                        defaultEncoding
                    )
                );
            }
        } // end if

        /*secondLevelSourcesfiles*/
        List secondLevelSourcesfiles =
            archetypeFilesResolver.findOtherSources ( 2, files, languageIncludes );
        if ( !secondLevelSourcesfiles.isEmpty () )
        {
            files.removeAll ( secondLevelSourcesfiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles (
                        secondLevelSourcesfiles,
                        filteredIncludes
                    ),
                    2,
                    true,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        secondLevelSourcesfiles,
                        filteredIncludes
                    ),
                    2,
                    true,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /*secondLevelResourcesfiles*/
        List secondLevelResourcesfiles =
            archetypeFilesResolver.findOtherResources ( 2, files, languageIncludes );
        if ( !secondLevelResourcesfiles.isEmpty () )
        {
            files.removeAll ( secondLevelResourcesfiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles (
                        secondLevelResourcesfiles,
                        filteredIncludes
                    ),
                    2,
                    false,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        secondLevelResourcesfiles,
                        filteredIncludes
                    ),
                    2,
                    false,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /*rootResourcesfiles*/
        List rootResourcesfiles =
            archetypeFilesResolver.findOtherResources ( 0, files, languageIncludes );
        if ( !rootResourcesfiles.isEmpty () )
        {
            files.removeAll ( rootResourcesfiles );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getFilteredFiles (
                        rootResourcesfiles,
                        filteredIncludes
                    ),
                    0,
                    false,
                    packageName,
                    true,
                    defaultEncoding
                )
            );
            resolvedFileSets.addAll (
                createFileSets (
                    archetypeFilesResolver.getUnfilteredFiles (
                        rootResourcesfiles,
                        filteredIncludes
                    ),
                    0,
                    false,
                    packageName,
                    false,
                    defaultEncoding
                )
            );
        }

        /**/
        if ( !files.isEmpty () )
        {
            getLogger ().info ( "Ignored files: " + files );
        }

        return resolvedFileSets;
    }

    private void restoreArtifactId (
        Properties reverseProperties,
        Properties pomReversedProperties,
        String artifactId
    )
    {
        if ( StringUtils.isEmpty ( artifactId ) )
        {
            reverseProperties.remove ( Constants.ARTIFACT_ID );
            pomReversedProperties.remove ( Constants.ARTIFACT_ID );
        }
        else
        {
            reverseProperties.setProperty ( Constants.ARTIFACT_ID, artifactId );
            pomReversedProperties.setProperty ( Constants.ARTIFACT_ID, artifactId );
        }
    }

    private void restoreParentArtifactId (
        Properties reverseProperties,
        Properties pomReversedProperties,
        String parentArtifactId
    )
    {
        if ( StringUtils.isEmpty ( parentArtifactId ) )
        {
            reverseProperties.remove ( Constants.PARENT_ARTIFACT_ID );
            pomReversedProperties.remove ( Constants.PARENT_ARTIFACT_ID );
        }
        else
        {
            reverseProperties.setProperty ( Constants.PARENT_ARTIFACT_ID, parentArtifactId );
            pomReversedProperties.setProperty ( Constants.PARENT_ARTIFACT_ID, parentArtifactId );
        }
    }

    private String getReversedContent ( String content, final Properties properties )
    {
        String result = content;
        Iterator propertyIterator = properties.keySet ().iterator ();
        while ( propertyIterator.hasNext () )
        {
            String propertyKey = (String) propertyIterator.next ();
            result =
                StringUtils.replace (
                    result,
                    properties.getProperty ( propertyKey ),
                    "${" + propertyKey + "}"
                );
        }
        return result;
    }

    private String getTemplateOutputDirectory ()
    {
        return
            Constants.SRC + File.separator + Constants.MAIN + File.separator + Constants.RESOURCES;
    }

    private FileSet getUnpackagedFileSet (
        final boolean filtered,
        final String group,
        final List groupFiles,
        String defaultEncoding
    )
    {
        Set extensions = getExtensions ( groupFiles );

        List includes = new ArrayList ();
        List excludes = new ArrayList ();

        Iterator extensionsIterator = extensions.iterator ();
        while ( extensionsIterator.hasNext () )
        {
            String extension = (String) extensionsIterator.next ();

            includes.add ( "**/*." + extension );
        }

        return createFileSet ( excludes, false, filtered, group, includes, defaultEncoding );
    }

    private FileSet getUnpackagedFileSet (
        final boolean filtered,
        final Set unpackagedExtensions,
        final List unpackagedFiles,
        final String group,
        final Set packagedExtensions,
        String defaultEncoding
    )
    {
        List includes = new ArrayList ();
        List excludes = new ArrayList ();

        Iterator extensionsIterator = unpackagedExtensions.iterator ();
        while ( extensionsIterator.hasNext () )
        {
            String extension = (String) extensionsIterator.next ();
            if ( packagedExtensions.contains ( extension ) )
            {
                includes.addAll (
                    archetypeFilesResolver.getFilesWithExtension ( unpackagedFiles, extension )
                );
            }
            else
            {
                includes.add ( "**/*." + extension );
            }
        }

        return createFileSet ( excludes, false, filtered, group, includes, defaultEncoding );
    }

    private OldArchetypeDescriptor convertToOldDescriptor (String id, String packageName, File basedir) throws IOException
    {
        getLogger ().debug ( "Resolving OldArchetypeDescriptor files in " + basedir );

        String excludes = "pom.xml,archetype.properties*,**/target/**";

        Iterator defaultExcludes = Arrays.asList ( ListScanner.DEFAULTEXCLUDES ).iterator ();
        while ( defaultExcludes.hasNext () )
        {
            excludes += "," + (String) defaultExcludes.next () + "/**";
        }

        List fileNames = FileUtils.getFileNames ( basedir, "**", excludes, false );

        getLogger ().debug ( "Resolved " + fileNames.size () + " files" );

        String packageAsDirectory = StringUtils.replace (packageName, '.', '/') +"/";

        List sources = archetypeFilesResolver.findSourcesMainFiles (fileNames, "java/**");
        fileNames.removeAll (sources);
         sources = removePackage(sources, packageAsDirectory);

        List testSources = archetypeFilesResolver.findSourcesTestFiles (fileNames, "java/**");
        fileNames.removeAll (testSources);
         testSources = removePackage(testSources, packageAsDirectory);

        List resources = archetypeFilesResolver.findResourcesMainFiles (fileNames, "java/**");
        fileNames.removeAll (resources);

        List testResources = archetypeFilesResolver.findResourcesTestFiles (fileNames, "java/**");
        fileNames.removeAll (testResources);

        List siteResources = archetypeFilesResolver.findSiteFiles (fileNames, null);
        fileNames.removeAll (siteResources);

        resources.addAll (fileNames);

        OldArchetypeDescriptor descriptor = new OldArchetypeDescriptor();
        descriptor.setId (id);
        descriptor.setSources (sources);
        descriptor.setTestSources (testSources);
        descriptor.setResources (resources);
        descriptor.setTestResources (testResources);
        descriptor.setSiteResources (siteResources);

        return descriptor;
    }

    private void writeOldDescriptor (OldArchetypeDescriptor oldDescriptor, File oldDescriptorFile) throws IOException
    {
        OldArchetypeDescriptorXpp3Writer writer = new OldArchetypeDescriptorXpp3Writer ();
        writer.write ( new FileWriter ( oldDescriptorFile ), oldDescriptor );
    }

    private List removePackage (List sources, String packageAsDirectory)
    {
        if (sources == null)
        {
            return null;
        }

        List unpackagedSources = new ArrayList (sources.size ());
        Iterator sourcesIterator = sources.iterator ();
        while (sourcesIterator.hasNext ())
        {
            String source = (String) sourcesIterator.next ();
            String unpackagedSource = StringUtils.replace (source, packageAsDirectory,"");
            unpackagedSources.add (unpackagedSource);
        }

        return unpackagedSources;
    }
}