/* gnu.classpath.tools.IOToolkit
   Copyright (C) 2004 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath 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
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */

package gnu.classpath.tools;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;

import java.util.Set;

/**
 *  Provides various I/O-related helper methods.
 *
 *  @author Julian Scheid
 */
public class IOToolkit
{
   /**
    *  Prevents instantiation.
    */
   private IOToolkit() {}

   /**
    *  Read all binary data from the given InputStream and write it to
    *  the given OutputStream. This method doesn't close either
    *  stream.
    *
    *  @param in  the stream from which to read data
    *  @param out the stream to which to write data
    */
   public static void copyStream(InputStream in, OutputStream out)
      throws IOException
   {
      byte[] buf = new byte[256];
      int nread;

      while ((nread = in.read(buf)) >= 0) {
         out.write(buf, 0, nread);
      }
   }

   /**
    *  Read all character data from the given Reader and write it to
    *  the given Writer. This method doesn't close either stream.
    *
    *  @param in  the Reader from which to read character data
    *  @param out the Writer to which to write character data
    */
   public static void copyStream(Reader in, Writer out)
      throws IOException 
   {
      char[] buf = new char[256];
      int nread;

      while ((nread = in.read(buf)) >= 0) {
         out.write(buf, 0, nread);
      }
   }

   /**
    *  Recursively copy the contents of the input directory to the
    *  output directory. The output directory is created if it doesn't
    *  exist. If the output directory doesn't exist and can't be
    *  created, an IOException is thrown.
    *
    *  @param sourceDir source directory from which to copy files
    *  @param targetDir target directory to which to copy files
    *  @param recursive if true, recursively copy subdirectoryies
    *  @param excludeDirs if non null, must be a Set of String. Each
    *  element from the set specifies the name of a direct
    *  subdirectory of the source directory which should be excluded
    *  from recursive copying.
    */
   public static void copyDirectory(File sourceDir, File targetDir, 
                                    boolean recursive,
                                    Set excludeDirs) 
      throws IOException 
   {
      if (!targetDir.exists() && !targetDir.mkdirs()) {
         throw new IOException("Cannot create directory " + targetDir);
      }

      File[] sourceFiles = sourceDir.listFiles();
      for (int i=0; i<sourceFiles.length; ++i) {
         if (sourceFiles[i].isDirectory()) {
            if (recursive && (null == excludeDirs 
                              || !excludeDirs.contains(sourceFiles[i].getName()))) {
               File targetSubDir = new File(targetDir, 
                                            sourceFiles[i].getName());
               if (targetSubDir.exists() || targetSubDir.mkdir()) {
                  copyDirectory(sourceFiles[i], targetSubDir, recursive, null);
               }
               else {
                  throw new IOException("Cannot create directory " + targetSubDir);
               }
            }
         }
         else {
            copyFile(sourceFiles[i], new File(targetDir, sourceFiles[i].getName()));
         }
      }
   }

   /**
    *  Copy the contents of the input file to the output file. The
    *  output file's parent directory must exist.
    *
    *  @param sourceFile  specifies the file to copy
    *  @param targetFile  specifies the file to create
    */
   public static void copyFile(File sourceFile, File targetFile) 
      throws IOException 
   {
      InputStream in = new FileInputStream(sourceFile);
      OutputStream out = new FileOutputStream(targetFile);
      int nread;
      byte[] buf = new byte[512];
      while ((nread = in.read(buf)) >= 0) {
         out.write(buf, 0, nread);
      }
      in.close();
      out.close();
   }

   /**
    *  Read the (remaining) contents of the given reader into a char
    *  array. This method doesn't close the reader when it is done.
    *
    *  @param reader the Reader to read characters from
    *  @return an array with the contents of the Reader
    */
   public static char[] readFully(Reader reader)
      throws IOException
   {
      StringWriter writer = new StringWriter();
      final int readBufferSize = 256;
      char[] chunk = new char[readBufferSize];
      int nread;
      while ((nread=reader.read(chunk))>=0) {
	 writer.write(chunk,0,nread);
      }
      StringBuffer buffer = writer.getBuffer();
      char[] result = new char[buffer.length()];
      buffer.getChars(0, buffer.length(), result, 0);
      return result;
   }

   public static String getLineFromFile(File file, int line)
      throws IOException
   {
      FileReader reader = new FileReader(file);
      BufferedReader bufferedReader = new BufferedReader(reader);
      while (line > 1) {
         bufferedReader.readLine();
         -- line;
      }
      String result = bufferedReader.readLine();
      reader.close();
      return result;
   }

   public static String getColumnDisplayLine(int column)
   {
      StringBuffer result = new StringBuffer();
      while (column > 0) {
         result.append(' ');
         --column;
      }
      result.append('^');
      return result.toString();
   }

}