package org.codehaus.plexus.classworlds.launcher;
   
   /*
    * Copyright 2001-2006 Codehaus 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.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.codehaus.plexus.classworlds.ClassWorld;
  import org.codehaus.plexus.classworlds.realm.ClassRealm;
  import org.codehaus.plexus.classworlds.realm.DuplicateRealmException;
  import org.codehaus.plexus.classworlds.realm.NoSuchRealmException;
  
  /**
   * <code>Launcher</code> configurator.
   *
   * @author <a href="mailto:bob@eng.werken.com">bob mcwhirter</a>
   * @author Jason van Zyl
   */
  public class Configurator implements ConfigurationHandler
  {
      /**
       * The launcher to configure.
       */
      private Launcher launcher;
  
      private ClassWorld world;
  
      /**
       * Processed Realms.
       */
      private Map<String, ClassRealm> configuredRealms;
  
      /**
       * Current Realm.
       */
      private ClassRealm curRealm;
  
      private ClassLoader foreignClassLoader = null;
      
      /**
       * Construct.
       *
       * @param launcher The launcher to configure.
       */
      public Configurator( Launcher launcher )
      {
          this.launcher = launcher;
  
          configuredRealms = new HashMap<String, ClassRealm>();
  
          if ( launcher != null )
          {
              this.foreignClassLoader = launcher.getSystemClassLoader();
          }
      }
  
      /**
       * Construct.
       *
       * @param world The classWorld to configure.
       */
      public Configurator( ClassWorld world )
      {
          setClassWorld( world );
      }
  
      /**
       * set world.
       * this setter is provided so you can use the same configurator to configure several "worlds"
       *
       * @param world The classWorld to configure.
       */
      public void setClassWorld( ClassWorld world )
      {
          this.world = world;
  
         configuredRealms = new HashMap<String, ClassRealm>();
     }
 
     /**
      * Configure from a file.
      *
      * @param is The config input stream
      * @throws IOException             If an error occurs reading the config file.
      * @throws MalformedURLException   If the config file contains invalid URLs.
      * @throws ConfigurationException  If the config file is corrupt.
      * @throws org.codehaus.plexus.classworlds.realm.DuplicateRealmException If the config file defines two realms with the same id.
      * @throws org.codehaus.plexus.classworlds.realm.NoSuchRealmException    If the config file defines a main entry point in
      *                                 a non-existent realm.
      */
     public void configure( InputStream is )
         throws IOException, ConfigurationException, DuplicateRealmException, NoSuchRealmException
     {
         if ( world == null )
         {
             world = new ClassWorld();
         }
 
         curRealm = null;
 
         foreignClassLoader = null;
 
         if ( this.launcher != null )
         {
             foreignClassLoader = this.launcher.getSystemClassLoader();
         }
 
         ConfigurationParser parser = new ConfigurationParser( this, System.getProperties() );
 
         parser.parse( is );
 
         // Associate child realms to their parents.
         associateRealms();
 
         if ( this.launcher != null )
         {
             this.launcher.setWorld( world );
         }
 
     }
 
     // TODO return this to protected when the legacy wrappers can be removed.
     /**
      * Associate parent realms with their children.
      */
     public void associateRealms()
     {
         List<String> sortRealmNames = new ArrayList<String>( configuredRealms.keySet() );
 
         // sort by name
         Comparator<String> comparator = new Comparator<String>()
         {
             public int compare( String g1,
                                 String g2 )
             {
                 return g1.compareTo( g2 );
             }
         };
 
         Collections.sort( sortRealmNames, comparator );
 
         // So now we have something like the following for defined
         // realms:
         //
         // root
         // root.maven
         // root.maven.plugin
         //
         // Now if the name of a realm is a superset of an existing realm
         // the we want to make child/parent associations.
 
         for ( String realmName : sortRealmNames )
         {
             int j = realmName.lastIndexOf( '.' );
 
             if ( j > 0 )
             {
                 String parentRealmName = realmName.substring( 0, j );
 
                 ClassRealm parentRealm = configuredRealms.get( parentRealmName );
 
                 if ( parentRealm != null )
                 {
                     ClassRealm realm = configuredRealms.get( realmName );
 
                     realm.setParentRealm( parentRealm );
                 }
             }
         }
     }
 
     public void addImportFrom( String relamName, String importSpec )
         throws NoSuchRealmException
     {
         curRealm.importFrom( relamName, importSpec );
     }
 
     public void addLoadFile( File file )
     {
         try
         {
             curRealm.addURL( file.toURI().toURL() );
         }
         catch ( MalformedURLException e )
         {
             // can't really happen... or can it?
         }
     }
 
     public void addLoadURL( URL url )
     {
         curRealm.addURL( url );
     }
 
     public void addRealm( String realmName )
         throws DuplicateRealmException
     {
         curRealm = world.newRealm( realmName, foreignClassLoader );
 
         // Stash the configured realm for subsequent association processing.
         configuredRealms.put( realmName, curRealm );
     }
 
     public void setAppMain( String mainClassName, String mainRealmName )
     {
         if ( this.launcher != null )
         {
             this.launcher.setAppMain( mainClassName, mainRealmName );
         }
     }
 }