/*
    * Copyright (C) 2006  Tom Gibara
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
    * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   */
  package com.tomgibara.pronto.control.impl;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.ScheduledFuture;
  import java.util.concurrent.TimeUnit;
  import java.util.logging.Level;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import com.tomgibara.pronto.control.StdinControllerSettings;
  import com.tomgibara.pronto.core.Pronto;
  import com.tomgibara.pronto.core.impl.StaticProperties;
  import com.tomgibara.pronto.state.ProntoStateException;
  import com.tomgibara.pronto.util.Duration;
  import com.tomgibara.pronto.util.Waiter;
  
  /**
   * A ControllerPart implementation that provides functionality for the
   * StdinControllerSettings interface.
   * 
   * @param <S>
   *            the type of state
   * @param <L>
   *            the type of label
   * @param <P>
   *            the type of parameter
   * 
   * @author Tom Gibara
   * 
   */
  
  public class StdinControllerPart<S, L, P> implements ControllerPart<S, L, P> {
  
      // statics
  
      private static int extractLine(final byte[] bytes, final int bytesRead, final List<String> lines) {
          int i;
          for (i = 0; i < bytesRead; i++) {
              byte b = bytes[i];
              if (b == '\n' || b == '\r') break;
          }
          final int bytesLeft;
          if (i == bytes.length || i < bytesRead) {
              String line = new String(bytes, 0, i);
              lines.add(line);
              if (i == bytes.length) {
                  bytesLeft = 0;
              } else {
                  bytesLeft = bytesRead - i - 1;
                  if (bytesLeft > 0) {
                      System.arraycopy(bytes, i + 1, bytes, 0, bytesLeft);
                  }
              }
          } else {
              bytesLeft = bytesRead;
          }
          return bytesLeft;
      }
  
      // package scoped for testing
      static int extractLines(final byte[] bytes, final int bytesRead, final List<String> lines) {
          int bytesLeft = bytesRead;
          while (true) {
              if (bytesLeft == 0) break;
              int tmp = extractLine(bytes, bytesLeft, lines);
              if (tmp == bytesLeft) break;
              bytesLeft = tmp;
          }
          return bytesLeft;
      }
  
      /**
       * The greatest number of characters that will be read as a single line of
       * input.
       */
      private static final int MAX_LINE_LENGTH = StaticProperties.getInt("pronto.control.stdin.max-line-length");
  
      /**
      * The length of time between successive polls of STDIN if no duration is
      * specified by the settings.
      */
     private static final Duration DEFAULT_CHECK_PERIOD = StaticProperties
             .getDuration("pronto.control.stdin.check-period");
 
     /**
      * A pattern for matching lines - the first group is expected to be the
      * label, the second is expected to be the transition parameter.
      */
     private static final Pattern LINE_PATTERN = StaticProperties.getPattern("pronto.control.stdin.line-pattern");
 
     // fields
 
     /**
      * The lock that must be held when performing any action that is dependent
      * upon the object's lifespan.
      */
     private final Object lock = new Object();
 
     /**
      * The controller that aggregates this part.
      */
     private final ControllerImpl<S, L, P> controller;
 
     /**
      * The settings used to construct this part.
      */
     private final StdinControllerSettings settings;
 
     /**
      * A future that represents the repeated polling of STDIN.
      */
     private ScheduledFuture<?> future;
 
     /**
      * Stores the bytes that have been read from STDIN but not parsed into
      * complete lines for execution.
      */
     // reserving a smaller array and then growing it might be more space
     // efficient but the extra work doesn't seem justified
     private final byte[] bytes = new byte[MAX_LINE_LENGTH];
 
     /**
      * The number of valid bytes in the bytes buffer.
      */
     private int bytesRead = 0;
 
     /**
      * Indicates whether the object is currently checking the STDIN. This is
      * used to confirm a successful shutdown when the part is stopped.
      */
     private boolean isChecking = false;
 
     // constructors
 
     /**
      * Creates a new StdinControllerPart.
      * 
      * @param controller
      *            the controller that aggregates this part
      * @param settings
      *            the settings for this part
      */
 
     public StdinControllerPart(final ControllerImpl<S, L, P> controller, final StdinControllerSettings settings) {
         this.controller = controller;
         this.settings = settings;
     }
 
     // part methods
 
     /**
      * Uses the shared pronto executor to schedule periodic checks on STDIN.
      */
 
     public void start() {
         synchronized (lock) {
             if (future != null) return;
 
             // obtain the lock which permits us to use the global resources
             Pronto.getInstance().getUseLock().lock();
 
             // establish a periodicly executed runnable that will check the file
             Duration duration = settings.getCheckPeriod();
             if (duration == null) duration = DEFAULT_CHECK_PERIOD;
             final long period = duration.getTime();
             future = Pronto.getInstance().getExecutor().scheduleWithFixedDelay(new Runnable() {
                 public void run() {
                     synchronized (lock) {
                         isChecking = true;
                         try {
                             checkStdin();
                         } finally {
                             isChecking = false;
                         }
                     }
                 }
             }, period, period, TimeUnit.MILLISECONDS);
         }
     }
 
     /**
      * Requests that the Pronto executor stops any future STDIN checks and then
      * waits (subject to the supplied timeout) until the ceasation of any
      * ongoing checking has been confirmed.
      * 
      * @param timeout
      *            the (approx.) number of milliseconds for which a call to the
      *            method will block, or 0L.
      * @return true if the part was able to confirm that all operation had
      *         ceased
      */
 
     public boolean stop(final long timeout) {
         synchronized (lock) {
             if (future == null) return true;
 
             try {
                 // stop the periodic file checking
                 future.cancel(true);
                 future = null;
 
                 // wait until any ongoing checking has ceased
                 return new Waiter(lock).waitForCondition(timeout, new Waiter.Condition() {
                     public boolean isMet() {
                         return !isChecking;
                     }
                 });
             } finally {
                 // release the pronto use-lock
                 Pronto.getInstance().getUseLock().unlock();
             }
         }
     }
 
     public ControllerImpl<S, L, P> getController() {
         return controller;
     }
 
     // private utility methods
 
     /**
      * This method is called by the pronto executor to checks STDIN for new
      * input. Any residual bytes are left in the bytes field for next time
      * this method is called.
      */
     /*
      * Cannot do the natural thing of spawning a thread, wrapping System.in a
      * reader, blocking on the read and then interrupting to stop because
      * reading on STDIN is not interruptible!! See #4514257 and #4385444
      * 
      * This approach assumes that 'good' values are returned from available().
      */
     private void checkStdin() {
         final InputStream in = System.in;
         try {
             while (true) {
                 // first try to read some more data
                 int available = in.available();
                 // assumes that nothing else is going to slurp these bytes
                 // first, otherwise we will block - something we are working
                 // very hard to avoid
                 if (available > 0) {
                     // byte[] buff = new byte[available];
                     int size = Math.min(available, MAX_LINE_LENGTH - bytesRead);
                     bytesRead += in.read(bytes, bytesRead, size);
                 } else {
                     break; // there's no more data - stop looping
                 }
 
                 // now extract any lines from the data that was read
                 ArrayList<String> lines = new ArrayList<String>();
                 bytesRead = extractLines(bytes, bytesRead, lines);
 
                 // attempt to execute each line
                 for (String line : lines) {
                     processLine(line);
                 }
             }
         } catch (IOException e) {
             ControlFactoryImpl.LOGGER.log(Level.WARNING, "IOException reading STDIN.", e);
         }
 
     }
 
     private void processLine(final String line) {
         if (line.length() == 0) return; // ignore empty lines
 
         // match string
         Matcher matcher = LINE_PATTERN.matcher(line);
         if (!matcher.matches()) {
             if (settings.isInteractive()) {
                 System.out.println("Bad input.");
             } else {
                 ControlFactoryImpl.LOGGER.log(Level.INFO, "Bad line \"{0}\" on STDIN", line);
             }
             return;
         }
 
         // extract label
         String labelName = matcher.group(1);
         final L label = controller.adapter.labelFromName(labelName);
         if (label == null) {
             if (settings.isInteractive()) {
                 System.out.println(String.format("Unrecognized label: %s", label));
             } else {
                 ControlFactoryImpl.LOGGER.log(Level.INFO, "Unrecognized label \"{0}\" on STDIN", labelName);
             }
             return;
         }
 
         // extract param
         String paramStr = matcher.group(2);
         final P param;
         try {
             param = controller.adapter.parseParameter(paramStr);
         } catch (ParseException e) {
             if (settings.isInteractive()) {
                 System.out.println(String.format("Unparsable parameter: %s", paramStr));
             } else {
                 ControlFactoryImpl.LOGGER.log(Level.INFO, "Unparsable parameter \"{0}\" on STDIN", paramStr);
             }
             return;
         }
 
         // perform state change
         try {
             controller.engine.transition(null, label, param);
             if (settings.isInteractive()) {
                 System.out.println("State changed.");
             }
         } catch (ProntoStateException e) {
             if (settings.isInteractive()) {
                 System.out.println(String.format("State change failed: %s", e.getLocalizedMessage()));
             } else {
                 ControlFactoryImpl.LOGGER
                         .log(Level.WARNING, "State transition failed in response to input on STDIN", e);
             }
             return;
         }
     }
 
 }