/*******************************************************************************
 * Copyright (c) 2009 by SAP AG, Walldorf. 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     SAP AG - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.ws.jaxws.testutils.files;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URL;
import java.nio.channels.FileChannel;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;


public class TestFileUtils
{
	// Hide default constructor
	private TestFileUtils()
	{
	};

	/** Get new instance of the FileUtilities object */
	public static TestFileUtils getInstance()
	{
		return new TestFileUtils();
	}

	/**
	 * Utility method. Copies the contents of the source folder to the destination folder.
	 */
	public boolean copyFiles(final File dest, final File src) throws IOException
	{

		if (src.isDirectory())
		{
			dest.mkdirs();
			final String list[] = src.list();

			for (int i = 0; i < list.length; i++)
			{
				final String dest1 = dest.getAbsolutePath() + "\\" + list[i];
				final String src1 = src.getAbsolutePath() + "\\" + list[i];
				copyFiles(new File(dest1), new File(src1));
			}
		} else
		{
			return copy(dest, src);
		}

		return false;
	}

	/**
	 * Utility method for copying a file! - not a directory
	 * 
	 * @param target
	 * @param source
	 * @throws IOException
	 */
	public boolean copy(final File target, final File source) throws IOException
	{
		if (!source.isFile())
			return false;

		final FileChannel sourceChannel = new FileInputStream(source).getChannel();
		final FileChannel targetChannel = new FileInputStream(target).getChannel();
		sourceChannel.transferTo(0, sourceChannel.size(), targetChannel);
		sourceChannel.close();
		targetChannel.close();

		return true;
	}

	/**
	 * 
	 * @param destDir
	 * @param srcRelativePath -
	 *            the relative path of the resource or <code>null</code> if it is in the same package
	 * @param resourceName
	 * @param resourceClass
	 * @return
	 * @throws IOException
	 */
	public File copyResourceToDir(File destDir, InputStream srcStream, String resourceName) throws IOException
	{
		File destFile = new File(destDir.getAbsolutePath(), resourceName);
		copyFile(srcStream, new FileOutputStream(destFile));
		return destFile;
	}
	/**
	 * 
	 * @param destDir
	 * @param srcRelativePath -
	 *            the relative path of the resource or <code>null</code> if it is in the same package
	 * @param srcFileName
	 * @param resourceClass
	 * @return
	 * @throws IOException
	 */
	public File copyResourceToDir(File destDir, String srcRelativePath, String srcFileName, Class<?> resourceClass) throws IOException
	{
		File destFile = new File(destDir.getAbsolutePath(), srcFileName);
		copyFile(createInputStreamForResource(srcRelativePath, srcFileName, resourceClass), new FileOutputStream(destFile));
		return destFile;
	}

	private InputStream createInputStreamForResource(String srcRelativePath, String srcFileName, Class<?> resourceClass)
	{
		return resourceClass.getResourceAsStream(createResourcePath(srcRelativePath) + srcFileName);
	}

	private String createResourcePath(String srcRelativePath)
	{
		return (srcRelativePath == null) ? "" : srcRelativePath + "/";
	}

	/** Closes the streams after completion */
	public void copyFile(InputStream in, OutputStream out) throws IOException
	{
		if (in == null || out == null)
			throw new IllegalArgumentException("Stream not initialized");
		try
		{
			byte[] buf = new byte[1024];
			int len;
			while ((len = in.read(buf)) > 0)
			{
				out.write(buf, 0, len);
			}
		} finally
		{
			in.close();
			out.close();
		}
	}

	/**
	 * Utility method for deleting the contents of a given folder path
	 * 
	 * @param folderPath
	 * @return <code>true</code> if the process was completed successfully.
	 * @throws IOException
	 */
	public boolean deleteFolderAndContents(final String folderPath) throws IOException
	{
		final File path = new File(folderPath);
		return deleteFolderAndContents(path);
	}

	/**
	 * Deletes the specified directory and all its contents including all sub directories.
	 * 
	 * @param tempDir
	 *            the directory that is being deleted.
	 */
	public boolean deleteFolderAndContents(File tempDir)
	{
		boolean status = true;
		if (tempDir != null)
		{
			File[] files = tempDir.listFiles();

			if (files != null)
			{
				for (int i = 0; i < files.length; i++)
				{
					if (files[i].isDirectory())
					{
						status = deleteFolderAndContents(files[i]) && status;
					} else
					{
						status = files[i].delete() && status;
					}
				}
			}
			status = tempDir.delete() && status;
		} else
		{
			status = false;
		}
		return status;
	}

	/**
	 * Extracts the contents of the given input stream file to the given directory.
	 * 
	 * @param istr
	 *            The input stream of the jar file
	 * @param srcFileName
	 *            The name of the archive - where the contents of the input stream will be copied
	 * @param destDir
	 *            The destination directory object
	 * @return <code>true</code> if the process was completed successfully
	 * @throws IOException
	 */
	public boolean unzipArchiveToDir(final InputStream istr, final String srcFileName, final File destDir) throws IOException
	{

		if (!destDir.exists())
			throw new IOException("Directory does not exist");
		if (!destDir.canWrite())
			throw new IOException("Could not write to directory");

		final File sourceFile = new File(destDir, srcFileName);

		final FileOutputStream fos = new FileOutputStream(sourceFile);
		final BufferedOutputStream bufOutStream = new BufferedOutputStream(fos);

		try
		{
			Unzipper.INSTANCE.copyInputStream(istr, bufOutStream);
		} finally
		{
			bufOutStream.close();
			fos.close();
		}

		// check if the archive was copied successfully
		if (!sourceFile.exists())
		{
			throw new FileNotFoundException("Archive could not be found");
		}

		Unzipper.INSTANCE.unzip(sourceFile, destDir, false);

		return true;
	}

	/** Utility method for getting the contents of a file through URL */
	public String readURLResource(URL url) throws IOException
	{
		String readInf = null;
		final InputStream in = url.openStream();

		try
		{
			int inRead = in.read();

			readInf = "";
			while (inRead != -1)
			{
				readInf += String.valueOf((char) inRead);
				inRead = in.read();
			}
		} finally
		{
			in.close();
		}

		return readInf;
	}

	/**
	 * Method for replacing the text occurrence in a file with the provided replacement.
	 * 
	 * @param file
	 * @param find
	 * @param replacement
	 * @return
	 * @throws IOException
	 */
	public boolean replaceContentsInFile(File file, String find, String replacement) throws IOException
	{
		if (!file.exists())
			return false;

		String fileContents = readFileContents(file);

		fileContents = fileContents.replaceAll(find, replacement);

		file.delete();
		file.createNewFile();

		writeContentsToFile(file, fileContents);

		return true;
	}

	/**
	 * Writes the string to the given file.
	 * 
	 * @param file -
	 *            the file to write to
	 * @param fileContents -
	 *            the contents to be written to the file
	 * @throws IOException
	 * @throws FileNotFoundException
	 */
	public void writeContentsToFile(File file, String fileContents) throws IOException, FileNotFoundException
	{

		PrintWriter pout = new PrintWriter(file);

		try
		{
			pout.println(fileContents);
			pout.flush();
		} finally
		{
			pout.close();
		}
	}

	/**
	 * Reads the contents of a file and returns it as String.
	 * 
	 * @param file -
	 *            the file to read from
	 * @return the contents of the file
	 * @throws IOException
	 */
	public String readFileContents(File file) throws IOException
	{
		String readInf = null;
		final InputStream in = new FileInputStream(file);

		try
		{
			int inRead = in.read();

			readInf = "";
			while (inRead != -1)
			{
				readInf += String.valueOf((char) inRead);
				inRead = in.read();
			}
		} catch (IOException e)
		{
			throw e;
		} finally
		{
			in.close();
		}

		return readInf;
	}

	/** @return the resource input stream of the projects archive */
	@SuppressWarnings("unchecked")
	public InputStream getResourceInputStream(final String archiveName, final String projectSourceFolder, Class relativeResourceBaseClass)
	{
		return relativeResourceBaseClass.getResourceAsStream(projectSourceFolder + "/" + archiveName);
	}

	/** Method for handling the unzipping of the test projects */
	public void unzipTestProjects(final InputStream archiveStream, final String archiveName, final File destDir) throws IOException
	{

		if (archiveStream == null)
			throw new IOException("The archive resource stream is not initialized! archive: " + archiveName + " - dir: " + destDir);

		try
		{
			unzipArchiveToDir(archiveStream, archiveName, destDir);
		} finally
		{
			archiveStream.close();
		}
	}

	/**
	 * Unzips the content of <tt>zipFileLocation</tt> into <tt>outFolder</tt>.
	 * 
	 * @param zipFileLocation
	 * @param outFolder
	 * @throws IOException
	 */
	public static void addZippedContent(File zipFileLocation, File outFolder) throws IOException
	{
		FileInputStream fis = new FileInputStream(zipFileLocation);
		addZippedContent(fis, outFolder);
	}

	/**
	 * Unzips the content of <tt>is</tt> into <tt>outFolder</tt>.
	 * 
	 * @param zipFileLocation
	 * @param outFolder
	 * @throws IOException
	 */
	public static void addZippedContent(InputStream is, File outFolder) throws IOException
	{
		ZipInputStream zis = new ZipInputStream(is);
		ZipEntry entry = null;
		while ((entry = zis.getNextEntry()) != null)
		{
			File outFile = new File(outFolder, entry.getName());

			if (entry.isDirectory())
			{
				outFile.mkdirs();
			} else
			{
				OutputStream out = new FileOutputStream(outFile);
				byte[] buff = new byte[2048];
				int read;
				while ((read = zis.read(buff)) > 0)
				{
					out.write(buff, 0, read);
				}
				out.close();
			}

			zis.closeEntry();
		}

		zis.close();
	}

	/**
	 * Deletes directory with its content
	 * 
	 * @param dir
	 */
	public static void deleteDirectory(File dir)
	{
		if (!dir.isDirectory())
		{
			throw new IllegalArgumentException("Not a directory" + dir.getName());
		}

		for (String s : dir.list())
		{
			File f = new File(dir.getAbsolutePath() + File.separator + s);
			if (f.isDirectory())
			{
				deleteDirectory(f);
			} else
			{
				f.delete();
			}
		}

		dir.delete();
	}

	/**
	 * Create a directory named via the pattern System.getProperty("java.io.tmpdir") + File.separator + dirName
	 * 
	 * @param dirName
	 * @return
	 */
	public static File createTempDirectory(String dirName)
	{
		File tempDir = new File(System.getProperty("java.io.tmpdir"), dirName);
		if (tempDir.exists())
		{
			deleteDirectory(tempDir);
		}

		if (!tempDir.mkdir())
		{
			throw new IllegalStateException("Temp direcory " + tempDir.getAbsolutePath() + " could not be created");
		}
		// tempDir.deleteOnExit();

		return tempDir;
	}

	/**
	 * Copy the content of <code>filePath</code> and copies it to temporary file in system temp directory.
	 * 
	 * @param classContext
	 * @param filePath
	 * @return created temporary file
	 * @throws IOException
	 */
	public static File copyToTempLocation(Class<?> classContext, String filePath) throws IOException
	{
		final InputStream is = classContext.getResourceAsStream(filePath);
		final File dir = new File(System.getProperty("java.io.tmpdir"));
		final File tempFile = new File(dir, System.currentTimeMillis() + ".java");
		tempFile.deleteOnExit();

		final FileOutputStream fos = new FileOutputStream(tempFile);
		try
		{
			byte[] buff = new byte[1024];
			for (int cnt = 0; (cnt = is.read(buff)) > -1;)
			{
				fos.write(buff, 0, cnt);
			}
		} finally
		{
			is.close();
			fos.close();
		}

		return tempFile;
	}

	public static void setFileContent(File file, String content) throws IOException
	{
		final FileWriter fw = new FileWriter(file);
		try
		{
			fw.write(content);
		} finally
		{
			fw.close();
		}
	}
}