/*
    * 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.maven.scm.provider.hg;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.maven.scm.ScmException;
  import org.apache.maven.scm.ScmFileSet;
  import org.apache.maven.scm.ScmFileStatus;
  import org.apache.maven.scm.ScmResult;
  import org.apache.maven.scm.provider.hg.command.HgCommandConstants;
  import org.apache.maven.scm.provider.hg.command.HgConsumer;
  import org.apache.maven.scm.provider.hg.command.inventory.HgChangeSet;
  import org.apache.maven.scm.provider.hg.command.inventory.HgOutgoingConsumer;
  import org.codehaus.plexus.util.cli.CommandLineException;
  import org.codehaus.plexus.util.cli.CommandLineUtils;
  import org.codehaus.plexus.util.cli.Commandline;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Common code for executing hg commands.
   *
   * @author <a href="mailto:thurner.rupert@ymono.net">thurner rupert</a>
   *
   */
  public final class HgUtils {
      private static final Logger LOGGER = LoggerFactory.getLogger(HgUtils.class);
  
      public static final String DEFAULT = "default";
  
      private HgUtils() {
          // no op
      }
  
      /**
       * Map between command and its valid exit codes
       */
      private static final Map<String, List<Integer>> EXIT_CODE_MAP = new HashMap<>();
  
      /**
       * Default exit codes for entries not in exitCodeMap
       */
      private static final List<Integer> DEFAULT_EXIT_CODES = new ArrayList<>();
  
      /** Setup exit codes*/
      static {
          DEFAULT_EXIT_CODES.add(Integer.valueOf(0));
  
          // Diff is different
          List<Integer> diffExitCodes = new ArrayList<>(3);
          diffExitCodes.add(Integer.valueOf(0)); // No difference
          diffExitCodes.add(Integer.valueOf(1)); // Conflicts in merge-like or changes in diff-like
          diffExitCodes.add(Integer.valueOf(2)); // Unrepresentable diff changes
          EXIT_CODE_MAP.put(HgCommandConstants.DIFF_CMD, diffExitCodes);
          // Outgoing is different
          List<Integer> outgoingExitCodes = new ArrayList<>(2);
          outgoingExitCodes.add(Integer.valueOf(0)); // There are changes
          outgoingExitCodes.add(Integer.valueOf(1)); // No changes
          EXIT_CODE_MAP.put(HgCommandConstants.OUTGOING_CMD, outgoingExitCodes);
      }
  
      public static ScmResult execute(HgConsumer consumer, File workingDir, String[] cmdAndArgs) throws ScmException {
          try {
              // Build commandline
              Commandline cmd = buildCmd(workingDir, cmdAndArgs);
              if (LOGGER.isInfoEnabled()) {
                  LOGGER.info("EXECUTING: " + maskPassword(cmd));
              }
  
              // Execute command
              int exitCode = executeCmd(consumer, cmd);
  
              // Return result
              List<Integer> exitCodes = DEFAULT_EXIT_CODES;
              if (EXIT_CODE_MAP.containsKey(cmdAndArgs[0])) {
                  exitCodes = EXIT_CODE_MAP.get(cmdAndArgs[0]);
              }
              boolean success = exitCodes.contains(Integer.valueOf(exitCode));
 
             // On failure (and not due to exceptions) - run diagnostics
             String providerMsg = "Execution of hg command succeded";
             if (!success) {
                 HgConfig config = new HgConfig(workingDir);
                 providerMsg = "\nEXECUTION FAILED" + "\n  Execution of cmd : " + cmdAndArgs[0]
                         + " failed with exit code: "
                         + exitCode + "." + "\n  Working directory was: " + "\n    " + workingDir.getAbsolutePath()
                         + config.toString(workingDir) + "\n";
                 if (LOGGER.isErrorEnabled()) {
                     LOGGER.error(providerMsg);
                 }
             }
 
             return new ScmResult(cmd.toString(), providerMsg, consumer.getStdErr(), success);
         } catch (ScmException se) {
             String msg = "EXECUTION FAILED" + "\n  Execution failed before invoking the Hg command. Last exception:"
                     + "\n    " + se.getMessage();
 
             // Add nested cause if any
             if (se.getCause() != null) {
                 msg += "\n  Nested exception:" + "\n    " + se.getCause().getMessage();
             }
 
             // log and return
             if (LOGGER.isErrorEnabled()) {
                 LOGGER.error(msg);
             }
             throw se;
         }
     }
 
     static Commandline buildCmd(File workingDir, String[] cmdAndArgs) throws ScmException {
         Commandline cmd = new Commandline();
         cmd.setExecutable(HgCommandConstants.EXEC);
         cmd.addArguments(cmdAndArgs);
         if (workingDir != null) {
             cmd.setWorkingDirectory(workingDir.getAbsolutePath());
 
             if (!workingDir.exists()) {
                 boolean success = workingDir.mkdirs();
                 if (!success) {
                     String msg = "Working directory did not exist" + " and it couldn't be created: " + workingDir;
                     throw new ScmException(msg);
                 }
             }
         }
         return cmd;
     }
 
     static int executeCmd(HgConsumer consumer, Commandline cmd) throws ScmException {
         final int exitCode;
         try {
             exitCode = CommandLineUtils.executeCommandLine(cmd, consumer, consumer);
         } catch (CommandLineException ex) {
             throw new ScmException("Command could not be executed: " + cmd, ex);
         }
         return exitCode;
     }
 
     public static ScmResult execute(File workingDir, String[] cmdAndArgs) throws ScmException {
         return execute(new HgConsumer(), workingDir, cmdAndArgs);
     }
 
     public static String[] expandCommandLine(String[] cmdAndArgs, ScmFileSet additionalFiles) {
         List<File> filesList = additionalFiles.getFileList();
         String[] cmd = new String[filesList.size() + cmdAndArgs.length];
 
         // Copy command into array
         System.arraycopy(cmdAndArgs, 0, cmd, 0, cmdAndArgs.length);
 
         // Add files as additional parameter into the array
         int i = 0;
         for (File scmFile : filesList) {
             String file = scmFile.getPath().replace('\\', File.separatorChar);
             cmd[i + cmdAndArgs.length] = file;
             i++;
         }
 
         return cmd;
     }
 
     public static int getCurrentRevisionNumber(File workingDir) throws ScmException {
 
         String[] revCmd = new String[] {HgCommandConstants.REVNO_CMD};
         HgRevNoConsumer consumer = new HgRevNoConsumer();
         HgUtils.execute(consumer, workingDir, revCmd);
 
         return consumer.getCurrentRevisionNumber();
     }
 
     public static String getCurrentBranchName(File workingDir) throws ScmException {
         String[] branchnameCmd = new String[] {HgCommandConstants.BRANCH_NAME_CMD};
         HgBranchnameConsumer consumer = new HgBranchnameConsumer();
         HgUtils.execute(consumer, workingDir, branchnameCmd);
         return consumer.getBranchName();
     }
 
     /**
      * Get current (working) revision.
      * <p>
      * Resolve revision to the last integer found in the command output.
      */
     private static class HgRevNoConsumer extends HgConsumer {
 
         private int revNo;
 
         public void doConsume(ScmFileStatus status, String line) {
             try {
                 revNo = Integer.valueOf(line).intValue();
             } catch (NumberFormatException e) {
                 // ignore
             }
         }
 
         int getCurrentRevisionNumber() {
             return revNo;
         }
     }
 
     /**
      * Get current (working) branch name
      */
     private static class HgBranchnameConsumer extends HgConsumer {
 
         private String branchName;
 
         public void doConsume(ScmFileStatus status, String trimmedLine) {
             branchName = String.valueOf(trimmedLine);
         }
 
         String getBranchName() {
             return branchName;
         }
 
         /** {@inheritDoc} */
         public void consumeLine(String line) {
             if (logger.isDebugEnabled()) {
                 logger.debug(line);
             }
             String trimmedLine = line.trim();
 
             doConsume(null, trimmedLine);
         }
     }
 
     /**
      * Check if there are outgoing changes on a different branch. If so, Mercurial default behaviour
      * is to block the push and warn using a 'push creates new remote branch !' message.
      * We also warn, and return true if a different outgoing branch was found
      * <p>
      * Method users should not stop the push on a negative return, instead, they should
      * hg push -r(branch being released)
      *
      * @param workingDir        the working dir
      * @param workingbranchName the working branch name
      * @return true if a different outgoing branch was found
      * @throws ScmException on outgoing command error
      */
     public static boolean differentOutgoingBranchFound(File workingDir, String workingbranchName) throws ScmException {
         String[] outCmd = new String[] {HgCommandConstants.OUTGOING_CMD};
         HgOutgoingConsumer outConsumer = new HgOutgoingConsumer();
         ScmResult outResult = HgUtils.execute(outConsumer, workingDir, outCmd);
         List<HgChangeSet> changes = outConsumer.getChanges();
         if (outResult.isSuccess()) {
             for (HgChangeSet set : changes) {
                 if (!getBranchName(workingbranchName).equals(getBranchName(set.getBranch()))) {
                     LOGGER.warn("A different branch than " + getBranchName(workingbranchName)
                             + " was found in outgoing changes, branch name was " + getBranchName(set.getBranch())
                             + ". Only local branch named " + getBranchName(workingbranchName) + " will be pushed.");
                     return true;
                 }
             }
         }
         return false;
     }
 
     private static String getBranchName(String branch) {
         return branch == null ? DEFAULT : branch;
     }
 
     public static String maskPassword(Commandline cl) {
         String clString = cl.toString();
 
         int pos = clString.indexOf('@');
 
         if (pos > 0) {
             clString = clString.replaceAll(":\\w+@", ":*****@");
         }
 
         return clString;
     }
 }