package org.apache.maven.plugins.shade.resource;

 /*

  * 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.apache.maven.plugins.shade.relocation.Relocator;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.ReaderFactory;

 import org.codehaus.plexus.util.WriterFactory;

 import org.codehaus.plexus.util.xml.Xpp3Dom;

 import org.codehaus.plexus.util.xml.Xpp3DomBuilder;

 import org.codehaus.plexus.util.xml.Xpp3DomWriter;

 import java.io.BufferedInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.Reader;

 import java.io.Writer;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.jar.JarEntry;

 import java.util.jar.JarOutputStream;

 /**

  * A resource processor that aggregates plexus <code>components.xml</code> files.

  */

 public class ComponentsXmlResourceTransformer

     implements ResourceTransformer

 {

     private Map<String, Xpp3Dom> components = new LinkedHashMap<String, Xpp3Dom>();

     public static final String COMPONENTS_XML_PATH = "META-INF/plexus/components.xml";

     public boolean canTransformResource( String resource )

     {

         return COMPONENTS_XML_PATH.equals( resource );

     }

     public void processResource( String resource, InputStream is, List<Relocator> relocators )

         throws IOException

     {

         Xpp3Dom newDom;

         try

         {

             BufferedInputStream bis = new BufferedInputStream( is )

             {

                 public void close()

                     throws IOException

                 {

                     // leave ZIP open

                 }

             };

             Reader reader = ReaderFactory.newXmlReader( bis );

             newDom = Xpp3DomBuilder.build( reader );

         }

         catch ( Exception e )

         {

             throw (IOException) new IOException( "Error parsing components.xml in " + is ).initCause( e );

         }

         // Only try to merge in components if there are some elements in the component-set

         if ( newDom.getChild( "components" ) == null )

         {

             return;

         }

         Xpp3Dom[] children = newDom.getChild( "components" ).getChildren( "component" );

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

         {

             Xpp3Dom component = children[i];

             String role = getValue( component, "role" );

             role = getRelocatedClass( role, relocators );

             setValue( component, "role", role );

             String roleHint = getValue( component, "role-hint" );

             String impl = getValue( component, "implementation" );

             impl = getRelocatedClass( impl, relocators );

             setValue( component, "implementation", impl );

             String key = role + ':' + roleHint;

             if ( components.containsKey( key ) )

             {

                 // TODO: use the tools in Plexus to merge these properly. For now, I just need an all-or-nothing

                 // configuration carry over

                 Xpp3Dom dom = components.get( key );

                 if ( dom.getChild( "configuration" ) != null )

                 {

                     component.addChild( dom.getChild( "configuration" ) );

                 }

             }

             Xpp3Dom requirements = component.getChild( "requirements" );

             if ( requirements != null && requirements.getChildCount() > 0 )

             {

                 for ( int r = requirements.getChildCount() - 1; r >= 0; r-- )

                 {

                     Xpp3Dom requirement = requirements.getChild( r );

                     String requiredRole = getValue( requirement, "role" );

                     requiredRole = getRelocatedClass( requiredRole, relocators );

                     setValue( requirement, "role", requiredRole );

                 }

             }

             components.put( key, component );

         }

     }

     public void modifyOutputStream( JarOutputStream jos )

         throws IOException

     {

         byte[] data = getTransformedResource();

         jos.putNextEntry( new JarEntry( COMPONENTS_XML_PATH ) );

         IOUtil.copy( data, jos );

         components.clear();

     }

     public boolean hasTransformedResource()

     {

         return !components.isEmpty();

     }

     byte[] getTransformedResource()

         throws IOException

     {

         ByteArrayOutputStream baos = new ByteArrayOutputStream( 1024 * 4 );

         Writer writer = WriterFactory.newXmlWriter( baos );

         try

         {

             Xpp3Dom dom = new Xpp3Dom( "component-set" );

             Xpp3Dom componentDom = new Xpp3Dom( "components" );

             dom.addChild( componentDom );

             for ( Xpp3Dom component : components.values() )

             {

                 componentDom.addChild( component );

             }

             Xpp3DomWriter.write( writer, dom );

         }

         finally

         {

             IOUtil.close( writer );

         }

         return baos.toByteArray();

     }

     private String getRelocatedClass( String className, List<Relocator> relocators )

     {

         if ( className != null && className.length() > 0 && relocators != null )

         {

             for ( Relocator relocator : relocators )

             {

                 if ( relocator.canRelocateClass( className ) )

                 {

                     return relocator.relocateClass( className );

                 }

             }

         }

         return className;

     }

     private static String getValue( Xpp3Dom dom, String element )

     {

         Xpp3Dom child = dom.getChild( element );

         return ( child != null && child.getValue() != null ) ? child.getValue() : "";

     }

     private static void setValue( Xpp3Dom dom, String element, String value )

     {

         Xpp3Dom child = dom.getChild( element );

         if ( child == null || value == null || value.length() <= 0 )

         {

             return;

         }

         child.setValue( value );

     }

 }