/*
    * #%L
    * JavaHg
    * %%
    * Copyright (C) 2011 aragost Trifork ag
    * %%
    * Permission is hereby granted, free of charge, to any person obtaining a copy
    * of this software and associated documentation files (the "Software"), to deal
    * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   * copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:
   * 
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   * 
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   * THE SOFTWARE.
   * #L%
   */
  package com.aragost.javahg.internals;
  
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.nio.charset.CharsetDecoder;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.ConcurrentModificationException;
  import java.util.List;
  import java.util.concurrent.atomic.AtomicReference;
  
  import com.aragost.javahg.Changeset;
  import com.aragost.javahg.DateTime;
  import com.aragost.javahg.Repository;
  import com.aragost.javahg.UnknownCommandException;
  import com.aragost.javahg.commands.CancelledExecutionException;
  import com.aragost.javahg.commands.ExecutionException;
  import com.google.common.collect.Lists;
  import com.google.common.io.ByteStreams;
  
  /**
   * Base class for the command classes.
   * 
   * Each Mercurial command (e.g., "log", "commit", etc) is mapped to a command
   * class, which is a subclass of this class. The command classes will provide
   * methods for setting command line flags and for actually executing the
   * command.
   * 
   * Concurrency: Instances of this class should be accessed only on a single
   * thread. The only exception is {@link #cancel()}.
   * 
   * States: Normally: READY->QUEUED->RUNNING->READY. If cancelled: From READY,
   * QUEUED, or RUNNING -> CANCELLING -> READY. If cancelled the executing thread
   * will have a CancelledExecutionException thrown and state will be READY.
   */
  public abstract class AbstractCommand {
  
      public enum State { READY, QUEUED, RUNNING, CANCELING }; 
  
      private AtomicReference<State> state = new AtomicReference<AbstractCommand.State>(State.READY);
  
      private final List<String> cmdLine;
  
      private final Repository repository;
  
      private OutputChannelInputStream outputChannelStream;
  
      private ByteArrayOutputStream error = new ByteArrayOutputStream();
  
      private int returnCode = Integer.MIN_VALUE;
  
      private int lineChannelLength;
  
      /**
       * Not null while in {@link State#RUNNING}.
       */
      private volatile Server server;
  
      protected AbstractCommand(Repository repository) {
          this.repository = repository;
          this.cmdLine = Lists.newArrayList(getCommandName());
      }
  
      protected AbstractCommand(Repository repository, String commandName) {
          this.repository = repository;
          this.cmdLine = Lists.newArrayList(commandName);
      }
  
      /**
       * @return the name of this Mercurial command, i.e., "add", "log",
       *         etc
       */
     public abstract String getCommandName();
 
     public void cmdAppend(String option) {
         this.cmdLine.add(option);
     }
 
     public void cmdAppend(String option, String arg) {
         if (arg == null) {
             throw new NullPointerException("cannot pass null for " + option + " flag");
         }
         this.cmdLine.add(option);
         this.cmdLine.add(arg);
     }
 
     public void cmdAppend(String option, String[] args) {
         for (String arg : args) {
             cmdAppend(option, arg);
         }
     }
 
     public void cmdAppend(String option, int arg) {
         this.cmdLine.add(option);
         this.cmdLine.add("" + arg);
     }
 
     public void cmdAppend(String option, DateTime date) {
         if (date == null) {
             throw new NullPointerException("cannot pass null for " + option + " flag");
         }
         this.cmdLine.add(option);
         this.cmdLine.add(date.getHgString());
     }
 
     /**
      * Launch the command and return stdout as a String.
      * 
      * @param args
      *            extra command line arguments (optional).
      * @return stdout as a String.
      * @throws IOException
      */
     protected final String launchString(String... args) {
         InputStream stdout = launchStream(args);
         try {
             return Utils.readStream(stdout, getRepository().newDecoder());
         } finally {
             cleanUp();
         }
     }
 
     /**
      * Launch the command and return stdout as a InputStream.
      * 
      * @param args
      *            extra command line arguments (optional).
      * @return stdout stream
      */
     protected final HgInputStream launchStream(String... args) {
         clear();
         changeState(State.READY, State.QUEUED, true);
 
         try {
             server = repository.getServerPool().take(this);
             changeState(State.QUEUED, State.RUNNING, true);
         } catch (InterruptedException e1) {
             changeState(State.CANCELING, State.READY, false);
             throw new CancelledExecutionException(this);
         }
 
         List<String> commandLine = new ArrayList<String>(this.cmdLine);
         boolean ok = false;
 
         getRepository().addToCommandLine(commandLine);
         commandLine.addAll(Arrays.asList(args));
 
         try {
             this.outputChannelStream = server.runCommand(commandLine, this);
             HgInputStream stream = new HgInputStream(outputChannelStream, this.repository.newDecoder());
             ok = true;
             return stream;
         } catch (UnexpectedServerTerminationException e) {
             if (state.get() == State.CANCELING) {
                 throw new CancelledExecutionException(this);
             }
             throw e;
         } catch (IOException e) {
             throw new RuntimeIOException(e);
         } finally {
             // If an exception is thrown there is no chance the command will
             // finish normally so abort the server. E.g protocol error
             if (!ok && state.get() != State.READY) {
                 state.set(State.READY);
                 repository.getServerPool().abort(server);
                 server = null;
             }
         }
     }
 
     /**
      * Changes state checking for cancellation
      * 
      * @param current
      *            The expected state
      * @param next
      *            The state to change to
      * @param strict
      *            If true a {@link ConcurrentModificationException} is thrown if
      *            in unexpected state
      * @throws CancelledExecutionException
      *             If in cancelled state
      * @throws ConcurrentModificationException
      *             If in another unexpected state and if strict is true
      */
     private void changeState(State current, State next, boolean strict) {
         if (!state.compareAndSet(current, next)) {
             if (state.compareAndSet(State.CANCELING, State.READY)) {
                 throw new CancelledExecutionException(this);                
             }
             if (strict) {
                 throw new ConcurrentModificationException("Unexpected command state");
             }
         }
     }
 
     protected final LineIterator launchIterator(String... args) {
         return new LineIterator(launchStream(args));
     }
 
     /**
      * Open the output stream again after sending input to the command
      * server. When the server alternates between sending output on
      * the 'o' channel and reading input lines, the output channel
      * will run dry several times. Call this method after sending
      * input to the command server in response to reading from the 'L'
      * channel. New output from the server will then appear on the
      * output channel.
      */
     public void reopenOutputChannelStream() {
         this.outputChannelStream.reopen();
     }
 
     /**
      * Send input line to command server in response to reading a
      * block on the 'L' channel.
      * 
      * @param s
      *            line of input.
      */
     public void sendLine(String s) {
         if (this.lineChannelLength == 0) {
             throw new IllegalStateException("No input expected");
         }
 
         server.sendLine(s);
         this.lineChannelLength = 0;
     }
 
     /**
      * @return true if we have read a 'L' channel from the server.
      */
     public boolean needsInputLine() {
         return this.lineChannelLength > 0;
     }
 
     /**
      * Finish the request by consuming any remaining input on the
      * output channel from the server. The server wont respond to new
      * commands until this is done.
      */
     void cleanUp() {
         if (this.outputChannelStream != null) {
             try {
                 Utils.consumeAll(this.outputChannelStream);
             } catch (IOException e) {
                 throw new RuntimeIOException(e);
             }
         }
     }
 
     protected void clear() {
         this.error.reset();
         this.returnCode = Integer.MIN_VALUE;
     }
 
     /**
      * Check if the command ended with a zero return code. Subclasses
      * can override this to accept other return codes as successful.
      * 
      * @return true if the command ended successfully.
      */
     protected boolean isSuccessful() {
         return getReturnCode() == 0;
     }
 
     private String streamAsString(OutputStream stream) {
         if (stream instanceof ByteArrayOutputStream) {
             byte[] bytes = ((ByteArrayOutputStream) stream).toByteArray();
             CharsetDecoder decoder = getRepository().newDecoder();
             return Utils.decodeBytes(bytes, decoder);
         } else {
             throw new IllegalStateException();
         }
     }
 
     /**
      * @return data read on the 'e' channel
      */
     public String getErrorString() {
         return streamAsString(this.error);
     }
 
     /**
      * @return the return code read from the 'r' channel
      */
     public int getReturnCode() {
         if (this.returnCode == Integer.MIN_VALUE) {
             throw new IllegalStateException("cmdserver is still executing request");
         }
         return this.returnCode;
     }
 
     /**
      * @return the {@link Repository} associated with this command.
      */
     public Repository getRepository() {
         return repository;
     }
 
     @Override
     public String toString() {
         return getCommandName();
     }
 
     /**
      * @param lineChannelLength
      *            the line length requested by the server on the 'L'
      *            channel.
      */
     void setLineChannelLength(int lineChannelLength) {
         this.lineChannelLength = lineChannelLength;
     }
 
     /**
      * Add to the stderr data stored in this command.
      * 
      * @param cin
      *            stderr of the command server.
      * @throws IOException
      */
     void addToError(BlockInputStream cin) throws IOException {
         ByteStreams.copy(cin, this.error);
     }
 
     protected void withDebugAndChangesetStyle() {
         withDebugFlag();
         cmdAppend("--style", Changeset.CHANGESET_STYLE_PATH);
     }
 
     protected void withDebugFlag() {
         cmdAppend("--debug");
     }
 
     /**
      * Called exactly once when this command finishes executing. The server is
      * freed and the state is changed to DONE.
      * 
      * @param returnCode The exit code of the completed command
      */
     final void handleReturnCode(int returnCode) {
         this.returnCode = returnCode;
         server.clearCurrentCommand(this);
         repository.getServerPool().put(server);
         server = null;
         changeState(State.RUNNING, State.READY, false);
 
         if (returnCode == -1) {
             // This can for example happens for an unknown command
             String errorString = getErrorString();
             if (errorString.startsWith("hg: unknown command '")) {
                 throw new UnknownCommandException(this);
             }
         }
 
         doneHook();
 
         if (!isSuccessful()) {
             throw new ExecutionException(this);
         }
     }
 
     /**
      * Cancel a running command. May be called from a different thread. Returns
      * immediately. The thread executing the command should return soon after
      * with a {@link CancelledExecutionException} thrown.
      */
     public final void cancel() {
         State oldState = state.getAndSet(State.CANCELING);
 
         if (oldState != State.READY) {
             // There is a small chance the final state of a command will be
             // CANCELLING rather than DONE but this doesn't actually matter.
             Server server = this.server;
             Process process;
 
             if (server != null && (process = server.getProcess()) != null) {
                 process.destroy();
             }
         }
     }
 
     /**
      * @return The current state of the command.
      */
     State getState() {
         return state.get();
     }
 
     /**
      * This method is called when the processing of a command is
      * finished. More precise it is called just after the 'r' channel
      * is read
      * <p>
      * It can be overridden in subclasses.
      */
     protected void doneHook() {
 
     }
 }