/*
    * Created on 24-oct.-2004 */
   package DTDDoc;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.FileOutputStream;
   import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Enumeration;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.StringTokenizer;
  
  
  /** A class that gather some useful tools.
   *
   * @author expertmb (http://www.experts-exchange.com/M_237837.html)
   * @author stefan schampailler_at_skynet_dot_be */
  
  
  public class Tools {
  
      /** Copy the whole content of a stream into another.
       *
       * @param source Input stream.
       * @param destination Output stream.
       * @throws IOException If anything goes wrong.
       */
  
      private static void streamCopy( InputStream source, OutputStream destination)
          throws IOException {
  
          if( source == null)
              throw new IOException( "Trying to input from a null stream");
          else if( destination == null)
              throw new IOException( "Trying to output to a null stream");
  
          byte[] buffer = new byte[16384];
  
          while (true) {
              int bytes_read = source.read(buffer);
              if (bytes_read > 0)
                  destination.write(buffer, 0, bytes_read);
              else
                  break;
          }
      }
  
      /** Copy the content of stream into another and close both of them when
       * done.
       *
       * @param source Source stream.
       * @param destination Destination stream.
       * @throws IOException If anything goes wrong.
       */
  
      private static void streamCopyAndClose( InputStream source,
              OutputStream destination) throws IOException {
  
          IOException exception = null;
  
          try {
              streamCopy( source, destination);
          } catch( IOException ex) {
              exception = ex;
          }
  
          if (source != null)
              try {
                  source.close();
              } catch (IOException e) {
                  if( exception != null)
                      exception = new IOException( exception.getMessage()+" (and I was not able to close this stream)");
              }
  
          if (destination != null)
              try {
                  destination.close();
              } catch (IOException e) {
                  if( exception != null)
                      exception = new IOException( exception.getMessage()+" (and I was not able to close this stream)");
              }
  
          if( exception != null)
              throw exception;
      }
  
      /** Open a file so that it's ready to be written in. This takes as
       * much care as possible to ensure the operation is possible.
       *
       * @param destinationFile File to open.
      * @return A stream to write (overwrite) into the file.
      * @throws FileCopyException
      */
     private static OutputStream openToWrite( File destinationFile) throws FileCopyException {
 
         // If the destination exists, make sure it is a writeable file
         // and ask before overwriting it.  If the destination doesn't
         // exist, make sure the directory exists and is writeable.
         if (destinationFile.exists()) {
             if (destinationFile.isFile()) {
                 if (!destinationFile.canWrite())
                     throw new FileCopyException("Can't write into "
                             + destinationFile);
                 /*
                  System.out.print("File " + dest_name
                  + " already exists.  Overwrite? (Y/N): ");
                  System.out.flush();
 
                  DataInputStream in = new DataInputStream(System.in);
                  String response = in.readLine();
                  if (!response.equals("Y") && !response.equals("y"))
                  throw new FileCopyException("FileCopy: copy cancelled."); */
             } else
                 throw new FileCopyException(destinationFile + " is not a file.");
         } else {
             File parentdir = parent(destinationFile);
             if (!parentdir.exists())
                 throw new FileCopyException( "Destination directory " +
                         "doesn't exist for " + destinationFile);
             if (!parentdir.canWrite())
                 throw new FileCopyException( "Destination directory " +
                         "for " + destinationFile + " is unwritable.");
         }
 
         // If we've gotten this far, then everything is okay; we can
         // copy the file.
 
         try {
             return new FileOutputStream(destinationFile);
         } catch( FileNotFoundException ex) {
             throw new FileCopyException("Can't write to "+destinationFile+
                     " because "+ex.getLocalizedMessage());
         }
     }
 
     /** Copies a resource file (in-jar) to a given destination.
      *
      * @param name Full path to the resource (relative to the jar though).
      * @param destinationFile Where to copy the file.
      * @throws FileCopyException
      */
 
     public static void copyFromResource( String name, File destinationFile)
         throws FileCopyException {
 
         //System.out.println("Copying "+name);
 
         InputStream source = Tools.class.getResourceAsStream( name);
 
         if( source == null) {
             String error = "Unable to find "+name+".";
             if( !name.startsWith("/"))
                 error += " Please note that name doesn't start with a slash '/'.";
 
             throw new FileCopyException( error);
         }
 
         OutputStream destination = openToWrite( destinationFile);
 
         try {
             streamCopyAndClose( source, destination);
         } catch( IOException ex) {
             throw new FileCopyException("Unable to copy "+name+" into "+destinationFile);
         }
     }
 
     /** Copy one file into antoher. If the destination file already exists, it
      * is overwritten.
      *
      * @param sourceFile Source path.
      * @param destinationFile Destination path.
      * @throws IOException
      */
 
     public static void copy( File sourceFile, File destinationFile)
         throws IOException {
 
         // First make sure the specified source file
         // exists, is a file, and is readable.
         if (!sourceFile.exists() || !sourceFile.isFile())
             throw new FileCopyException(
                     "Can't find "+sourceFile);
 
         if (!sourceFile.canRead())
             throw new FileCopyException("File " + sourceFile +
             " is unreadable");
 
         InputStream source = new FileInputStream( sourceFile);
         OutputStream destination = openToWrite( destinationFile);
 
         try {
             streamCopyAndClose( source, destination);
         } catch( IOException ex) {
             throw new FileCopyException("Unable to copy "+sourceFile+" into "+destinationFile);
         }
     }
 
 
     /** Get the parent of a given path.
      *
      * @param f The path.
      * @return The path's parent. Null if there's no such parent.
      */
 
     public static File parent(File f) {
             String dirname = f.getParent();
             if (dirname == null) {
                 if (f.isAbsolute())
                     return new File(File.separator);
                 else
                     return new File(System.getProperty("user.dir"));
             }
             return new File(dirname);
         }
 
     /** Returns a sorted copy of a given collection.
      *
      * @param collection Colelction to sort.
      * @param comparator Comparator to use while sorting.
      * @return A sorted copy of the collection.
      */
 
     static public Collection sort( Collection collection, Comparator comparator) {
         List l = new ArrayList( collection);
         Collections.sort( l, comparator);
         return l;
     }
 
     /** Transform a list into an array. The list is a string of texts
      *  separated by a character called "separator".
      *  @param s The list
      *  @param separator the separator.
      *  @return An array containing all the elements of the list. Null
      *      if the list is empty. */
 
     public static String[] listToArray( String s, String separator) {
         if( s == null) return null;
 
         List l = new ArrayList();
         StringTokenizer st = new StringTokenizer( s, separator, false);
 
         while( st.hasMoreTokens()) {
             l.add( st.nextToken());
         }
 
         if( l.size() <= 0) return null;
 
         return (String[])l.toArray(new String[l.size()]);
 
     }
 
 
     public static String join( String[] array, String separator) {
         int len = array.length;
         StringBuffer buff = new StringBuffer();
         for (int i = 0; i < len; i++) {
             if (i > 0) {
                 buff.append(separator);
             }
             buff.append(array[i]);
         }
         return buff.toString();
     }
 
     /** Escape all non-ASCII character in a UNICODE string.
      * The "escaping convention" is the one of HTML : &amp;#xxxx;.
      *
      * <p>Additionally, this function can escape the single quote character for
      * Javascript strings.</p>
      *
      *
      * @param s String to escape. If null, nothing is done.
      * @param javascript If true, escapes the single quote character into
      *     \' so that it can appear in a single quote delimited Javascript
      *     string.
      * @return The escaped version of the string. If the parameter is null,
      *     returns null.
      */
 
     public static String escapeHTMLUnicode( String s, boolean javascript) {
 
         // MJK 8/26/2004 Made this public static so it can be used from
         // ElementTreeBuilder.
         // SC 20/10/2004 Merged the javascript capability for the
         // ElementTreeBuidler as well
 
         if( s != null) {
 
             StringBuffer out = new StringBuffer(s.length()*2);
 
             for (int j = 0; j < s.length(); j++) {
                 char c = s.charAt(j);
 
                 if (javascript && c == '\'')
                     out.append( "\\'");
                 else if( (int) c < 128) // ASCII char ?
                     // Yes, leave it unchanged
                     out.append( c);
                 else
                     // No, escape it to preserve encoding
                     out.append("&#").append((int) c).append(';');
             }
 
             return out.toString();
 
         } else
             return null;
     }
 
     public static List enumerationToList( Enumeration enumeration) {
 
         if( enumeration == null)
             return null;
 
         List c = new LinkedList();
 
         while( enumeration.hasMoreElements())
             c.add( enumeration.nextElement());
 
         return c;
     }
 
     /** Extract the file name out of a full path. For example,
      *  for "/alpha/bravo/zulu", this function will return "zulu".
      *
      *  @param path The full path.
      *  @return The file name part of the path. */
 
     public static String getFilename(String path) {
 
         // Warning ! lastIndexOf can return -1 !!!
         int li = path.lastIndexOf(File.separator) + 1;
 
         return path.substring(li);
     }
 
     /** Will create the directories present in the path of a file.
      *  @param f The file to get the path from. */
 
     public static void makeFileDir(File f) throws IOException {
         // FIXME Move this in a supporting class
         String c = f.getCanonicalPath();
         File dir = new File(c.substring(0, c.lastIndexOf(File.separator)));
         dir.mkdirs();
     }
 
     /*
     public static File createBackup( File source) throws IOException {
         File backup = File.createTempFile( "PFBackup_", ".back",
                 parent( source));
 
         copy( source, backup);
         return backup;
     } */
 
 
     public final static List HTML_TAGS;
     static {
         List html = Arrays.asList(new String[] {
             "script", "noscript", "iframe", "div", "p",
             "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol",
             "menu", "dir", "li", "dl", "dt", "dd", "address", "hr",
             "pre", "blockquote", "center", "ins", "del", "a", "span",
             "bdo", "br", "em", "strong", "dfn", "code", "samp", "kbd", "var", "cite",
             "abbr", "acronym", "q", "sub", "sup", "tt", "i", "b", "big", "small",
             "u", "s", "strike", "basefont", "font", "object", "param", "applet",
             "img", "map", "area", "form", "label", "input", "select", "optgroup",
             "option", "textarea", "fieldset", "legend", "button", "isindex",
             "table", "caption", "thead", "tfoot", "tbody", "colgroup", "col",
             "tr", "th", "td"
         });
         Collections.sort(html);
         HTML_TAGS = Collections.unmodifiableList(html);
     }
 
     public static boolean startsWithHtmlTag(String txt) {
         // an HTML tag starts with either < or </
         if (txt.startsWith("</")) {
             txt = txt.substring(2);
         } else if (txt.startsWith("<")) {
             txt = txt.substring(1);
         } else {
             return false;
         }
 
         // the tag name ends at the first space or >
         int idx = txt.indexOf(' ');
         if (idx > 0) {
             txt = txt.substring(0, idx);
         }
         idx = txt.indexOf('>');
         if (idx > 0) {
             txt = txt.substring(0, idx);
         }
 
         String tag = txt.toLowerCase();
         return (Collections.binarySearch(HTML_TAGS, tag) >= 0);
     }
 
     public static String replace(String src, String token, String with) {
         int index = src.indexOf(token);
         if (index < 0) {
             return src;
         }
         StringBuffer buffer = new StringBuffer();
         int prev = 0;
         while (index >= 0) {
             buffer.append(src.substring(prev, index));
             buffer.append(with);
             prev = index + token.length();
             index = src.indexOf(token, prev);
         }
         buffer.append(src.substring(prev));
         return buffer.toString();
     }
 }