package org.apache.maven.plugin.ear.util;

 /*

  * 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.codehaus.plexus.configuration.PlexusConfiguration;

 import org.codehaus.plexus.configuration.PlexusConfigurationException;

 import org.apache.maven.plugin.ear.EarPluginException;

 import org.apache.maven.plugin.ear.EarModuleFactory;

 import org.apache.maven.plugin.ear.UnknownArtifactTypeException;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 /**

  * Allows to map custom artifact type to standard type.

  *

  * @author <a href="snicoll@apache.org">Stephane Nicoll</a>

  * @version $Id: ArtifactTypeMappingService.java 728546 2008-12-21 22:56:51Z bentmann $

  */

 public class ArtifactTypeMappingService

 {

     static final String ARTIFACT_TYPE_MAPPING_ELEMENT = "artifactTypeMapping";

     static final String TYPE_ATTRIBUTE = "type";

     static final String MAPPING_ATTRIBUTE = "mapping";

     private static final ArtifactTypeMappingService INSTANCE = new ArtifactTypeMappingService();

     public static ArtifactTypeMappingService getInstance()

     {

         return INSTANCE;

     }

     // A standard type to a list of customType

     private final Map typeMappings;

     // The user-defined mapping for direct access

     private final Map customMappings;

     private ArtifactTypeMappingService()

     {

         this.typeMappings = new HashMap();

         this.customMappings = new HashMap();

     }

     public void configure( final PlexusConfiguration plexusConfiguration )

         throws EarPluginException, PlexusConfigurationException

     {

         // Initializes the typeMappings with default values

         init();

         // No user defined configuration

         if ( plexusConfiguration == null )

         {

             return;

         }

         // Inject users configuration

         final PlexusConfiguration[] artifactTypeMappings =

             plexusConfiguration.getChildren( ARTIFACT_TYPE_MAPPING_ELEMENT );

         for ( int i = 0; i < artifactTypeMappings.length; i++ )

         {

             PlexusConfiguration artifactTypeMapping = artifactTypeMappings[i];

             final String customType = artifactTypeMapping.getAttribute( TYPE_ATTRIBUTE );

             final String mapping = artifactTypeMapping.getAttribute( MAPPING_ATTRIBUTE );

             if ( customType == null )

             {

                 throw new EarPluginException( "Invalid artifact type mapping, type attribute should be set." );

             }

             else if ( mapping == null )

             {

                 throw new EarPluginException( "Invalid artifact type mapping, mapping attribute should be set." );

             }

             else if ( !EarModuleFactory.isStandardArtifactType( mapping ) )

             {

                 throw new EarPluginException( "Invalid artifact type mapping, mapping[" + mapping +

                     "] must be a standard Ear artifact type[" + EarModuleFactory.getStandardArtifactTypes() + "]" );

             }

             else if ( customMappings.containsKey( customType ) )

             {

                 throw new EarPluginException(

                     "Invalid artifact type mapping, type[" + customType + "] is already registered." );

             }

             else

             {

                 // Add the custom mapping

                 customMappings.put( customType, mapping );

                 // Register the custom mapping to its standard type

                 List typeMapping = (List) typeMappings.get( mapping );

                 typeMapping.add( customType );

             }

         }

     }

     /**

      * Specify whether the <tt>customType</tt> could be mapped to the

      * <tt>standardType</tt>.

      *

      * @param standardType the standard type (ejb, jar, war, ...)

      * @param customType   a user-defined type

      * @return true if the customType could be mapped to the standard type

      */

     public boolean isMappedToType( final String standardType, final String customType )

     {

         if ( !EarModuleFactory.isStandardArtifactType( standardType ) )

         {

             throw new IllegalStateException( "Artifact type[" + standardType +

                 "] is not a standard Ear artifact type[" + EarModuleFactory.getStandardArtifactTypes() + "]" );

         }

         final List typeMappings = (List) this.typeMappings.get( standardType );

         return typeMappings.contains( customType );

     }

     /**

      * Returns the standard type for the specified <tt>type</tt>. If

      * the specified type is already a standard type, the orignal type

      * is returned.

      *

      * @param type a type

      * @return the standard type (ejb, jar, war, ...) for this type

      */

     public String getStandardType( final String type )

         throws UnknownArtifactTypeException

     {

         if ( type == null )

         {

             throw new IllegalStateException( "custom type could not be null." );

         }

         else if ( EarModuleFactory.getStandardArtifactTypes().contains( type ) )

         {

             return type;

         }

         else if ( !customMappings.containsKey( type ) )

         {

             throw new UnknownArtifactTypeException( "Unknown artifact type[" + type + "]" );

         }

         else

         {

             return (String) customMappings.get( type );

         }

     }

     private void init()

     {

         // Initialize the typeMappings

         typeMappings.clear();

         // Clear the customMappings

         customMappings.clear();

         // Initialize the mapping with the standard artifact types

         final Iterator it = EarModuleFactory.getStandardArtifactTypes().iterator();

         while ( it.hasNext() )

         {

             String type = (String) it.next();

             List typeMapping = new ArrayList();

             typeMapping.add( type );

             this.typeMappings.put( type, typeMapping );

         }

     }

 }