/**

  * Copyright 2010, CSIRO Australia.

  *

  * Licensed 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 au.csiro.netcdf.util;

 import java.io.File;

 import java.io.FileFilter;

 import java.io.FileInputStream;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import org.apache.commons.io.filefilter.WildcardFileFilter;

 /**

  * Util - utility class with various helpful tools...

  * 

  * Copyright 2005, CSIRO Australia All rights reserved.

  * 

  * @author James Dempsey on 12/10/2005

  * @version $Revision: 78 $ $Date: 2010-07-24 16:23:13 +1000 (Sat, 24 Jul 2010) $

  */

 public class Util

 {

     /**

      * Check if a string contains a valid number

      * 

      * @param number The numeric string to be checked

      * @return True if the number is valid

      */

     public static boolean validateNumber(String number)

     {

         try

         {

             Integer.parseInt(number);

             return true;

         }

         catch (NumberFormatException e)

         {

             return false;

         }

     }

     /**

      * Check if a file exists for a given file pathname.

      * 

      * @param filePath

      *            a pathname string.

      * @return True if the file exists.

      */

     public static boolean fileExists(String filePath)

     {

         if(filePath == null || filePath.isEmpty())

         {

             return false;

         }

         File file = new File(filePath);

         return file.exists();

     }

     /**

      * Counts the number of lines in a file.

      * 

      * @param filePath

      *            the name of the file to open.

      * @return The number of lines in the file

      */

     public static int fastFileLineCounter(String filePath)

     {

         if (filePath == null || filePath.isEmpty())

         {

             throw new IllegalArgumentException("missing filename!");

         }

         try

         {

             FileInputStream fis = new FileInputStream(filePath);

             final int bufferSize = 2048;

             byte buf[] = new byte[bufferSize];

             int cnt = 0;

             int n;

             while ((n = fis.read(buf)) != -1)

             {

                 for (int i = 0; i < n; i++)

                 {

                     if (buf[i] == '\n')

                     {

                         cnt++;

                     }

                 }

             }

             fis.close();

             return cnt;

         }

         catch (IOException e)

         {

             System.err.println(e);

             return -1;

         }

     }

     /**

      * Creates a new <code>File</code> instance from a given pathname string, if the given pathname string exists.

      * 

      * @param outputFilenameArg

      *            a pathname string.

      * @return a {@link File} instance.

      * @throws IllegalArgumentException

      *             thrown if the file can not be found.

      */

     public static File getExistingFile(String outputFilenameArg) throws IllegalArgumentException

     {

         if (!fileExists(outputFilenameArg))

         {

             throw new IllegalArgumentException("The following file must exist: " + outputFilenameArg);

         }

         return new File(outputFilenameArg);

     }

     /**

      * Method to get the file extension as a String for the supplied file name.

      * If there is no extension it will return <tt>null</tt>.

      * @param fileName - file name to get extension from

      * @return String - valid file extension or <tt>null</tt>.

      */

     public static String getFileExtension(String fileName)

     {

         String fileExtension = null;

         int dotPos = fileName.lastIndexOf(".");

         if (dotPos > 0)

         {

             fileExtension = fileName.substring(dotPos);

         }

         return fileExtension;

     }

     /**

      * Splits a comma separated <code>String</code> into a <code>List</code> of tokens.

      * 

      * @param commaSeparatedString

      *            a comma separated <code>String</code>

      * @return a list of tokens, or an empty list if the <code>String</code> is <tt>null</tt> or empty.

      */

     public static List<String> tokeniseCommaSeparatedString(String commaSeparatedString)

     {

         if (commaSeparatedString == null || commaSeparatedString.isEmpty())

         {

             return new ArrayList<String>();

         }

         String[] tokens = splitOnNonBackslashedCharacter(commaSeparatedString, ","); // split on all ',' characters that

                                                                                      // are not delimited by a backslash

         return Arrays.asList(tokens);

     }

     /**

      * Splits the given string around matches of the given non-backslashed regular expression.

      * 

      * @param text

      *            the string to be split.

      * @param regex

      *            the delimiting regular expression.

      * @return the array of strings computed by splitting this string around matches of the given non-backslashed

      *         regular expression.

      */

     public static String[] splitOnNonBackslashedCharacter(String text, String regex)

     {

         if (text == null)

         {

             text = "";

         }

         int last_match = 0;

         List<String> splitted = new LinkedList<String>();

         // matches any regex character that does not have a backslash in front of it.

         Pattern pattern = Pattern.compile("[^\\\\]" + regex);

         Matcher m = pattern.matcher(text);

         while (m.find())

         {

             splitted.add(text.substring(last_match, m.start() + 1)); // +1 is used to include the character before regex

                                                                      // which would otherwise be stripped. 

             last_match = m.end();

         }

         splitted.add(text.substring(last_match));

         return splitted.toArray(new String[splitted.size()]);

     }

     /**

      * Retrieve a list of the absolute path names of the files in a folder that match a pattern. The pattern uses the

      * characters '?' and '*' to represent a single or multiple wildcard characters. This is the same as often found on

      * Dos/Unix command lines. 

      * 

      * @param foldername

      *            The name of the folder to be searched or the single file if no pattern

      * @param pattern

      *            The pattern to be matched against. The wildcard characters '?' and '*' are supported.

      * @return A list of the absolute names of the matching files

      */

     public static List<String> getListOfTargetFiles(String foldername, String pattern)

     {

         String cleanPat = pattern.replaceAll("\\\\\\*", "*").replaceAll("\\\\\\?", "?");

         List<String> fileNameList = new ArrayList<String>();

         if (pattern == null || pattern.length() == 0)

         {

             fileNameList.add(foldername);

             return fileNameList;

         }

         File dir = new File(foldername);

         if (!dir.exists() || !dir.isDirectory() || !dir.canRead())

         {

             return Collections.emptyList();

         }

         FileFilter patternFilter = new WildcardFileFilter(cleanPat);

         File[] files = dir.listFiles(patternFilter);

         for (int i = 0; i < files.length; i++)

         {

             fileNameList.add(files[i].getAbsolutePath());

         }

         return fileNameList;

     }

 }