package org.apache.maven.plugin.surefire.booterclient.lazytestprovider;
   
   /*
    * 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.
   */
  
  import org.apache.maven.surefire.api.booter.Command;
  import org.apache.maven.surefire.api.booter.Shutdown;
  
  import java.io.IOException;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  import java.util.Queue;
  import java.util.concurrent.ConcurrentLinkedQueue;
  import java.util.concurrent.Semaphore;
  import java.util.concurrent.atomic.AtomicBoolean;
  import java.util.concurrent.atomic.AtomicReference;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import static org.apache.maven.surefire.api.booter.Command.BYE_ACK;
  import static org.apache.maven.surefire.api.booter.Command.NOOP;
  import static org.apache.maven.surefire.api.booter.Command.SKIP_SINCE_NEXT_TEST;
  import static org.apache.maven.surefire.api.booter.Command.toShutdown;
  
  /**
   * Dispatches commands without tests.
   *
   * @author <a href="mailto:tibordigana@apache.org">Tibor Digana (tibor17)</a>
   * @since 2.19
   */
  public final class TestLessInputStream
          extends DefaultCommandReader
  {
      private final Semaphore barrier = new Semaphore( 0 );
  
      private final AtomicBoolean closed = new AtomicBoolean();
  
      private final Queue<Command> immediateCommands = new ConcurrentLinkedQueue<>();
  
      private final TestLessInputStreamBuilder builder;
  
      private Iterator<Command> cachableCommands;
  
      private TestLessInputStream( TestLessInputStreamBuilder builder )
      {
          this.builder = builder;
      }
  
      @Override
      public void provideNewTest()
      {
      }
  
      @Override
      public void skipSinceNextTest()
      {
          if ( canContinue() )
          {
              immediateCommands.add( SKIP_SINCE_NEXT_TEST );
              barrier.release();
          }
      }
  
      @Override
      public void shutdown( Shutdown shutdownType )
      {
          if ( canContinue() )
          {
              immediateCommands.add( toShutdown( shutdownType ) );
              barrier.release();
          }
      }
  
      @Override
      public void noop()
      {
          if ( canContinue() )
          {
              immediateCommands.add( NOOP );
              barrier.release();
          }
      }
  
     @Override
     public void acknowledgeByeEventReceived()
     {
         if ( canContinue() )
         {
             immediateCommands.add( BYE_ACK );
             barrier.release();
         }
     }
 
     @Override
     public boolean isClosed()
     {
         return closed.get();
     }
 
     @Override
     protected Command nextCommand()
     {
         Command cmd = immediateCommands.poll();
         if ( cmd == null )
         {
             if ( cachableCommands == null )
             {
                 cachableCommands = builder.getIterableCachable().iterator();
             }
 
             cmd = cachableCommands.next();
         }
         return cmd;
     }
 
     @Override
     protected void beforeNextCommand()
         throws IOException
     {
         awaitNextCommand();
     }
 
     @Override
     public void close()
     {
         if ( closed.compareAndSet( false, true ) )
         {
             barrier.drainPermits();
             barrier.release();
         }
     }
 
     /**
      * For testing purposes only.
      *
      * @return permits used internally by {@link #beforeNextCommand()}
      */
     int availablePermits()
     {
         return barrier.availablePermits();
     }
 
     private void awaitNextCommand()
         throws IOException
     {
         try
         {
             barrier.acquire();
         }
         catch ( InterruptedException e )
         {
             throw new IOException( e.getLocalizedMessage() );
         }
     }
 
     /**
      * Builds {@link TestLessInputStream streams}, registers cachable commands
      * and provides accessible API to dispatch immediate commands to all atomically
      * alive streams.
      */
     public static final class TestLessInputStreamBuilder
     {
         private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
         private final Queue<TestLessInputStream> aliveStreams = new ConcurrentLinkedQueue<>();
         private final ImmediateCommands immediateCommands = new ImmediateCommands();
         private final CachableCommands cachableCommands = new CachableCommands();
         private final Node head = new Node( null );
         private final Iterable<Command> iterableCachable;
 
         public TestLessInputStreamBuilder()
         {
             iterableCachable = new Iterable<Command>()
             {
                 @Override
                 public Iterator<Command> iterator()
                 {
                     return new CIt();
                 }
             };
         }
 
         public TestLessInputStream build()
         {
             Lock lock = rwLock.writeLock();
             lock.lock();
             try
             {
                 TestLessInputStream is = new TestLessInputStream( this );
                 aliveStreams.offer( is );
                 return is;
             }
             finally
             {
                 lock.unlock();
             }
         }
 
         public void removeStream( TestLessInputStream is )
         {
             Lock lock = rwLock.writeLock();
             lock.lock();
             try
             {
                 aliveStreams.remove( is );
             }
             finally
             {
                 lock.unlock();
             }
         }
 
         /**
          * Only {@link NotifiableTestStream#noop()} and {@link NotifiableTestStream#shutdown(Shutdown)} are supported.
          * Another methods throw {@link UnsupportedOperationException}.
          *
          * @return commands which are immediately transmitted once to all alive forked JVMs, not cached. As opposite
          * to cached commands, the immediate commands disappear and cannot be seen by any fork initiated after
          * the command has dispatched.
          */
         public NotifiableTestStream getImmediateCommands()
         {
             return immediateCommands;
         }
 
         /**
          * Cached commands are sent to all alive or future alive forks. These are termination commands which are not
          * reversible and therefore only {@link NotifiableTestStream#shutdown(Shutdown)} and
          * {@link NotifiableTestStream#skipSinceNextTest()} are supported.
          * Another methods throw {@link UnsupportedOperationException}.
          *
          * @return commands which are cached for currently alive or future forks.
          */
         public NotifiableTestStream getCachableCommands()
         {
             return cachableCommands;
         }
 
         /**
          * The iterator is not thread safe.
          */
         Iterable<Command> getIterableCachable()
         {
             return iterableCachable;
         }
 
         @SuppressWarnings( "checkstyle:innerassignment" )
         private boolean addTailNodeIfAbsent( Command command )
         {
             Node newTail = new Node( command );
             Node currentTail = head;
             do
             {
                 for ( Node successor; ( successor = currentTail.next.get() ) != null; )
                 {
                     currentTail = successor;
                     if ( command.equals( currentTail.command ) )
                     {
                         return false;
                     }
                 }
             } while ( !currentTail.next.compareAndSet( null, newTail ) );
             return true;
         }
 
         private static Node nextCachedNode( Node current )
         {
             return current.next.get();
         }
 
         private final class CIt
             implements Iterator<Command>
         {
             private Node node = TestLessInputStreamBuilder.this.head;
 
             @Override
             public boolean hasNext()
             {
                 return examineNext( false ) != null;
             }
 
             @Override
             public Command next()
             {
                 Command command = examineNext( true );
                 if ( command == null )
                 {
                     throw new NoSuchElementException();
                 }
                 return command;
             }
 
             @Override
             public void remove()
             {
                 throw new UnsupportedOperationException();
             }
 
             private Command examineNext( boolean store )
             {
                 Node next = nextCachedNode( node );
                 if ( store && next != null )
                 {
                     node = next;
                 }
                 return next == null ? null : next.command;
             }
         }
 
         /**
          * Event is called just now for all alive streams and command is not persisted.
          */
         private final class ImmediateCommands
             implements NotifiableTestStream
         {
             @Override
             public void provideNewTest()
             {
                 throw new UnsupportedOperationException();
             }
 
             @Override
             public void skipSinceNextTest()
             {
                 throw new UnsupportedOperationException();
             }
 
             @Override
             public void shutdown( Shutdown shutdownType )
             {
                 Lock lock = rwLock.readLock();
                 lock.lock();
                 try
                 {
                     for ( TestLessInputStream aliveStream : TestLessInputStreamBuilder.this.aliveStreams )
                     {
                         aliveStream.shutdown( shutdownType );
                     }
                 }
                 finally
                 {
                     lock.unlock();
                 }
             }
 
             @Override
             public void noop()
             {
                 Lock lock = rwLock.readLock();
                 lock.lock();
                 try
                 {
                     for ( TestLessInputStream aliveStream : TestLessInputStreamBuilder.this.aliveStreams )
                     {
                         aliveStream.noop();
                     }
                 }
                 finally
                 {
                     lock.unlock();
                 }
             }
 
             @Override
             public void acknowledgeByeEventReceived()
             {
                 throw new UnsupportedOperationException();
             }
         }
 
         /**
          * Event is persisted.
          */
         private final class CachableCommands
             implements NotifiableTestStream
         {
             @Override
             public void provideNewTest()
             {
                 throw new UnsupportedOperationException();
             }
 
             @Override
             public void skipSinceNextTest()
             {
                 Lock lock = rwLock.readLock();
                 lock.lock();
                 try
                 {
                     if ( TestLessInputStreamBuilder.this.addTailNodeIfAbsent( SKIP_SINCE_NEXT_TEST ) )
                     {
                         release();
                     }
                 }
                 finally
                 {
                     lock.unlock();
                 }
             }
 
             @Override
             public void shutdown( Shutdown shutdownType )
             {
                 Lock lock = rwLock.readLock();
                 lock.lock();
                 try
                 {
                     if ( TestLessInputStreamBuilder.this.addTailNodeIfAbsent( toShutdown( shutdownType ) ) )
                     {
                         release();
                     }
                 }
                 finally
                 {
                     lock.unlock();
                 }
             }
 
             @Override
             public void noop()
             {
                 throw new UnsupportedOperationException();
             }
 
             @Override
             public void acknowledgeByeEventReceived()
             {
                 throw new UnsupportedOperationException();
             }
 
             private void release()
             {
                 for ( TestLessInputStream aliveStream : TestLessInputStreamBuilder.this.aliveStreams )
                 {
                     aliveStream.barrier.release();
                 }
             }
         }
 
         private static class Node
         {
             private final AtomicReference<Node> next = new AtomicReference<>();
             private final Command command;
 
             Node( Command command )
             {
                 this.command = command;
             }
         }
     }
 }