/*
    * 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.
   */
  package org.apache.commons.rng.examples.stress;
  
  import org.apache.commons.rng.UniformRandomProvider;
  import org.apache.commons.rng.core.source32.IntProvider;
  
  import picocli.CommandLine.Command;
  import picocli.CommandLine.Mixin;
  import picocli.CommandLine.Option;
  import picocli.CommandLine.Parameters;
  
  import java.io.BufferedWriter;
  import java.io.File;
  import java.io.IOException;
  import java.io.Writer;
  import java.nio.ByteOrder;
  import java.nio.IntBuffer;
  import java.nio.file.Files;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.Callable;
  import java.util.concurrent.ThreadLocalRandom;
  
  /**
   * Specification for the "bridge" command.
   *
   * <p>This command tests that {@code int} values can be piped to a
   * program that reads {@code int} values from its standard input. Only
   * a limited number of {@code int} values will be written.</p>
   */
  @Command(name = "bridge",
           description = {"Transfer test 32-bit data to a test application sub-process via standard input."})
  class BridgeTestCommand implements Callable<Void> {
      /** The standard options. */
      @Mixin
      private StandardOptions reusableOptions;
  
      /** The executable. */
      @Parameters(index = "0",
                  description = "The stress test executable.")
      private File executable;
  
      /** The executable arguments. */
      @Parameters(index = "1..*",
                  description = "The arguments to pass to the executable.",
                  paramLabel = "<argument>")
      private List<String> executableArguments = new ArrayList<>();
  
      /** The file output prefix. */
      @Option(names = {"--prefix"},
              description = "Results file prefix (default: ${DEFAULT-VALUE}).")
      private File fileOutputPrefix = new File("bridge");
  
      /** The output byte order of the binary data. */
      @Option(names = {"-b", "--byte-order"},
              description = {"Byte-order of the transferred data (default: ${DEFAULT-VALUE}).",
                             "Valid values: BIG_ENDIAN, LITTLE_ENDIAN."})
      private ByteOrder byteOrder = ByteOrder.nativeOrder();
  
      /**
       * Validates the run command arguments and and runs the bridge test.
       */
      @Override
      public Void call() {
          LogUtils.setLogLevel(reusableOptions.logLevel);
          ProcessUtils.checkExecutable(executable);
          ProcessUtils.checkOutputDirectory(fileOutputPrefix);
          runBridgeTest();
          return null;
      }
  
      /**
       * Starts the executable process and writes {@code int} values to a data file and the stdin
       * of the executable. Captures stdout of the executable to a file.
       */
      private void runBridgeTest() {
          final List<String> command = ProcessUtils.buildSubProcessCommand(executable, executableArguments);
  
          try {
              final File dataFile = new File(fileOutputPrefix + ".data");
              final File outputFile = new File(fileOutputPrefix + ".out");
              final File errorFile = new File(fileOutputPrefix + ".err");
  
              // Store int values
             final IntBuffer buffer = IntBuffer.allocate(Integer.SIZE * 2);
 
             try (BufferedWriter textOutput = Files.newBufferedWriter(dataFile.toPath())) {
                 // Write int data using a single bit in all possible positions
                 int value = 1;
                 for (int i = 0; i < Integer.SIZE; i++) {
                     writeInt(textOutput, buffer, value);
                     value <<= 1;
                 }
 
                 // Write random int data
                 while (buffer.remaining() != 0) {
                     writeInt(textOutput, buffer, ThreadLocalRandom.current().nextInt());
                 }
             }
 
             // Pass the same values to the output application
             buffer.flip();
             final UniformRandomProvider rng = new IntProvider() {
                 @Override
                 public int next() {
                     return buffer.get();
                 }
             };
 
             // Start the application.
             final ProcessBuilder builder = new ProcessBuilder(command);
             builder.redirectOutput(ProcessBuilder.Redirect.to(outputFile));
             builder.redirectError(ProcessBuilder.Redirect.to(errorFile));
             final Process testingProcess = builder.start();
 
             // Open the stdin of the process and write to a custom data sink.
             // Note: The 'bridge' command only supports 32-bit data in order to
             // demonstrate passing suitable data for TestU01 BigCrush.
             final Source64Mode source64 = null;
             try (RngDataOutput sink = RNGUtils.createDataOutput(rng, source64,
                     testingProcess.getOutputStream(), buffer.capacity() * 4, byteOrder)) {
                 sink.write(rng);
             }
 
             final Integer exitValue = ProcessUtils.getExitValue(testingProcess);
             if (exitValue == null) {
                 LogUtils.error("%s did not exit. Process was killed.", command.get(0));
             } else {
                 final int value = exitValue;
                 if (value != 0) {
                     LogUtils.error("%s exit code = %d", command.get(0), value);
                 }
             }
 
         } catch (IOException ex) {
             throw new ApplicationException("Failed to run process: " + ex.getMessage(), ex);
         }
     }
 
     /**
      * Write an {@code int} value to the writer and the buffer output. The native Java
      * value will be written to the writer using the debugging output of the
      * {@link OutputCommand}.
      *
      * @param textOutput the text data writer.
      * @param buffer the buffer.
      * @param value the value.
      * @throws IOException Signals that an I/O exception has occurred.
      * @see OutputCommand#writeInt(java.io.Writer, int)
      */
     private static void writeInt(Writer textOutput,
                                  IntBuffer buffer,
                                  int value) throws IOException {
         OutputCommand.writeInt(textOutput, value);
         buffer.put(value);
     }
 }