/*
    * Zemucan: A Syntax Assistant for DB2
    * Copyright (C) 2009, 2010 Andres Gomez Casanova
    *
    * This file is part of Zemucan.
    *
    * Zemucan 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 3 of the License, or
   * (at your option) any later version.
   *
   * Zemucan 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, see <http://www.gnu.org/licenses/>.
   *
   * Contact:
   * a n g o c a  at  y a h o o  dot  c o m
   * Cra. 45 No 61 - 31, Bogota, Colombia.
   *
   * Author:   $LastChangedBy: angoca $:
   * Date:     $LastChangedDate: 2011-03-06 10:15:32 -0500 (dom, 06 mar 2011) $:
   * Revision: $LastChangedRevision: 1913 $:
   * URL:      $HeadURL: https://zemucan.svn.sourceforge.net/svnroot/zemucan/branches/zemucan_v1/source-code/executerImpl/src/main/java/name/angoca/zemucan/executer/impl/ImplementationExecuter.java $:
   */
  package name.angoca.zemucan.executer.impl;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.util.StringTokenizer;
  
  import name.angoca.zemucan.AbstractZemucanException;
  import name.angoca.zemucan.ParameterNullException;
  import name.angoca.zemucan.executer.api.AbstractExecuter;
  import name.angoca.zemucan.executer.api.ExecutingCommandException;
  import name.angoca.zemucan.executer.api.ExecutionState;
  import name.angoca.zemucan.tools.configurator.Configurator;
  import name.angoca.zemucan.tools.messages.executer.Messages;
  import name.angoca.zemucan.ui.api.OutputWriter;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * This is the implementation of the executer. This class is not thread safe
   * because the getInstance method can be executed concurrently and causing
   * problems. This executer does not support the execution of a interactive
   * command (it does not implement the process.getOutputStream().)
   * <p>
   * TODO v2.0 Execute the command in a new thread <b>Control Version</b>
   * <p>
   * <ul>
   * <li>0.0.1 Class creation.</li>
   * <li>0.1.0 Singleton pattern, analyze of exit token.</li>
   * <li>0.1.1 Use of streams.</li>
   * <li>0.1.2 Execution state.</li>
   * <li>0.1.3 Enum.</li>
   * <li>0.1.4 Close de streams and get instance synchronized.</li>
   * <li>0.1.5 Name of a state.</li>
   * <li>0.1.6 final.</li>
   * <li>1.0.0 Moved to version 1.</li>
   * <li>1.1.0 Exit property in this class.</li>
   * <li>1.2.0 Implements an abstract class.</li>
   * <li>1.3.0 Executer improved for OS commands.</li>
   * <li>1.4.0 No thread safe and tests.</li>
   * <li>1.4.1 Strings externalized.</li>
   * <li>1.5.0 Destroy instance.</li>
   * <li>1.6.0 Throws, assert, param order.</li>
   * <li>1.6.1 compareTo -> equals.</li>
   * <li>1.6.2 The application waits the process to be finished</li>
   * <li>1.6.3 Synchronization.</li>
   * <li>1.6.4 Execution in Linux.</li>
   * </ul>
   *
   * @author Andres Gomez Casanova <a
   *         href="mailto:a n g o c a at y a h o o dot c o m" >(AngocA)</a>
   * @version 1.6.4 2010-06-04
   */
  public final class ImplementationExecuter extends AbstractExecuter {
      /**
       * Property to execute DB2 directly throw the db2clp and not from the shell.
       */
      static final String DB2_NATIVE_PROPERTY = "DB2Native"; //$NON-NLS-1$
  
      /**
       * Parameters to execute DB2.
       */
      static final String DB2_PARAMS = "DB2params"; //$NON-NLS-1$
      /**
       * Exit property.
       */
      private static final String EXIT_PROPERTY = "Exit"; //$NON-NLS-1$
  
     /**
      * Token that finish the application.
      */
     static final String EXIT_VALUE = "exit"; //$NON-NLS-1$
 
     /**
      * Singleton pattern.
      */
     private static ImplementationExecuter instance;
 
     /**
      * Logger.
      */
     private static final Logger LOGGER = LoggerFactory
             .getLogger(ImplementationExecuter.class);
 
     /**
      * Destroys the current instance. Useful for tests.
      */
     public static void destroyInstance() {
         if (ImplementationExecuter.instance != null) {
             ImplementationExecuter.instance.tokens = null;
             ImplementationExecuter.instance = null;
         }
 
         assert ImplementationExecuter.instance == null;
     }
 
     /**
      * Implementation of Singleton pattern, returns the sole instance. It's not
      * thread safe, it does not have synchronization because it is expensive.
      * Not double-checked locking neither.
      * <p>
      * This method is not synchronized, and it is not thread safe, but nothing
      * change if it becomes synchronized
      * (http://www.ibm.com/developerworks/java/library/j-dcl.html.)
      *
      * @return The sole instance of the executer.
      */
     public static ImplementationExecuter/* ! */getInstance() {
         if (ImplementationExecuter.instance == null) {
             synchronized (ImplementationExecuter.class) {
                 ImplementationExecuter.instance = new ImplementationExecuter();
             }
         }
 
         assert ImplementationExecuter.instance != null;
         return ImplementationExecuter.instance;
     }
 
     /**
      * For assertions.
      */
     private boolean assertsEnabled;
 
     /**
      * Set of tokens to exit the execution.
      */
     private String tokens;
 
     /**
      * Private default constructor.
      */
     private ImplementationExecuter() {
         this.assertsEnabled = false;
         // Intentional side-effect!
         assert this.assertsEnabled = true;
 
         this.tokens = Configurator.getInstance().getProperty(
                 ImplementationExecuter.EXIT_PROPERTY);
         if ((this.tokens == null) || this.tokens.equals("")) { //$NON-NLS-1$
             this.tokens = ImplementationExecuter.EXIT_VALUE;
         }
     }
 
     /**
      * Catches the error.
      * <p>
      * Note: This method has not been tested.
      *
      * @param command
      *            Executed command.
      * @param exception
      *            Exception thrown that has the reason.
      * @throws CommandNotFoundException
      *             if the reason is a not found command.
      */
     private void catchError(final String/* ! */command,
             final IOException/* ! */exception) throws CommandNotFoundException {
         assert command != null;
         assert exception != null;
 
         // I don't know how to tests this part.
         final String message = exception.getMessage();
         final String error1 = "Cannot run program"; //$NON-NLS-1$
         final CharSequence error2 = new String("CreateProcess error=2"); //$NON-NLS-1$
         if (message.startsWith(error1) && message.contains(error2)) {
             // Adds the name of the command, and it should not be a privacy
             // violation.
             throw new CommandNotFoundException(new StringTokenizer(command)
                     .nextToken());
         }
     }
 
     /**
      * Close the given objects.
      * <p>
      * Note: This method has not been tested.
      *
      * @param inputStream
      *            Stream from the process.
      * @param reader
      *            Reader.
      * @param bfStream
      *            Stream to write.
      * @throws ExecutingCommandException
      *             If there is a problem closing an object.
      */
     private void closeObjects(final InputStream/* ? */inputStream,
             final Reader/* ? */reader, final BufferedReader/* ? */bfStream)
             throws ExecutingCommandException {
 
         try {
             if (bfStream != null) {
                 bfStream.close();
             }
         } catch (final IOException exception2) {
             // I don't know how to tests this part.
             throw new ExecutingCommandException(exception2);
         } finally {
             try {
                 if (inputStream != null) {
                     inputStream.close();
                 }
             } catch (final IOException exception3) {
                 // I don't know how to tests this part.
                 throw new ExecutingCommandException(exception3);
             } finally {
                 if (reader != null) {
                     this.closeStream(reader);
                 }
             }
         }
     }
 
     /**
      * Closes the stream.
      *
      * @param reader
      *            Reader.
      * @throws ExecutingCommandException
      *             If there is a problem, the exception is wrapped.
      */
     private void closeStream(final Reader reader)
             throws ExecutingCommandException {
         try {
             reader.close();
         } catch (final IOException exception4) {
             // I don't know how to tests this part.
             throw new ExecutingCommandException(exception4);
         }
     }
 
     /**
      * Executes the given command and returns a code that means the execution
      * state.
      *
      * @param command
      *            Command to execute.
      * @param writer
      *            The output's writer.
      * @return A signal that indicates the state of the command.
      * @throws AbstractZemucanException
      *             If there is a problem when writing. If a parameter is null.
      *             If there is a problem executing the given command.
      */
     @Override
     public ExecutionState/* ! */execute(final String/* ! */command,
             final OutputWriter/* ! */writer) throws AbstractZemucanException {
         if (command == null) {
             throw new ParameterNullException("command"); //$NON-NLS-1$
         }
         if (writer == null) {
             throw new ParameterNullException("writer"); //$NON-NLS-1$
         }
 
         // No body uses the unknown state, it just for initialize the
         // variable.
         ExecutionState state = ExecutionState.INITIATED;
 
         ImplementationExecuter.LOGGER.info(Messages
                 .getString("ImplementationExecuter.ToExecute"), //$NON-NLS-1$
                 command);
 
         if (this.isAnExitToken(command)) {
             state = ExecutionState.APPLICATION_EXIT;
         } else {
             state = ExecutionState.EXECUTED;
             if (!command.equals("")) { //$NON-NLS-1$
 
                 // Ex2ecutes the commands calling the shell.
                 final String[] commands = this.getCommandsToExecute(command);
 
                 Process process;
                 try {
                     process = Runtime.getRuntime().exec(commands);
                 } catch (final IOException exception) {
                     // I don't know how to tests this part.
                     this.catchError(command, exception);
                     throw new ExecutingCommandException(exception);
                 }
 
                 // Prints the standard output and the standard error
                 // one after the other. Not asynchronous.
                 this.printStream(writer, process.getInputStream());
                 this.printStream(writer, process.getErrorStream());
 
                 int value;
                 try {
                     value = process.waitFor();
                 } catch (final InterruptedException exception) {
                     throw new ExecutingCommandException(exception);
                 }
 
                 ImplementationExecuter.LOGGER.info(Messages
                         .getString("ImplementationExecuter.ErrorCode") //$NON-NLS-1$
                         + value);
                 process.destroy();
             }
         }
 
         ImplementationExecuter.LOGGER.debug("{} -> {}", command, state); //$NON-NLS-1$
 
         assert state != null;
         return state;
     }
 
     /**
      * Executes a db2 command natively.
      *
      * @param db2params
      *            the db2 params.
      * @param db2Command
      *            The db2 command.
      * @param thereAreDB2Params
      *            If there are db2 params.
      * @return The set of commands to execute.
      */
     private String[] executeNativeDB2Command(final String db2params,
             final String db2Command, final boolean thereAreDB2Params) {
         String[] commands;
         // With the given environment parameters.
         if (thereAreDB2Params) {
             ImplementationExecuter.LOGGER
                     .debug("db2 command natively with params"); //$NON-NLS-1$
             commands = new String[] { "db2", db2params, db2Command }; //$NON-NLS-1$
         } else {
             // With no environment parameters.
             ImplementationExecuter.LOGGER
                     .debug("db2 command natively without params"); //$NON-NLS-1$
             commands = new String[] { "db2", db2Command }; //$NON-NLS-1$
         }
         return commands;
     }
 
     /**
      * Executes a command in shell. Refactored method.
      *
      * @param db2params
      *            If there are some db2 params.
      * @param isADB2Command
      *            If the command is db2.
      * @param db2Command
      *            The db2 command.
      * @param thereAreDB2Params
      *            If there are db2 params.
      * @return The set of commands to execute.
      */
     private String[] executeOtherCommand(final String db2params,
             final boolean isADB2Command, final String db2Command,
             final boolean thereAreDB2Params) {
         String[] commands;
         // Executes the commands calling the shell.
 
         // Prepares the execution environment
         final String os = System.getProperty("os.name"); //$NON-NLS-1$
         ImplementationExecuter.LOGGER.info(Messages
                 .getString("ImplementationExecuter.Executing"), os); //$NON-NLS-1$
         // The operative system is Linux.
         if (os.startsWith("Linux")) { //$NON-NLS-1$
             commands = this.getLinuxCommand(isADB2Command, thereAreDB2Params,
                     db2params, db2Command);
         } else
         // The operative system is Windows
         if (os.startsWith("Windows")) { //$NON-NLS-1$
             commands = this.getWindowsCommand(isADB2Command, thereAreDB2Params,
                     db2params, db2Command);
         } else {
             // The operative system is other. Executing directly.
 
             ImplementationExecuter.LOGGER.warn(Messages
                     .getString("ImplementationExecuter.NoShell")); //$NON-NLS-1$
             commands = new String[] { db2Command };
         }
         return commands;
     }
 
     /**
      * If the command is a db2 clp command, it removes the db2 part.
      *
      * @param command
      *            Command to execute.
      * @return The real db2 clp command to execute, or the original command.
      */
     private String/* ! */extractDB2Part(final String/* ! */command) {
         assert command != null;
 
         String newCommand = command;
         final String db2 = "db2 "; //$NON-NLS-1$
         if (command.startsWith(db2)) {
             newCommand = command.substring(db2.length());
         }
 
         assert newCommand != null;
         return newCommand;
     }
 
     /**
      * Analyzes how the command has be to executed. If it has to call the shell,
      * or db2 directly and which parameters.
      *
      * @param command
      *            Command to execute.
      * @return The command that has to be executed.
      * @throws ParameterNullException
      *             If a parameter is null.
      */
     String[]/* [!]! */getCommandsToExecute(final String/* ! */command)
             throws ParameterNullException {
         if (command == null) {
             throw new ParameterNullException("command"); //$NON-NLS-1$
         }
 
         // Gets some parameters
         final boolean db2Native = Boolean.parseBoolean(Configurator
                 .getInstance().getProperty(
                         ImplementationExecuter.DB2_NATIVE_PROPERTY));
         final String db2params = System
                 .getProperty(ImplementationExecuter.DB2_PARAMS);
 
         final boolean isADB2Command = command.startsWith("db2 "); //$NON-NLS-1$
 
         final String db2Command = this.extractDB2Part(command);
 
         boolean thereAreDB2Params = false;
         if (!command.equals(db2Command)) {
             // This is a DB2 command.
             thereAreDB2Params = (db2params != null) && !db2params.equals(""); //$NON-NLS-1$
         }
 
         String[] commands = null;
         // Executes a db2 command directly. Operative system commands
         // are ignored and they are passed as parameters. Use of pipe
         // is not possible.
         if (db2Native && isADB2Command) {
             commands = this.executeNativeDB2Command(db2params, db2Command,
                     thereAreDB2Params);
         } else {
             commands = this.executeOtherCommand(db2params, isADB2Command,
                     db2Command, thereAreDB2Params);
         }
 
         assert commands != null;
         if (this.assertsEnabled) {
             for (final String retCommand : commands) {
                 assert retCommand != null;
             }
         }
         return commands;
     }
 
     /**
      * Returns the set of commands with all parameters to execute in Linux.
      *
      * @param isADB2Command
      *            if the command is a db2 command.
      * @param thereAreDB2Params
      *            if there are db2 parameters.
      * @param db2params
      *            Set of db2 parameters.
      * @param db2Command
      *            original command without the db2 word.
      * @return Set of commands to execute in Linux.
      */
     private String[]/* [!]! */getLinuxCommand(final boolean isADB2Command,
             final boolean thereAreDB2Params, final String/* ? */db2params,
             final String/* ! */db2Command) {
         assert db2Command != null;
 
         String[] commands;
         // iIt's a DB2 command.
         if (isADB2Command) {
             // There are DB2 params.
             if (thereAreDB2Params) {
                 ImplementationExecuter.LOGGER
                         .debug("Linux and db2 command with params"); //$NON-NLS-1$
                 commands = new String[] { "db2", db2params, db2Command }; //$NON-NLS-1$
             } else {
                 // There are not DB2 params
                 ImplementationExecuter.LOGGER
                         .debug("Linux and db2 command without params"); //$NON-NLS-1$
                 commands = new String[] { "db2", db2Command }; //$NON-NLS-1$
             }
         } else {
             // It is not a DB2 command.
             ImplementationExecuter.LOGGER.debug("Linux and NOT db2 command"); //$NON-NLS-1$
             commands = new String[] { db2Command };
         }
 
         assert commands != null;
         if (this.assertsEnabled) {
             for (final String retCommand : commands) {
                 assert retCommand != null;
             }
         }
         return commands;
     }
 
     /**
      * Returns the set of tokens to exit the application.
      *
      * @return Set of tokens.
      */
     String/* ! */getTokens() {
         assert this.tokens != null;
         return this.tokens;
     }
 
     /**
      * Returns the set of commands with all parameters to execute in Windows.
      *
      * @param isADB2Command
      *            if the command is a db2 command.
      * @param thereAreDB2Params
      *            if there are db2 parameters.
      * @param db2params
      *            Set of db2 parameters.
      * @param db2Command
      *            original command without the db2 word.
      * @return Set of commands to execute in Windows.
      */
     private String[]/* [!]! */getWindowsCommand(final boolean isADB2Command,
             final boolean thereAreDB2Params, final String/* ? */db2params,
             final String/* ! */db2Command) {
         assert db2Command != null;
 
         String[] commands;
         if (isADB2Command) {
             if (thereAreDB2Params) {
                 ImplementationExecuter.LOGGER
                         .debug("Windows and db2 command with params"); //$NON-NLS-1$
                 commands = new String[] { "cmd.exe", "/c", "db2", db2params, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                         db2Command };
             } else {
                 ImplementationExecuter.LOGGER
                         .debug("Windows and db2 command without params"); //$NON-NLS-1$
                 commands = new String[] { "cmd.exe", "/c", "db2", db2Command }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
             }
         } else {
             ImplementationExecuter.LOGGER.debug("Windows and NOT db2 command"); //$NON-NLS-1$
             commands = new String[] { "cmd.exe", "/c", db2Command }; //$NON-NLS-1$ //$NON-NLS-2$
         }
 
         assert commands != null;
         if (this.assertsEnabled) {
             for (final String retCommand : commands) {
                 assert retCommand != null;
             }
         }
         return commands;
     }
 
     /**
      * Analyze the current command to see if the application has to finish.
      *
      * @param command
      *            Command entered.
      * @return true if the application has to finish.
      */
     private boolean isAnExitToken(final String/* ! */command) {
         assert command != null;
 
         boolean exit = false;
         final StringTokenizer pharseTokens = new StringTokenizer(this.tokens);
         while (pharseTokens.hasMoreElements() && !exit) {
             if (command.compareToIgnoreCase(pharseTokens.nextToken()) == 0) {
                 exit = true;
             }
         }
         return exit;
     }
 
     /**
      * Prints a given stream in the given writer.
      *
      * @param writer
      *            Writer into write the stream.
      * @param inputStream
      *            Stream to write. It's closed when finished the method.
      * @throws AbstractZemucanException
      *             If there is a problem writing. If there is a problem while
      *             printing.
      */
     private void printStream(final OutputWriter/* ! */writer,
             final InputStream/* ! */inputStream) throws AbstractZemucanException {
         assert writer != null;
         assert inputStream != null;
 
         final Reader reader = new InputStreamReader(inputStream);
         final BufferedReader bfStream = new BufferedReader(reader);
 
         String current;
         // Prints the standard output.
         try {
             current = bfStream.readLine();
             while (current != null) {
                 writer.writeLine(current);
                 current = bfStream.readLine();
             }
         } catch (final IOException exception1) {
             // I don't know how to tests this part.
             throw new ExecutingCommandException(exception1);
         } finally {
             this.closeObjects(inputStream, reader, bfStream);
         }
     }
 }