package org.codehaus.mojo.pde.descriptor;
   
   /*
    * Copyright 2006 The Apache Software Foundation.
    *
    * Licensed 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 java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.Reader;
  
  import org.apache.maven.plugin.MojoExecutionException;
  import org.codehaus.mojo.pde.descriptor.io.xpp3.FeatureXpp3Reader;
  import org.codehaus.mojo.pde.descriptor.io.xpp3.FragmentXpp3Reader;
  import org.codehaus.mojo.pde.descriptor.io.xpp3.PluginXpp3Reader;
  import org.codehaus.mojo.pde.descriptor.io.xpp3.ProductXpp3Reader;
  import org.codehaus.plexus.util.IOUtil;
  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  
  /**
   * 
   * 
   */
  public class DescriptorUtil
  {
  
      /**
       * Load the descriptor file for the pde project. This will either load the product descriptor
       * (based on the productFilename) or one of the eclipse artifacts in the following order:
       * feature ("feature.xml"), fragment ("fragment.xml"), plugin ("plugin.xml").
       * 
       * @param basedir the pde plugin base directory
       * @param productFilename optional, if specified then the eclipse product file that will be
       *            returned.
       * @return the descriptor for the pde project
       * @throws MojoExecutionException build failures.
       */
      public static Descriptor getDescriptor( File basedir, String productFilename )
          throws MojoExecutionException
      {
          Descriptor d = null;
  
          if ( productFilename != null )
          {
              d = loadProductDescriptor( basedir, productFilename );
          }
          else
          {
              d = loadFeatureDescriptor( basedir );
  
              if ( d == null )
              {
                  d = loadFragmentDescriptor( basedir );
              }
  
              if ( d == null )
              {
                  d = loadPluginDescriptor( basedir );
              }
          }
  
          if ( d == null )
          {
              throw new MojoExecutionException( basedir.getPath() + " is not a PDE project." );
          }
  
          return d;
      }
  
      /**
       * Load Feature from pde project directory.
       * 
       * @param basedir the pde project directory.
       * @return a Descriptor containing the Feature
       * @throws MojoExecutionException build failures.
       */
      private static Descriptor loadFeatureDescriptor( File basedir )
          throws MojoExecutionException
      {
          FeatureDescriptor descriptor = null;
  
          File file = new File( basedir, "feature.xml" );
  
          if ( file.exists() )
          {
              try
              {
                 descriptor = readFeatureDescriptor( new FileReader( file ) );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Error reading " + file );
             }
         }
 
         return descriptor;
 
     }
 
     /**
      * Load Fragment from pde project directory.
      * 
      * @param basedir the pde project directory.
      * @return a Descriptor containing the Fragment
      * @throws MojoExecutionException build failures.
      */
     private static Descriptor loadFragmentDescriptor( File basedir )
         throws MojoExecutionException
     {
         FeatureDescriptor descriptor = null;
 
         File file = new File( basedir, "fragment.xml" );
         if ( file.exists() )
         {
             try
             {
                 descriptor = readFeatureDescriptor( new FileReader( file ) );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Error reading " + file );
             }
         }
 
         return descriptor;
 
     }
 
     /**
      * Load Plugin from pde project directory.
      * 
      * @param basedir the pde project directory.
      * @return a Descriptor containing the Plugin
      * @throws MojoExecutionException build failures.
      */
     private static Descriptor loadPluginDescriptor( File basedir )
         throws MojoExecutionException
     {
         PluginDescriptor d = null;
 
         File file = new File( basedir, "plugin.xml" );
         if ( file.exists() )
         {
             try
             {
                 d = readPluginDescriptor( new FileReader( file ) );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Error reading " + file );
             }
         }
         else
         {
             d = new PluginDescriptor();
         }
 
         if ( d.getId() == null || d.getVersion() == null )
         {
             ManifestBean bean = new ManifestBean( basedir );
             if ( d.getId() == null )
             {
                 d.setId( bean.getId() );
             }
 
             if ( d.getVersion() == null )
             {
                 d.setVersion( bean.getVersion() );
             }
         }
 
         return d;
 
     }
 
     /**
      * Load Product from pde project directory.
      * 
      * @param basedir the pde project directory.
      * @param productFilename the file name for the *.product file for the project.
      * @return a Descriptor containing the Product
      * @throws MojoExecutionException build failures.
      */
     private static Descriptor loadProductDescriptor( File basedir, String productFilename )
         throws MojoExecutionException
     {
         ProductDescriptor d = null;
 
         File file = new File( basedir, productFilename );
         if ( file.exists() )
         {
             try
             {
                 d = readProductDescriptor( new FileReader( file ) );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Error reading " + file );
             }
         }
 
         return d;
     }
 
     /**
      * Load the plugin.xml via a Reader
      * 
      * @param reader plugin file
      * @throws MojoExecutionException build failures.
      * @return PluginDescriptor
      */
     public static PluginDescriptor readPluginDescriptor( Reader reader )
         throws MojoExecutionException
     {
         PluginDescriptor descriptor;
         try
         {
             PluginXpp3Reader r = new PluginXpp3Reader();
 
             descriptor = r.read( reader, false );
 
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "Error reading plugin.xml descriptor", e );
         }
         catch ( XmlPullParserException e )
         {
             throw new MojoExecutionException( "Error reading plugin.xml descriptor", e );
         }
         finally
         {
             IOUtil.close( reader );
         }
 
         return descriptor;
     }
 
     /**
      * Load the feature.xml via a Reader
      * 
      * @param reader the feature file
      * @return FeatureDescriptor
      * @throws MojoExecutionException build failures.
      */
     public static FeatureDescriptor readFeatureDescriptor( Reader reader )
         throws MojoExecutionException
     {
         FeatureDescriptor descriptor;
         try
         {
             FeatureXpp3Reader r = new FeatureXpp3Reader();
             descriptor = r.read( reader, false );
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "Error reading feature.xml descriptor", e );
         }
         catch ( XmlPullParserException e )
         {
             throw new MojoExecutionException( "Error reading feature.xml descriptor", e );
         }
         finally
         {
             IOUtil.close( reader );
         }
 
         return descriptor;
     }
 
     /**
      * Load the fragment.xml via a Reader
      * 
      * @param reader the fragment file
      * @return FragmentDescriptor
      * @throws MojoExecutionException build failures.
      */
     public static FragmentDescriptor readFragmentDescriptor( Reader reader )
         throws MojoExecutionException
     {
         FragmentDescriptor descriptor;
         try
         {
             FragmentXpp3Reader r = new FragmentXpp3Reader();
             descriptor = r.read( reader, false );
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "Error reading fragment.xml descriptor", e );
         }
         catch ( XmlPullParserException e )
         {
             throw new MojoExecutionException( "Error reading fragment.xml descriptor", e );
         }
         finally
         {
             IOUtil.close( reader );
         }
 
         return descriptor;
     }
 
     /**
      * Load the *.product via a Reader
      * 
      * @param reader the product file
      * @return ProductDescriptor
      * @throws MojoExecutionException build failures.
      */
     public static ProductDescriptor readProductDescriptor( Reader reader )
         throws MojoExecutionException
     {
         ProductDescriptor descriptor;
         try
         {
             ProductXpp3Reader r = new ProductXpp3Reader();
             descriptor = r.read( reader, false );
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "Error reading *.product descriptor", e );
         }
         catch ( XmlPullParserException e )
         {
             throw new MojoExecutionException( "Error reading *.product descriptor", e );
         }
         finally
         {
             IOUtil.close( reader );
         }
 
         return descriptor;
     }
 
     /**
      * Return the String version of the pdetype based on the descriptor.
      * 
      * @param descriptor the project descriptor
      * @return product, plugin, feature, or fragment based upon the descriptor.
      */
     public static String getPDEType( Descriptor descriptor )
     {
         if ( descriptor instanceof ProductDescriptor )
         {
             return "product";
         }
         if ( descriptor instanceof PluginDescriptor )
         {
             return "plugin";
         }
         if ( descriptor instanceof FeatureDescriptor )
         {
             return "feature";
         }
         if ( descriptor instanceof FragmentDescriptor )
         {
             return "fragment";
         }
 
         return null;
     }
 
 }