/*

  * 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.shared.osgi;

 import java.io.File;

 import java.io.IOException;

 import java.util.Enumeration;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Set;

 import java.util.jar.JarFile;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import java.util.zip.ZipEntry;

 import org.apache.maven.artifact.Artifact;

 import aQute.lib.osgi.Analyzer;

 /**

  * Default implementation of {@link Maven2OsgiConverter}

  * 

  * @plexus.component

  * 

  * @author <a href="mailto:carlos@apache.org">Carlos Sanchez</a>

  * @version $Id: DefaultMaven2OsgiConverter.java 573759 2007-09-07 23:45:40Z carlos $

  */

 public class DefaultMaven2OsgiConverter

     implements Maven2OsgiConverter

 {

     /** Bundle-Version must match this pattern */

     private static final Pattern OSGI_VERSION_PATTERN = Pattern

         .compile( "[0-9]+\\.[0-9]+\\.[0-9]+(\\.[0-9A-Za-z_-]+)?" );

     /** pattern used to change - to . */

     // private static final Pattern P_VERSION = Pattern.compile("([0-9]+(\\.[0-9])*)-(.*)");

     /** pattern that matches strings that contain only numbers */

     private static final Pattern ONLY_NUMBERS = Pattern.compile( "[0-9]+" );

     private static final String FILE_SEPARATOR = System.getProperty( "file.separator" );

     private String getBundleSymbolicName( String groupId, String artifactId )

     {

         return groupId + "." + artifactId;

     }

     /**

      * Get the symbolic name as groupId + "." + artifactId, with the following exceptions

      * <ul>

      * <li>if artifact.getFile is not null and the jar contains a OSGi Manifest with

      * Bundle-SymbolicName property then that value is returned</li>

      * <li>if groupId has only one section (no dots) and artifact.getFile is not null then the

      * first package name with classes is returned. eg. commons-logging:commons-logging ->

      * org.apache.commons.logging</li>

      * <li>if artifactId is equal to last section of groupId then groupId is returned. eg.

      * org.apache.maven:maven -> org.apache.maven</li>

      * <li>if artifactId starts with last section of groupId that portion is removed. eg.

      * org.apache.maven:maven-core -> org.apache.maven.core</li>

      * </ul>

      */

     public String getBundleSymbolicName( Artifact artifact )

     {

         if ( ( artifact.getFile() != null ) && artifact.getFile().exists() )

         {

             Analyzer analyzer = new Analyzer();

             try

             {

                 JarFile jar = new JarFile( artifact.getFile(), false );

                 if ( jar.getManifest() != null )

                 {

                     String symbolicNameAttribute = jar.getManifest().getMainAttributes()

                         .getValue( Analyzer.BUNDLE_SYMBOLICNAME );

                     Map bundleSymbolicNameHeader = analyzer.parseHeader( symbolicNameAttribute );

                     Iterator it = bundleSymbolicNameHeader.keySet().iterator();

                     if ( it.hasNext() )

                     {

                         return (String) it.next();

                     }

                 }

             }

             catch ( IOException e )

             {

                 throw new ManifestReadingException( "Error reading manifest in jar "

                     + artifact.getFile().getAbsolutePath(), e );

             }

         }

         int i = artifact.getGroupId().lastIndexOf( '.' );

         if ( ( i < 0 ) && ( artifact.getFile() != null ) && artifact.getFile().exists() )

         {

             String groupIdFromPackage = getGroupIdFromPackage( artifact.getFile() );

             if ( groupIdFromPackage != null )

             {

                 return groupIdFromPackage;

             }

         }

         String lastSection = artifact.getGroupId().substring( ++i );

         if ( artifact.getArtifactId().equals( lastSection ) )

         {

             return artifact.getGroupId();

         }

         if ( artifact.getArtifactId().startsWith( lastSection ) )

         {

             String artifactId = artifact.getArtifactId().substring( lastSection.length() );

             if ( Character.isLetterOrDigit( artifactId.charAt( 0 ) ) )

             {

                 return getBundleSymbolicName( artifact.getGroupId(), artifactId );

             }

             else

             {

                 return getBundleSymbolicName( artifact.getGroupId(), artifactId.substring( 1 ) );

             }

         }

         return getBundleSymbolicName( artifact.getGroupId(), artifact.getArtifactId() );

     }

     private String getGroupIdFromPackage( File artifactFile )

     {

         try

         {

             /* get package names from jar */

             Set packageNames = new HashSet();

             JarFile jar = new JarFile( artifactFile, false );

             Enumeration entries = jar.entries();

             while ( entries.hasMoreElements() )

             {

                 ZipEntry entry = (ZipEntry) entries.nextElement();

                 if ( entry.getName().endsWith( ".class" ) )

                 {

                     File f = new File( entry.getName() );

                     String packageName = f.getParent();

                     if ( packageName != null )

                     {

                         packageNames.add( packageName );

                     }

                 }

             }

             /* find the top package */

             String[] groupIdSections = null;

             for ( Iterator it = packageNames.iterator(); it.hasNext(); )

             {

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

                 String[] packageNameSections = packageName.split( "\\" + FILE_SEPARATOR );

                 if ( groupIdSections == null )

                 {

                     /* first candidate */

                     groupIdSections = packageNameSections;

                 }

                 else

                 // if ( packageNameSections.length < groupIdSections.length )

                 {

                     /*

                      * find the common portion of current package and previous selected groupId

                      */

                     int i;

                     for ( i = 0; ( i < packageNameSections.length ) && ( i < groupIdSections.length ); i++ )

                     {

                         if ( !packageNameSections[i].equals( groupIdSections[i] ) )

                         {

                             break;

                         }

                     }

                     groupIdSections = new String[i];

                     System.arraycopy( packageNameSections, 0, groupIdSections, 0, i );

                 }

             }

             if ( ( groupIdSections == null ) || ( groupIdSections.length == 0 ) )

             {

                 return null;

             }

             /* only one section as id doesn't seem enough, so ignore it */

             if ( groupIdSections.length == 1 )

             {

                 return null;

             }

             StringBuffer sb = new StringBuffer();

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

             {

                 sb.append( groupIdSections[i] );

                 if ( i < groupIdSections.length - 1 )

                 {

                     sb.append( '.' );

                 }

             }

             return sb.toString();

         }

         catch ( IOException e )

         {

             /* we took all the precautions to avoid this */

             throw new RuntimeException( e );

         }

     }

     public String getBundleFileName( Artifact artifact )

     {

         return getBundleSymbolicName( artifact ) + "_" + getVersion( artifact.getVersion() ) + ".jar";

     }

     public String getVersion( Artifact artifact )

     {

         return getVersion( artifact.getVersion() );

     }

     public String getVersion( String version )

     {

         String osgiVersion;

         // Matcher m = P_VERSION.matcher(version);

         // if (m.matches()) {

         // osgiVersion = m.group(1) + "." + m.group(3);

         // }

         /* TODO need a regexp guru here */

         Matcher m;

         /* if it's already OSGi compliant don't touch it */

         m = OSGI_VERSION_PATTERN.matcher( version );

         if ( m.matches() )

         {

             return version;

         }

         osgiVersion = version;

         /* check for dated snapshot versions with only major or major and minor */

         Pattern DATED_SNAPSHOT = Pattern.compile( "([0-9])(\\.([0-9]))?(\\.([0-9]))?\\-([0-9]{8}\\.[0-9]{6}\\-[0-9]*)" );

         m = DATED_SNAPSHOT.matcher( osgiVersion );

         if ( m.matches() )

         {

             String major = m.group( 1 );

             String minor = ( m.group( 3 ) != null ) ? m.group( 3 ) : "0";

             String service = ( m.group( 5 ) != null ) ? m.group( 5 ) : "0";

             String qualifier = m.group( 6 ).replaceAll( "-", "_" ).replaceAll( "\\.", "_" );

             osgiVersion = major + "." + minor + "." + service + "." + qualifier;

         }

         /* else transform first - to . and others to _ */

         osgiVersion = osgiVersion.replaceFirst( "-", "\\." );

         osgiVersion = osgiVersion.replaceAll( "-", "_" );

         m = OSGI_VERSION_PATTERN.matcher( osgiVersion );

         if ( m.matches() )

         {

             return osgiVersion;

         }

         /* remove dots in the middle of the qualifier */

         Pattern DOTS_IN_QUALIFIER = Pattern.compile( "([0-9])(\\.[0-9])?\\.([0-9A-Za-z_-]+)\\.([0-9A-Za-z_-]+)" );

         m = DOTS_IN_QUALIFIER.matcher( osgiVersion );

         if ( m.matches() )

         {

             String s1 = m.group( 1 );

             String s2 = m.group( 2 );

             String s3 = m.group( 3 );

             String s4 = m.group( 4 );

             Matcher qualifierMatcher = ONLY_NUMBERS.matcher( s3 );

             /*

              * if last portion before dot is only numbers then it's not in the middle of the

              * qualifier

              */

             if ( !qualifierMatcher.matches() )

             {

                 osgiVersion = s1 + s2 + "." + s3 + "_" + s4;

             }

         }

         /* convert

          * 1.string   -> 1.0.0.string

          * 1.2.string -> 1.2.0.string

          * 1          -> 1.0.0

          * 1.1        -> 1.1.0

          */

         //Pattern NEED_TO_FILL_ZEROS = Pattern.compile( "([0-9])(\\.([0-9]))?\\.([0-9A-Za-z_-]+)" );

         Pattern NEED_TO_FILL_ZEROS = Pattern.compile( "([0-9])(\\.([0-9]))?(\\.([0-9A-Za-z_-]+))?" );

         m = NEED_TO_FILL_ZEROS.matcher( osgiVersion );

         if ( m.matches() )

         {

             String major = m.group( 1 );

             String minor = m.group( 3 );

             String service = null;

             String qualifier = m.group( 5 );

             /* if there's no qualifier just fill with 0s */

             if ( qualifier == null )

             {

                 osgiVersion = getVersion( major, minor, service, qualifier );

             }

             else

             {

                 /* if last portion is only numbers then it's not a qualifier */

                 Matcher qualifierMatcher = ONLY_NUMBERS.matcher( qualifier );

                 if ( qualifierMatcher.matches() )

                 {

                     if ( minor == null )

                     {

                         minor = qualifier;

                     }

                     else

                     {

                         service = qualifier;

                     }

                     osgiVersion = getVersion( major, minor, service, null );

                 }

                 else

                 {

                     osgiVersion = getVersion( major, minor, service, qualifier );

                 }

             }

         }

         m = OSGI_VERSION_PATTERN.matcher( osgiVersion );

         /* if still its not OSGi version then add everything as qualifier */

         if ( !m.matches() )

         {

             String major = "0";

             String minor = "0";

             String service = "0";

             String qualifier = osgiVersion.replaceAll( "\\.", "_" );

             osgiVersion = major + "." + minor + "." + service + "." + qualifier;

         }

         return osgiVersion;

     }

     private String getVersion( String major, String minor, String service, String qualifier )

     {

         StringBuffer sb = new StringBuffer();

         sb.append( major != null ? major : "0" );

         sb.append( '.' );

         sb.append( minor != null ? minor : "0" );

         sb.append( '.' );

         sb.append( service != null ? service : "0" );

         if ( qualifier != null )

         {

             sb.append( '.' );

             sb.append( qualifier );

         }

         return sb.toString();

     }

 }