package net.sf.logdistiller;
   
   /*
    * 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.IOException;
  import java.text.ParseException;
  import java.util.*;
  
  /**
   * Combines logevents fetched from multiple factories. The resulting factory chooses the next logevent according to the
   * order provided.
   */
  public class FactoryMultiplexer
      extends LogEvent.Factory
  {
      private final Comparator<LogEvent> logeventComparator;
  
      private final List<Entry> factories = new ArrayList<Entry>();
  
      private boolean initialized = false;
  
      private Comparator<Entry> entryComparator;
  
      public FactoryMultiplexer( LogType.Description description )
      {
          this( description, null );
      }
  
      public FactoryMultiplexer( LogType.Description description, Comparator<LogEvent> logeventComparator )
      {
          super( description, "multiplexer" );
          this.logeventComparator = logeventComparator;
      }
  
      public void addFactory( LogEvent.Factory factory )
      {
          if ( initialized )
          {
              throw new IllegalStateException( "cannot add a new LogEvent.Factory after reading first event" );
          }
          if ( description != factory.getDescription() )
          {
              throw new IllegalArgumentException( "cannot add a new LogEvent.Factory with different description" );
          }
          factories.add( new Entry( factory ) );
      }
  
      protected LogEvent readNextEvent()
          throws IOException, ParseException
      {
          if ( !initialized )
          {
              init();
          }
          if ( factories.size() <= 0 )
          {
              return null;
          }
          Entry entry = factories.get( 0 );
          LogEvent nextEvent = entry.getEvent();
          if ( entry.nextEvent() == null )
          {
              factories.remove( 0 );
          }
          else
          {
              sort();
          }
          return nextEvent;
      }
  
      /**
       * Initialize the multiplexer: fetch first event in each factory, remove empty factories, init entry comparator and
       * sort the factories.
       *
       * @throws IOException
       * @throws ParseException
       */
      private void init()
          throws IOException, ParseException
      {
          initialized = true;
          LogEvent oneEvent = null;
          // fetch the first LogEvent
          List<Entry> emptyFactories = new ArrayList<Entry>();
          for ( Entry entry : factories )
          {
             LogEvent event = entry.nextEvent();
             if ( event == null )
             {
                 emptyFactories.add( entry );
             }
             else
             {
                 oneEvent = event;
             }
         }
         // remove empty factories
         factories.removeAll( emptyFactories );
         if ( factories.size() >= 0 )
         {
             // init entry comparator
             if ( logeventComparator != null )
             {
                 entryComparator = new EntrySpecificComparator( logeventComparator );
             }
             else if ( oneEvent instanceof Comparable<?> )
             {
                 entryComparator = new EntryNaturalComparator();
             }
             // sort the factories
             sort();
         }
     }
 
     /**
      * Sort the factories, if necessary (a logevent comparator has been provided, or logevent implements Comparable).
      */
     private void sort()
     {
         if ( entryComparator != null )
         {
             Collections.sort( factories, entryComparator );
         }
     }
 
     private static class Entry
     {
         protected LogEvent nextEvent;
 
         private final LogEvent.Factory factory;
 
         public Entry( LogEvent.Factory factory )
         {
             this.factory = factory;
         }
 
         public LogEvent getEvent()
         {
             return nextEvent;
         }
 
         public LogEvent nextEvent()
             throws IOException, ParseException
         {
             nextEvent = factory.nextEvent();
             return nextEvent;
         }
     }
 
     /**
      * Comparator for entries with logevents that implement Comparable.
      */
     private static class EntryNaturalComparator
         implements Comparator<Entry>
     {
         public int compare( Entry entry1, Entry entry2 )
         {
             return ( (Comparable) entry1.getEvent() ).compareTo( entry2.getEvent() );
         }
     }
 
     /**
      * Comparator for entries when a specific logevent Comparator is provided.
      */
     private static class EntrySpecificComparator
         implements Comparator<Entry>
     {
         private final Comparator<LogEvent> eventComparator;
 
         public EntrySpecificComparator( Comparator<LogEvent> eventComparator )
         {
             this.eventComparator = eventComparator;
         }
 
         public int compare( Entry entry1, Entry entry2 )
         {
             return eventComparator.compare( entry1.getEvent(), entry2.getEvent() );
         }
     }
 }