package net.sourceforge.basher.internal.impl;
   
   import java.util.*;
   import java.util.concurrent.CountDownLatch;
   import java.beans.XMLDecoder;
   import java.io.ByteArrayInputStream;
   
   import net.sourceforge.basher.*;
   import net.sourceforge.basher.events.*;
  import net.sourceforge.basher.impl.TaskContribution;
  import net.sourceforge.basher.internal.TaskCreator;
  import org.apache.commons.logging.LogFactory;
  import org.ops4j.gaderian.Registry;
  import org.ops4j.gaderian.impl.*;
  
  /**
   * @author Johan Lindquist
   * @version $Revision$
   */
  public class BasherBootHelper implements BasherEventListener
  {
      private Registry _registry;
      private CountDownLatch countDownLatch = new CountDownLatch( 1 );
      private boolean _manuallyControlled = false;
  
      public int run( final Properties properties ) throws Exception
      {
          // Extract the active basher context
          final String activeBasherContext = properties.getProperty( "activeBasherContext", "default" );
  
          // Construct the registry
          final RegistryBuilder registryBuilder = new RegistryBuilder( new StrictErrorHandler() );
          registryBuilder.addDefaultModuleDescriptorProvider();
  
          _registry = registryBuilder.constructRegistry( Locale.getDefault() );
  
          // Handle initialisation of Basher contexts provided from the plug-ins
          // This will also ensure that the selected contexts reporting directory
          // is correctly setup with the directory specified by the plug-ins
          final BasherContext basherContext = initializeBasherContexts( activeBasherContext, properties );
  
          // Lookup the event manager and register for events
          EventManager eventManager = ( EventManager ) _registry.getService( EventManager.class );
          eventManager.addBasherEventListener( this );
  
          // Retrieve tasks added as part of the source tree
          final List<Class> includedClasses = initializeIncludedClasses( properties );
  
          if ( includedClasses != null && !includedClasses.isEmpty() )
          {
              // There are classes added - register them with the task manager
              final TaskCreator taskCreator = ( TaskCreator ) _registry.getService( TaskCreator.class );
              final TaskManager taskManager = ( TaskManager ) _registry.getService( TaskManager.class );
  
              for ( Class includedClass : includedClasses )
              {
                  // FIXME: do not just yet yse this!!!
                  // taskManager.addTask( includedClass );
              }
          }
  
          //
          _manuallyControlled = basherContext.isManuallyControlled();
  
          if ( !_manuallyControlled )
          {
              // Find the scheduler and start the run
              final Scheduler scheduler = ( Scheduler ) _registry.getService( Scheduler.class );
              scheduler.start( activeBasherContext );
          }
  
          // Now, wait for the complete call back
          try
          {
              countDownLatch.await();
          }
          catch ( InterruptedException e )
          {
              e.printStackTrace();
          }
  
          // Ok, we have now received an end event - it is safe to shutdown the registry and exit
  
          // For safety, we sleep for just a bit
          try
          {
              Thread.sleep( 3000 );
          }
          catch ( InterruptedException e )
          {
              e.printStackTrace();
          }
  
          // FIXME: This should process the results to check whether
          // FIXME: - any tasks failed
          // FIXME: - any tasks ran for too long
          int resultCode = 0;
  
  
 
         try
         {
             _registry.shutdown();
         }
         catch ( Exception e )
         {
             e.printStackTrace();
         }
         finally
         {
             return resultCode;
         }
 
 
     }
 
     private List<Class> initializeIncludedClasses( final Properties properties ) throws ClassNotFoundException
     {
         List<Class> includedFiles = new ArrayList<Class>();
         for ( Object key : properties.keySet() )
         {
             String name = ( String ) key;
 
             if ( name.startsWith( "includedFile." ) )
             {
                 final String className = makeClassName( properties.getProperty( name ) );
                 includedFiles.add( Thread.currentThread().getContextClassLoader().loadClass( className ) );
             }
         }
 
         return includedFiles;
     }
 
     private String makeClassName( final String sourceName )
     {
         String sourceClassName = sourceName.substring( 0, sourceName.length() - ".java".length() );
         sourceClassName = sourceClassName.replaceAll( "/", "." );
         sourceClassName = sourceClassName.replaceAll( "\\\\", "." );
         return sourceClassName;
     }
 
     private BasherContext initializeBasherContexts( final String activeBasherContext, final Properties properties )
     {
         // First deserialize the basher contexts provided to use from plugins
         final List<BasherContext> basherContexts = deserializeBasherContexts( properties );
 
         // Find the context manager and add all provided contexts
         final ContextManager contextManager = ( ContextManager ) _registry.getService( ContextManager.class );
         for ( final BasherContext basherContext : basherContexts )
         {
             contextManager.addBasherContext( basherContext );
         }
 
         final BasherContext context = contextManager.getBasherContext( activeBasherContext );
         setupReportsDirectory( context, properties );
         return context;
     }
 
     private void setupReportsDirectory( final BasherContext basherContext, Properties properties )
     {
         basherContext.setReportDirectory( properties.getProperty( "reportingDirectory", "target/basher-reports" ) );
     }
 
     private List<BasherContext> deserializeBasherContexts( final Properties properties )
     {
         List<BasherContext> basherContexts = new ArrayList<BasherContext>();
         for ( Object o : properties.keySet() )
         {
             String key = ( String ) o;
             if ( key.startsWith( "basherContext." ) )
             {
                 XMLDecoder xmlDecoder = new XMLDecoder( new ByteArrayInputStream( properties.getProperty( key ).getBytes() ) );
                 final BasherContext basherContext = ( BasherContext ) xmlDecoder.readObject();
                 basherContexts.add( basherContext );
             }
         }
 
         return basherContexts;
 
     }
 
     public void basherEvent( final BasherEvent basherEvent )
     {
         if ( basherEvent instanceof PhaseTransitionEvent )
         {
             if ( !_manuallyControlled )
             {
                 if ( ( ( PhaseTransitionEvent ) basherEvent ).getNewPhase() == Phase.END )
                 {
                     countDownLatch.countDown();
                 }
             }
         }
         else if ( basherEvent instanceof BasherShutdownEvent )
         {
             if ( _manuallyControlled )
             {
                 countDownLatch.countDown();
             }
         }
 //        else if (basherEvent instanceof AverageCollectedEvent )
 //        {
 //            Average average = ((AverageCollectedEvent)basherEvent).getAverage();
 //            // FIXME: Collect the averages for later check
 //        }
     }
 }