/*
    * #%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.BufferedOutputStream;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.lang.reflect.Array;
  import java.lang.reflect.InvocationTargetException;
  import java.nio.ByteBuffer;
  import java.nio.CharBuffer;
  import java.nio.charset.CharacterCodingException;
  import java.nio.charset.Charset;
  import java.nio.charset.CharsetDecoder;
  import java.util.Collection;
  import java.util.Map;
  import java.util.Random;
  import java.util.concurrent.ExecutionException;
  import java.util.regex.Pattern;
  
  import com.aragost.javahg.log.Logger;
  import com.aragost.javahg.log.LoggerFactory;
  import com.google.common.io.ByteStreams;
  import com.google.common.io.CharStreams;
  
  /**
   * Miscellaneous utils methods for JavaHg.
   */
  public class Utils {
  
      private static final Logger LOG = LoggerFactory.getLogger(Utils.class);
  
      /**
       * Flag indicating if we are on a Windows box
       */
      private static final boolean IS_WINDOWS;
  
      /**
       * Temp dir where resources are copied from the jar (classpath) to
       * an actual file
       */
      private static final File RESOURCES_TEMP_DIR;
      static {
          String osName = System.getProperty("os.name");
          IS_WINDOWS = osName.startsWith("Windows");
          File baseDirectory = new File(System.getProperty("user.home"), ".javahg" + File.separator + "tmp");
          RESOURCES_TEMP_DIR = createTempDirectory(baseDirectory);
          Runtime.getRuntime().addShutdownHook(new Thread() {
              @Override
              public void run() {
                  try {
                      Utils.deleteRecursive(RESOURCES_TEMP_DIR);
                      LOG.info("Deleted temp resource dir " + RESOURCES_TEMP_DIR);
                  } catch (IOException e) {
                      System.err.println("Could not delete temp resource dir " + RESOURCES_TEMP_DIR);
                      e.printStackTrace();
                  }
              }
          });
      }
  
  	private static final Pattern HTTP_PATTERN = Pattern.compile("[hH][tT][tT][pP]:.*[@]");
  	private static final Pattern HTTPS_PATTERN = Pattern.compile("[hH][tT][tT][pP][sS]:.*[@]");
  	private static final Pattern SSH_PATTERN = Pattern.compile("[sS][sS][hH]:.*[@]");
  	private static final Pattern SVN_PATTERN = Pattern.compile("[sS][vV][nN]:.*[@]");
  
      /**
       * 
       * @return true if the OS is Windows, otherwise false
       */
      public static boolean isWindows() {
          return IS_WINDOWS;
     }
 
     public static Charset getUtf8Charset() {
         return Charset.forName("UTF-8");
     }
 
     /**
      * Read four bytes from the stream, and return the integer
      * represented by these bytes in big endian. If EOF is reached
      * then -1 is returned.
      * 
      * @param stream
      *            the input stream
      * @return the decoded integer.
      * @throws IOException
      */
     public static int readBigEndian(InputStream stream) throws IOException {
         byte b0 = (byte) stream.read();
         byte b1 = (byte) stream.read();
         byte b2 = (byte) stream.read();
         int b3 = stream.read();
         if (b3 == -1) {
             return -1;
         }
         return (b0 << 24) + ((b1 & 0xFF) << 16) + ((b2 & 0xFF) << 8) + ((byte) b3 & 0xFF);
     }
 
     /**
      * Write 4 bytes representing the specified integer in big-endian.
      * 
      * @param n
      *            the integer
      * @param stream
      *            the output stream
      * @throws IOException
      */
     public static void writeBigEndian(int n, OutputStream stream) throws IOException {
         byte[] bytes = new byte[] { (byte) (n >>> 24), (byte) (n >>> 16), (byte) (n >>> 8), (byte) n };
         stream.write(bytes);
     }
 
     /**
      * Read and discard everything from the specified InputStream
      * 
      * @param stream
      * @throws IOException
      */
     public static void consumeAll(InputStream stream) throws IOException {
         while (stream.read(BUF) != -1)
             ;
     }
 
     private static final byte[] BUF = new byte[256];
 
     /**
      * Read everything from the stream and return it as a String
      * 
      * @param in
      *            the input stream
      * @param decoder
      *            the {@link CharsetDecoder} encapsulating the policy
      *            of handling errors while decoding.
      * @return the decoded String.
      */
     public static String readStream(InputStream in, CharsetDecoder decoder) {
         try {
             return CharStreams.toString(new InputStreamReader(in, decoder));
         } catch (IOException e) {
             throw new RuntimeIOException(e);
         }
     }
 
     /**
      * Decode the bytes with the decoder
      * 
      * @param bytes
      * @param decoder
      * @return the decoded bytes
      */
     public static String decodeBytes(byte[] bytes, CharsetDecoder decoder) {
         ByteBuffer wrap = ByteBuffer.wrap(bytes);
         CharBuffer chars;
         try {
             chars = decoder.decode(wrap);
         } catch (CharacterCodingException e) {
             throw asRuntime(e);
         }
         return new String(chars.array(), chars.arrayOffset(), chars.limit());
     }
 
     /**
      * Insert an element as the first to an array. The input array is
      * not changed, instead a copy is returned.
      * 
      * @param <T>
      * @param first
      *            element to insert at position 0 in the result.
      * @param rest
      *            elements to insert at position 1 to
      *            {@code rest.length}.
      * @return the unshifted array of length {@code 1 + rest.length}.
      */
     public static <T> T[] arrayUnshift(T first, T[] rest) {
         @SuppressWarnings("unchecked")
         T[] result = (T[]) Array.newInstance(first.getClass(), 1 + rest.length);
         result[0] = first;
         System.arraycopy(rest, 0, result, 1, rest.length);
         return result;
     }
 
     /**
      * Concatenate two arrays. The input arrays are copied into the
      * output array.
      * 
      * @param <T>
      * @param a
      * @param b
      * @return the concatenated array of length
      *         {@code a.length + b.length}.
      */
     public static <T> T[] arrayConcat(T[] a, T[] b) {
         @SuppressWarnings("unchecked")
         T[] result = (T[]) Array.newInstance(a.getClass().getComponentType(), a.length + b.length);
         System.arraycopy(a, 0, result, 0, a.length);
         System.arraycopy(b, 0, result, a.length, b.length);
         return result;
     }
 
     /**
      * Convert an array of Files to an array of Strings.
      * <p>
      * Each file is converted with the getPath() method.
      * 
      * @param files
      * @return array of file names as Strings
      */
     public static String[] fileArray2StringArray(File[] files) {
         String[] result = new String[files.length];
         for (int i = 0; i < files.length; i++) {
             File file = files[i];
             result[i] = file.getPath();
         }
         return result;
     }
 
     /**
      * 
      * @param baseDir
      * @param strings
      * @return array of File objects
      */
     public static File[] stringArray2FileArray(File baseDir, String[] strings) {
         File[] result = new File[strings.length];
         for (int i = 0; i < strings.length; i++) {
             String s = strings[i];
             File file = new File(s);
             if (!file.isAbsolute()) {
                 file = new File(baseDir, s);
             }
             result[i] = Utils.resolveSymlinks(file);
         }
         return result;
     }
 
     /**
      * Return a new File object where symlinks are resolved.
      * 
      * @param file
      * @return the canonical file name
      */
     public static File resolveSymlinks(File file) {
         // On windows calling File.getCanonicalFile will result in
         // abc~ parts will be expanded. We don't want that.
         if (IS_WINDOWS) {
             return file;
         } else {
             try {
                 return file.getCanonicalFile();
             } catch (IOException e) {
                 throw new RuntimeIOException(e);
             }
         }
     }
 
     /**
      * Return the single element in the specified Collection.
      * <p>
      * If the collection is empty <code>null</null> is return
      * 
      * @param coll
      * @return null or the singleton element in the collection
      * @throws IllegalArgumentException
      *             if the collection has more than one element
      */
     public static <T> T single(Collection<T> coll) {
         switch (coll.size()) {
         case 0:
             return null;
         case 1:
             return coll.iterator().next();
         default:
             throw new IllegalArgumentException("Collection has more than one element");
         }
     }
 
     /**
      * Create a temporary file.
      * <p>
      * This method is identical to
      * {@link java.io.File#createTempFile(String, String)} except it
      * throws a {@link RuntimeIOException}.
      * 
      * @param suffix
      * @return the temporary file
      */
     public static File createTempFile(String suffix) {
         try {
             return File.createTempFile("javahg-", suffix);
         } catch (IOException e) {
             throw new RuntimeIOException(e);
         }
     }
 
     /**
      * Determines whether the specified file is a Symbolic Link rather
      * than an actual file.
      * <p>
      * Will not return true if there is a Symbolic Link anywhere in
      * the path, only if the specific file is.
      * 
      * Note: The implementation is adapted from the similar method in
      * Apache Commons IO
      * 
      * @param file
      *            the file to check
      * @return true if the file is a Symbolic Link
      */
     public static boolean isSymlink(File file) {
         if (IS_WINDOWS) {
             return false;
         }
         try {
             File fileInCanonicalDir = null;
             if (file.getParent() == null) {
                 fileInCanonicalDir = file;
             } else {
                 File canonicalDir = file.getParentFile().getCanonicalFile();
                 fileInCanonicalDir = new File(canonicalDir, file.getName());
             }
 
             return !fileInCanonicalDir.getCanonicalFile().equals(fileInCanonicalDir.getAbsoluteFile());
         } catch (IOException e) {
             throw new RuntimeIOException(e);
         }
     }
 
     /**
      * Convert the specified exception into a RuntimeException
      * 
      * @param e
      * @return the RuntimeException
      */
     public static RuntimeException asRuntime(Throwable e) {
         if (e instanceof RuntimeException) {
             return (RuntimeException) e;
         }
         if (e instanceof ExecutionException) {
             return asRuntime(e.getCause());
         }
         if (e instanceof InvocationTargetException) {
             return asRuntime(e.getCause());
         }
         if (e instanceof IOException) {
             return new RuntimeIOException((IOException) e);
         }
         return new RuntimeException(e);
     }
 
     /**
      * Delete a directory in the system temporary directory
      * (java.io.tmpdir).
      * 
      * @throws IOException
      */
     public static void deleteTempDir(File file) throws IOException {
         file = file.getCanonicalFile();
         String javaTmpDir = new File(System.getProperty("java.io.tmpdir")).getCanonicalPath();
         if (file.getPath().startsWith(javaTmpDir)) {
             deleteRecursive(file);
         } else {
             throw new IllegalArgumentException("Can only delete files in " + javaTmpDir);
         }
     }
 
     private static void deleteRecursive(File file) throws IOException {
         if (file.isDirectory()) {
             File[] files = file.listFiles();
             for (File f : files) {
                 deleteRecursive(f);
             }
         }
 
         // Windows often fails to delete on first attempt, but after a
         // short
         // break the file can be deleted. Wait up to 5 sec.
         // I believe that it is because the cmdserver process (which
         // has been
         // terminated before calling this method)
         // still has a lock on the dir. So we wait for it to actually
         // finish and
         // release lock
         for (int i = 20; !file.delete(); i--) {
             if (i == 0) {
                 throw new IOException("Failed to delete: " + file);
             }
             try {
                 System.err.println("Sleep a bit and try again to delete " + file + "[" + i + "/20]");
                 Thread.sleep(250);
             } catch (InterruptedException e) {
             }
         }
     }
     
     /**
      * Creates a new temporary directory as child of the given parent.
      * 
      * @param parent parent directory
      * @return temporary directory
      */
     private static File createTempDirectory( File parent ) {
         String name = System.currentTimeMillis() + "-";
         for (int i=0; i<100; i++) {
             File directory = new File(parent, name + i);
             if ( ! directory.exists() && directory.mkdirs() ){
                 return directory;
             }
         }
         throw new IllegalStateException("could not create a temp directory at " + parent);
     }
 
     /**
      * Return a File that is created from a resource name found on the
      * classpath. The resource is written into the File the first time
      * it's needed.
      * 
      * @param resourceName
      * @return the File
      * @throws IOException
      */
     public static File resourceAsFile(String resourceName) {
         return resourceAsFile(resourceName, null);
     }
 
     /**
      * Return a File that is created from a resource name found on the
      * classpath. The resource is written into the File the first time
      * it's needed.
      * <p>
      * Patterns of the form %{name} will be replace with the
      * corresponding value from the replacement map.
      * 
      * @param resourceName
      * @parem replacements if null no replacements will be performed
      * @return the File
      * @throws IOException
      */
     public static File resourceAsFile(String resourceName, Map<String, byte[]> replacements) {
         File file = new File(RESOURCES_TEMP_DIR, resourceName);
         if (!file.exists()) {
             file.getParentFile().mkdirs();
             InputStream stream = Utils.class.getResourceAsStream(resourceName);
             try {
                 OutputStream fileOutput = new BufferedOutputStream(new FileOutputStream(file));
                 OutputStream output = fileOutput;
                 if (replacements != null) {
                     output = new PatternReplacingOutputStream(fileOutput, replacements);
                 }
                 ByteStreams.copy(stream, output);
                 output.close();
             } catch (IOException e) {
                 throw new RuntimeIOException(e);
             }
             LOG.info("Copy resource {} to {}", resourceName, file.getAbsolutePath());
         }
         return file;
     }
 
     /**
      * Generate some random bytes that is printable Ascii characters.
      * <p>
      * They will be used in a Mercurial style file. To make it easy to
      * use the bytes in the style file the characters '"' and '\' will
      * not be part of the byte array.
      * 
      * @return
      */
     public static byte[] randomBytes() {
         byte[] bytes = new byte[20];
         new Random().nextBytes(bytes);
         // Make the bytes printable by modulo 64 and add to '"' and
         // use 126 for '\\'
         assert '"' + 64 < 126;
         for (int i = 0; i < bytes.length; i++) {
             int b = '"' + 1 + (bytes[i] & 63);
             if (b == '\\') {
                 b = 126;
             }
             bytes[i] = (byte) b;
         }
         LOG.info("Random bytes generated: {}", new String(bytes));
         return bytes;
     }
 
 	public static String obfuscateLoginData(String line) {
 		String myLine = (line == null ? "" : line);
 		myLine = HTTP_PATTERN.matcher(myLine).replaceAll("http://***@");
 		if (myLine.equals(line)) {
 			myLine = HTTPS_PATTERN.matcher(line).replaceAll("https://***@");
 		}
 		if (myLine.equals(line)) {
 			myLine = SSH_PATTERN.matcher(line).replaceAll("ssh://***@");
 		}
 		if (myLine.equals(line)) {
 			myLine = SVN_PATTERN.matcher(line).replaceAll("svn://***@");
 		}
 		return myLine;
 	}
 }