// Copyright (c) 2003-present, Jodd Team (http://jodd.org)
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

package jodd.io;

import jodd.core.JoddCore;
import jodd.util.StringPool;
import jodd.util.StringUtil;
import jodd.util.SystemUtil;
import jodd.util.URLDecoder;

import java.io.BufferedInputStream;
import java.io.BufferedWriter;
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.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.FileFilter;
import java.io.Writer;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.ArrayList;

import static jodd.core.JoddCore.fileUtilParams;

/**
 * File utilities.
 */
public class FileUtil {

	private static final String MSG_NOT_A_DIRECTORY = "Not a directory: ";
	private static final String MSG_CANT_CREATE = "Can't create: ";
	private static final String MSG_NOT_FOUND = "Not found: ";
	private static final String MSG_NOT_A_FILE = "Not a file: ";
	private static final String MSG_ALREADY_EXISTS = "Already exists: ";
	private static final String MSG_UNABLE_TO_DELETE = "Unable to delete: ";

	/**
	 * Simple factory for <code>File</code> objects.
	 */
	private static File file(String fileName) {
		return new File(fileName);
	}

	/**
	 * Simple factory for <code>File</code> objects.
	 */
	private static File file(File parent, String fileName) {
		return new File(parent, fileName);
	}

	// ---------------------------------------------------------------- misc shortcuts

	/**
	 * Checks if two files points to the same file.
	 */
	public static boolean equals(String file1, String file2) {
		return equals(file(file1), file(file2));
	}

	/**
	 * Checks if two files points to the same file.
	 */
	public static boolean equals(File file1, File file2) {
		try {
			file1 = file1.getCanonicalFile();
			file2 = file2.getCanonicalFile();
		} catch (IOException ignore) {
			return false;
		}
		return file1.equals(file2);
	}

	/**
	 * Converts file URLs to file. Ignores other schemes and returns <code>null</code>.
	 */
	public static File toFile(URL url) {
		String fileName = toFileName(url);
		if (fileName == null) {
			return null;
		}
		return file(fileName);
	}

	/**
	 * Converts file to URL in a correct way.
	 * Returns <code>null</code> in case of error.
	 */
	public static URL toURL(File file) throws MalformedURLException {
		return file.toURI().toURL();
	}

	/**
	 * Converts file URLs to file name. Accepts only URLs with 'file' protocol.
	 * Otherwise, for other schemes returns <code>null</code>.
	 */
	public static String toFileName(URL url) {
		if ((url == null) || !(url.getProtocol().equals("file"))) {
			return null;
		}
		String filename = url.getFile().replace('/', File.separatorChar);

		return URLDecoder.decode(filename, JoddCore.encoding);
	}

	/**
	 * Returns a file of either a folder or a containing archive.
	 */
	public static File toContainerFile(URL url) {
		String protocol = url.getProtocol();
		if (protocol.equals("file")) {
			return toFile(url);
		}

		String path = url.getPath();

		return new File(URI.create(
				path.substring(0, path.lastIndexOf("!/"))));
	}

	/**
	 * Returns <code>true</code> if file exists.
	 */
	public static boolean isExistingFile(File file) {
		if (file == null) {
			return false;
		}
		return file.exists() && file.isFile();
	}

	/**
	 * Returns <code>true</code> if folder exists.
	 */
	public static boolean isExistingFolder(File folder) {
		if (folder == null) {
			return false;
		}
		return folder.exists() && folder.isDirectory();
	}

	// ---------------------------------------------------------------- mkdirs

	/**
	 * Creates all folders at once.
	 * @see #mkdirs(java.io.File)
	 */
	public static void mkdirs(String dirs) throws IOException {
		mkdirs(file(dirs));
	}
	/**
	 * Creates all folders at once.
	 */
	public static void mkdirs(File dirs) throws IOException {
		if (dirs.exists()) {
			if (!dirs.isDirectory()) {
				throw new IOException(MSG_NOT_A_DIRECTORY + dirs);
			}
			return;
		}
		if (!dirs.mkdirs()) {
			throw new IOException(MSG_CANT_CREATE + dirs);
		}
	}

	/**
	 * Creates single folder.
	 * @see #mkdir(java.io.File)
	 */
	public static void mkdir(String dir) throws IOException {
		mkdir(file(dir));
	}
	/**
	 * Creates single folders.
	 */
	public static void mkdir(File dir) throws IOException {
		if (dir.exists()) {
			if (!dir.isDirectory()) {
				throw new IOException(MSG_NOT_A_DIRECTORY + dir);
			}
			return;
		}
		if (!dir.mkdir()) {
			throw new IOException(MSG_CANT_CREATE + dir);
		}
	}

	// ---------------------------------------------------------------- touch

	/**
	 * @see #touch(java.io.File)
	 */
	public static void touch(String file) throws IOException {
		touch(file(file));
	}
	/**
	 * Implements the Unix "touch" utility. It creates a new file
	 * with size 0 or, if the file exists already, it is opened and
	 * closed without modifying it, but updating the file date and time.
	 */
	public static void touch(File file) throws IOException {
		if (!file.exists()) {
			StreamUtil.close(new FileOutputStream(file));
		}
		file.setLastModified(System.currentTimeMillis());
	}


	// ---------------------------------------------------------------- params

	/**
	 * Creates new {@link FileUtilParams} instance by cloning current default params.
	 */
	public static FileUtilParams cloneParams() {
		try {
			return fileUtilParams.clone();
		} catch (CloneNotSupportedException ignore) {
			return null;
		}
	}

	/**
	 * Creates new {@link FileUtilParams} instance with default values.
	 */
	public static FileUtilParams params() {
		return new FileUtilParams();
	}

	// ---------------------------------------------------------------- copy file to file

	/**
	 * @see #copyFile(java.io.File, java.io.File, FileUtilParams)
	 */
	public static void copyFile(String src, String dest) throws IOException {
		copyFile(file(src), file(dest), fileUtilParams);
	}
	/**
	 * @see #copyFile(java.io.File, java.io.File, FileUtilParams)
	 */
	public static void copyFile(String src, String dest, FileUtilParams params) throws IOException {
		copyFile(file(src), file(dest), params);
	}
	/**
	 * @see #copyFile(java.io.File, java.io.File, FileUtilParams)
	 */
	public static void copyFile(File src, File dest) throws IOException {
		copyFile(src, dest, fileUtilParams);
	}

	/**
	 * Copies a file to another file with specified {@link FileUtilParams copy params}.
	 */
	public static void copyFile(File src, File dest, FileUtilParams params) throws IOException {
		checkFileCopy(src, dest, params);
		doCopyFile(src, dest, params);
	}

	private static void checkFileCopy(File src, File dest, FileUtilParams params) throws IOException {
		if (!src.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + src);
		}
		if (!src.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + src);
		}
		if (equals(src, dest)) {
			throw new IOException("Files '" + src + "' and '" + dest + "' are equal");
		}

		File destParent = dest.getParentFile();
		if (destParent != null && !destParent.exists()) {
			if (!params.createDirs) {
				throw new IOException(MSG_NOT_FOUND + destParent);
			}
			if (!destParent.mkdirs()) {
				throw new IOException(MSG_CANT_CREATE + destParent);
			}
		}
	}

	/**
	 * Internal file copy when most of the pre-checking has passed.
	 */
	private static void doCopyFile(File src, File dest, FileUtilParams params) throws IOException {
		if (dest.exists()) {
			if (dest.isDirectory()) {
				throw new IOException("Destination '" + dest + "' is a directory");
			}
			if (!params.overwrite) {
				throw new IOException(MSG_ALREADY_EXISTS + dest);
			}
		}

		// do copy file
		FileInputStream input = new FileInputStream(src);
		try {
			FileOutputStream output = new FileOutputStream(dest);
			try {
				StreamUtil.copy(input, output);
			} finally {
				StreamUtil.close(output);
			}
		} finally {
			StreamUtil.close(input);
		}

		// done

		if (src.length() != dest.length()) {
			throw new IOException("Copy file failed of '" + src + "' to '" + dest + "' due to different sizes");
		}
		if (params.preserveDate) {
			dest.setLastModified(src.lastModified());
		}
	}

	// ---------------------------------------------------------------- copy file to directory

	/**
	 * @see #copyFileToDir(java.io.File, java.io.File, FileUtilParams)
	 */
	public static File copyFileToDir(String src, String destDir) throws IOException {
		return copyFileToDir(file(src), file(destDir), fileUtilParams);
	}
	/**
	 * @see #copyFileToDir(java.io.File, java.io.File, FileUtilParams)
	 */
	public static File copyFileToDir(String src, String destDir, FileUtilParams params) throws IOException {
		return copyFileToDir(file(src), file(destDir), params);
	}
	/**
	 * @see #copyFileToDir(java.io.File, java.io.File, FileUtilParams)
	 */
	public static File copyFileToDir(File src, File destDir) throws IOException {
		return copyFileToDir(src, destDir, fileUtilParams);
	}
	/**
	 * Copies a file to folder with specified copy params and returns copied destination.
	 */
	public static File copyFileToDir(File src, File destDir, FileUtilParams params) throws IOException {
		if (destDir.exists() && !destDir.isDirectory()) {
			throw new IOException(MSG_NOT_A_DIRECTORY + destDir);
		}
		File dest = file(destDir, src.getName());
		copyFile(src, dest, params);
		return dest;
	}


	// ---------------------------------------------------------------- copy dir


	public static void copyDir(String srcDir, String destDir) throws IOException {
		copyDir(file(srcDir), file(destDir), fileUtilParams);
	}

	public static void copyDir(String srcDir, String destDir, FileUtilParams params) throws IOException {
		copyDir(file(srcDir), file(destDir), params);
	}

	public static void copyDir(File srcDir, File destDir) throws IOException {
		copyDir(srcDir, destDir, fileUtilParams);
	}

	/**
	 * Copies directory with specified copy params.
	 */
	public static void copyDir(File srcDir, File destDir, FileUtilParams params) throws IOException {
		checkDirCopy(srcDir, destDir);
		doCopyDirectory(srcDir, destDir, params);
	}

	private static void checkDirCopy(File srcDir, File destDir) throws IOException {
		if (!srcDir.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + srcDir);
		}
		if (!srcDir.isDirectory()) {
			throw new IOException(MSG_NOT_A_DIRECTORY + srcDir);
		}
		if (equals(srcDir, destDir)) {
			throw new IOException("Source '" + srcDir + "' and destination '" + destDir + "' are equal");
		}
	}

	private static void doCopyDirectory(File srcDir, File destDir, FileUtilParams params) throws IOException {
		if (destDir.exists()) {
			if (!destDir.isDirectory()) {
				throw new IOException(MSG_NOT_A_DIRECTORY + destDir);
			}
		} else {
			if (!params.createDirs) {
				throw new IOException(MSG_NOT_FOUND + destDir);
			}
			if (!destDir.mkdirs()) {
				throw new IOException(MSG_CANT_CREATE + destDir);
			}
			if (params.preserveDate) {
				destDir.setLastModified(srcDir.lastModified());
			}
		}

		File[] files = srcDir.listFiles();
		if (files == null) {
			throw new IOException("Failed to list contents of: " + srcDir);
		}

		IOException exception = null;
		for (File file : files) {
			File destFile = file(destDir, file.getName());
			try {
				if (file.isDirectory()) {
					if (params.recursive) {
						doCopyDirectory(file, destFile, params);
					}
				} else {
					doCopyFile(file, destFile, params);
				}
			} catch (IOException ioex) {
				if (params.continueOnError) {
					exception = ioex;
					continue;
				}
				throw ioex;
			}
		}

		if (exception != null) {
			throw exception;
		}
	}



	// ---------------------------------------------------------------- move file

	public static File moveFile(String src, String dest) throws IOException {
		return moveFile(file(src), file(dest), fileUtilParams);
	}

	public static File moveFile(String src, String dest, FileUtilParams params) throws IOException {
		return moveFile(file(src), file(dest), params);
	}

	public static File moveFile(File src, File dest) throws IOException {
		return moveFile(src, dest, fileUtilParams);
	}

	public static File moveFile(File src, File dest, FileUtilParams params) throws IOException {
		checkFileCopy(src, dest, params);
		doMoveFile(src, dest, params);
		return dest;
	}

	private static void doMoveFile(File src, File dest, FileUtilParams params) throws IOException {
		if (dest.exists()) {
			if (!dest.isFile()) {
				throw new IOException(MSG_NOT_A_FILE + dest);
			}
			if (!params.overwrite) {
				throw new IOException(MSG_ALREADY_EXISTS + dest);
			}
			dest.delete();
		}

		final boolean rename = src.renameTo(dest);
		if (!rename) {
			doCopyFile(src, dest, params);
			src.delete();
		}
	}

	// ---------------------------------------------------------------- move file to dir


	public static File moveFileToDir(String src, String destDir) throws IOException {
		return moveFileToDir(file(src), file(destDir), fileUtilParams);
	}
	public static File moveFileToDir(String src, String destDir, FileUtilParams params) throws IOException {
		return moveFileToDir(file(src), file(destDir), params);
	}

	public static File moveFileToDir(File src, File destDir) throws IOException {
		return moveFileToDir(src, destDir, fileUtilParams);
	}
	public static File moveFileToDir(File src, File destDir, FileUtilParams params) throws IOException {
		if (destDir.exists() && !destDir.isDirectory()) {
			throw new IOException(MSG_NOT_A_DIRECTORY + destDir);
		}
		return moveFile(src, file(destDir, src.getName()), params);
	}


	// ---------------------------------------------------------------- move dir

	public static File moveDir(String srcDir, String destDir) throws IOException {
		return moveDir(file(srcDir), file(destDir));
	}
	public static File moveDir(File srcDir, File destDir) throws IOException {
		checkDirCopy(srcDir, destDir);
		doMoveDirectory(srcDir, destDir);
		return destDir;
	}

	private static void doMoveDirectory(File src, File dest) throws IOException {
		if (dest.exists()) {
			if (!dest.isDirectory()) {
				throw new IOException(MSG_NOT_A_DIRECTORY + dest);
			}
			dest = file(dest, dest.getName());
			dest.mkdir();
		}

		final boolean rename = src.renameTo(dest);
		if (!rename) {
			doCopyDirectory(src, dest, params());
			deleteDir(src);
		}
	}

	// ---------------------------------------------------------------- delete file

	public static void deleteFile(String dest) throws IOException {
		deleteFile(file(dest));
	}

	public static void deleteFile(File dest) throws IOException {
		if (!dest.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + dest);
		}
		if (!dest.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + dest);
		}
		if (!dest.delete()) {
			throw new IOException(MSG_UNABLE_TO_DELETE + dest);
		}
	}


	// ---------------------------------------------------------------- delete dir

	public static void deleteDir(String dest) throws IOException {
		deleteDir(file(dest), fileUtilParams);
	}
	public static void deleteDir(String dest, FileUtilParams params) throws IOException {
		deleteDir(file(dest), params);
	}
	public static void deleteDir(File dest) throws IOException {
		deleteDir(dest, fileUtilParams);
	}
	/**
	 * Deletes a directory.
	 */
	public static void deleteDir(File dest, FileUtilParams params) throws IOException {
		cleanDir(dest, params);
		if (!dest.delete()) {
			throw new IOException(MSG_UNABLE_TO_DELETE + dest);
		}
	}



	public static void cleanDir(String dest) throws IOException {
		cleanDir(file(dest), fileUtilParams);
	}
	public static void cleanDir(String dest, FileUtilParams params) throws IOException {
		cleanDir(file(dest), params);
	}
	public static void cleanDir(File dest) throws IOException {
		cleanDir(dest, fileUtilParams);
	}

	/**
	 * Cleans a directory without deleting it.
	 */
	public static void cleanDir(File dest, FileUtilParams params) throws IOException {
		if (!dest.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + dest);
		}

		if (!dest.isDirectory()) {
			throw new IOException(MSG_NOT_A_DIRECTORY + dest);
		}

		File[] files = dest.listFiles();
		if (files == null) {
			throw new IOException("Failed to list contents of: " + dest);
		}

		IOException exception = null;
		for (File file : files) {
			try {
				if (file.isDirectory()) {
					if (params.recursive) {
						deleteDir(file, params);
					}
				} else {
					file.delete();
				}
			} catch (IOException ioex) {
				if (params.continueOnError) {
					exception = ioex;
					continue;
				}
				throw ioex;
			}
		}

		if (exception != null) {
			throw exception;
		}
	}

	// ---------------------------------------------------------------- read/write chars

	public static char[] readUTFChars(String fileName) throws IOException {
		return readUTFChars(file(fileName));
	}
	/**
	 * Reads UTF file content as char array.
	 * @see UnicodeInputStream
	 */
	public static char[] readUTFChars(File file) throws IOException {
		if (!file.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + file);
		}
		if (!file.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + file);
		}
		long len = file.length();
		if (len >= Integer.MAX_VALUE) {
			len = Integer.MAX_VALUE;
		}
		UnicodeInputStream in = null;
		try {
			in = new UnicodeInputStream(new FileInputStream(file), null);
			FastCharArrayWriter fastCharArrayWriter = new FastCharArrayWriter((int) len);
			String encoding = in.getDetectedEncoding();
			if (encoding == null) {
				encoding = StringPool.UTF_8;
			}
			StreamUtil.copy(in, fastCharArrayWriter, encoding);
			return fastCharArrayWriter.toCharArray();
		} finally {
			StreamUtil.close(in);
		}
	}

	public static char[] readChars(String fileName) throws IOException {
		return readChars(file(fileName), fileUtilParams.encoding);
	}

	public static char[] readChars(File file) throws IOException {
		return readChars(file, fileUtilParams.encoding);
	}

	public static char[] readChars(String fileName, String encoding) throws IOException {
		return readChars(file(fileName), encoding);
	}

	/**
	 * Reads file content as char array.
	 */
	public static char[] readChars(File file, String encoding) throws IOException {
		if (!file.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + file);
		}
		if (!file.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + file);
		}
		long len = file.length();
		if (len >= Integer.MAX_VALUE) {
			len = Integer.MAX_VALUE;
		}

		InputStream in = null;
		try {
			in = new FileInputStream(file);
			if (encoding.startsWith("UTF")) {
				in = new UnicodeInputStream(in, encoding);
			}
			FastCharArrayWriter fastCharArrayWriter = new FastCharArrayWriter((int) len);
			StreamUtil.copy(in, fastCharArrayWriter, encoding);
			return fastCharArrayWriter.toCharArray();
		} finally {
			StreamUtil.close(in);
		}
	}


	public static void writeChars(File dest, char[] data) throws IOException {
		outChars(dest, data, JoddCore.encoding, false);
	}
	public static void writeChars(String dest, char[] data) throws IOException {
		outChars(file(dest), data, JoddCore.encoding, false);
	}

	public static void writeChars(File dest, char[] data, String encoding) throws IOException {
		outChars(dest, data, encoding, false);
	}
	public static void writeChars(String dest, char[] data, String encoding) throws IOException {
		outChars(file(dest), data, encoding, false);
	}
	
	protected static void outChars(File dest, char[] data, String encoding, boolean append) throws IOException {
		if (dest.exists()) {
			if (!dest.isFile()) {
				throw new IOException(MSG_NOT_A_FILE + dest);
			}
		}
		Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(dest, append), encoding));
		try {
			out.write(data);
		} finally {
			StreamUtil.close(out);
		}
	}


	// ---------------------------------------------------------------- read/write string

	public static String readUTFString(String fileName) throws IOException {
		return readUTFString(file(fileName));
	}

	/**
	 * Detects optional BOM and reads UTF string from a file.
	 * If BOM is missing, UTF-8 is assumed.
	 * @see UnicodeInputStream
	 */
	public static String readUTFString(File file) throws IOException {
		if (!file.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + file);
		}
		if (!file.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + file);
		}
		long len = file.length();
		if (len >= Integer.MAX_VALUE) {
			len = Integer.MAX_VALUE;
		}
		UnicodeInputStream in = null;
		try {
			in = new UnicodeInputStream(new FileInputStream(file), null);
			FastCharArrayWriter out = new FastCharArrayWriter((int) len);
			String encoding = in.getDetectedEncoding();
			if (encoding == null) {
				encoding = StringPool.UTF_8;
			}
			StreamUtil.copy(in, out, encoding);
			return out.toString();
		} finally {
			StreamUtil.close(in);
		}
	}

	/**
	 * Detects optional BOM and reads UTF string from an input stream.
	 * If BOM is missing, UTF-8 is assumed.
	 */
	public static String readUTFString(InputStream inputStream) throws IOException {
		UnicodeInputStream in = null;
		try {
			in = new UnicodeInputStream(inputStream, null);
			FastCharArrayWriter out = new FastCharArrayWriter();
			String encoding = in.getDetectedEncoding();
			if (encoding == null) {
				encoding = StringPool.UTF_8;
			}
			StreamUtil.copy(in, out, encoding);
			return out.toString();
		} finally {
			StreamUtil.close(in);
		}
	}


	public static String readString(String source) throws IOException {
		return readString(file(source), fileUtilParams.encoding);
	}

	public static String readString(String source, String encoding) throws IOException {
		return readString(file(source), encoding);
	}

	public static String readString(File source) throws IOException {
		return readString(source, fileUtilParams.encoding);
	}

	/**
	 * Reads file content as string encoded in provided encoding.
	 * For UTF encoded files, detects optional BOM characters.
	 */
	public static String readString(File file, String encoding) throws IOException {
		if (!file.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + file);
		}
		if (!file.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + file);
		}
		long len = file.length();
		if (len >= Integer.MAX_VALUE) {
			len = Integer.MAX_VALUE;
		}
		InputStream in = null;
		try {
			in = new FileInputStream(file);
			if (encoding.startsWith("UTF")) {
				in = new UnicodeInputStream(in, encoding);
			}
			FastCharArrayWriter out = new FastCharArrayWriter((int) len);
			StreamUtil.copy(in, out, encoding);
			return out.toString();
		} finally {
			StreamUtil.close(in);
		}
	}


	public static void writeString(String dest, String data) throws IOException {
		outString(file(dest), data, fileUtilParams.encoding, false);
	}

	public static void writeString(String dest, String data, String encoding) throws IOException {
		outString(file(dest), data, encoding, false);
	}

	public static void writeString(File dest, String data) throws IOException {
		outString(dest, data, fileUtilParams.encoding, false);
	}

	public static void writeString(File dest, String data, String encoding) throws IOException {
		outString(dest, data, encoding, false);
	}


	public static void appendString(String dest, String data) throws IOException {
		outString(file(dest), data, fileUtilParams.encoding, true);
	}

	public static void appendString(String dest, String data, String encoding) throws IOException {
		outString(file(dest), data, encoding, true);
	}

	public static void appendString(File dest, String data) throws IOException {
		outString(dest, data, fileUtilParams.encoding, true);
	}

	public static void appendString(File dest, String data, String encoding) throws IOException {
		outString(dest, data, encoding, true);
	}

	protected static void outString(File dest, String data, String encoding, boolean append) throws IOException {
		if (dest.exists()) {
			if (!dest.isFile()) {
				throw new IOException(MSG_NOT_A_FILE + dest);
			}
		}
		FileOutputStream out = null;
		try {
			out = new FileOutputStream(dest, append);
			out.write(data.getBytes(encoding));
		} finally {
			StreamUtil.close(out);
		}
	}

	// ---------------------------------------------------------------- stream

	public static void writeStream(File dest, InputStream in) throws IOException {
		FileOutputStream out = null;
		try {
			out = new FileOutputStream(dest);
			StreamUtil.copy(in, out);
		} finally {
			StreamUtil.close(out);
		}
	}

	public static void writeStream(String dest, InputStream in) throws IOException {
		FileOutputStream out = null;
		try {
			out = new FileOutputStream(dest);
			StreamUtil.copy(in, out);
		} finally {
			StreamUtil.close(out);
		}
	}


	// ---------------------------------------------------------------- read/write string lines


	public static String[] readLines(String source) throws IOException {
		return readLines(file(source), fileUtilParams.encoding);
	}
	public static String[] readLines(String source, String encoding) throws IOException {
		return readLines(file(source), encoding);
	}
	public static String[] readLines(File source) throws IOException {
		return readLines(source, fileUtilParams.encoding);
	}

	/**
	 * Reads lines from source files.
	 */
	public static String[] readLines(File file, String encoding) throws IOException {
		if (!file.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + file);
		}
		if (!file.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + file);
		}
		List<String> list = new ArrayList<>();

		InputStream in = null;
		try {
			in = new FileInputStream(file);
			if (encoding.startsWith("UTF")) {
				in = new UnicodeInputStream(in, encoding);
			}
			BufferedReader br = new BufferedReader(new InputStreamReader(in, encoding));
			String strLine;
			while ((strLine = br.readLine()) != null)   {
				list.add(strLine);
			}
		} finally {
			StreamUtil.close(in);
		}
		return list.toArray(new String[list.size()]);
	}



	// ---------------------------------------------------------------- read/write bytearray


	public static byte[] readBytes(String file) throws IOException {
		return readBytes(file(file));
	}

	public static byte[] readBytes(File file) throws IOException {
		return readBytes(file, -1);
	}
	public static byte[] readBytes(File file, int fixedLength) throws IOException {
		if (!file.exists()) {
			throw new FileNotFoundException(MSG_NOT_FOUND + file);
		}
		if (!file.isFile()) {
			throw new IOException(MSG_NOT_A_FILE + file);
		}
		long len = file.length();
		if (len >= Integer.MAX_VALUE) {
			throw new IOException("File is larger then max array size");
		}

		if (fixedLength > -1 && fixedLength < len) {
			len = fixedLength;
		}

		byte[] bytes = new byte[(int) len];
		RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");
		randomAccessFile.readFully(bytes);
		randomAccessFile.close();

		return bytes;
	}



	public static void writeBytes(String dest, byte[] data) throws IOException {
		outBytes(file(dest), data, 0, data.length, false);
	}

	public static void writeBytes(String dest, byte[] data, int off, int len) throws IOException {
		outBytes(file(dest), data, off, len, false);
	}

	public static void writeBytes(File dest, byte[] data) throws IOException {
		outBytes(dest, data, 0, data.length, false);
	}

	public static void writeBytes(File dest, byte[] data, int off, int len) throws IOException {
		outBytes(dest, data, off, len, false);
	}


	public static void appendBytes(String dest, byte[] data) throws IOException {
		outBytes(file(dest), data, 0, data.length, true);
	}

	public static void appendBytes(String dest, byte[] data, int off, int len) throws IOException {
		outBytes(file(dest), data, off, len, true);
	}

	public static void appendBytes(File dest, byte[] data) throws IOException {
		outBytes(dest, data, 0, data.length, true);
	}

	public static void appendBytes(File dest, byte[] data, int off, int len) throws IOException {
		outBytes(dest, data, off, len, true);
	}

	protected static void outBytes(File dest, byte[] data, int off, int len, boolean append) throws IOException {
		if (dest.exists()) {
			if (!dest.isFile()) {
				throw new IOException(MSG_NOT_A_FILE + dest);
			}
		}
		FileOutputStream out = null;
		try {
			out = new FileOutputStream(dest, append);
			out.write(data, off, len);
		} finally {
			StreamUtil.close(out);
		}
	}

	// ---------------------------------------------------------------- equals content

	public static boolean compare(String file1, String file2) throws IOException {
		return compare(file(file1), file(file2));
	}

	/**
	 * Compare the contents of two files to determine if they are equal or
	 * not.
	 * <p>
	 * This method checks to see if the two files are different lengths
	 * or if they point to the same file, before resorting to byte-by-byte
	 * comparison of the contents.
	 * <p>
	 * Code origin: Avalon
	 */
	public static boolean compare(File file1, File file2) throws IOException {
		boolean file1Exists = file1.exists();
		if (file1Exists != file2.exists()) {
			return false;
		}

		if (!file1Exists) {
			return true;
		}

		if ((!file1.isFile()) || (!file2.isFile())) {
			throw new IOException("Only files can be compared");
		}

		if (file1.length() != file2.length()) {
			return false;
		}

		if (equals(file1, file2)) {
			return true;
		}

		InputStream input1 = null;
		InputStream input2 = null;
		try {
			input1 = new FileInputStream(file1);
			input2 = new FileInputStream(file2);
			return StreamUtil.compare(input1, input2);
		} finally {
			StreamUtil.close(input1);
			StreamUtil.close(input2);
		}
	}

	// ---------------------------------------------------------------- time

	public static boolean isNewer(String file, String reference) {
		return isNewer(file(file), file(reference));
	}

	/**
	 * Test if specified <code>File</code> is newer than the reference <code>File</code>.
	 *
	 * @param file		the <code>File</code> of which the modification date must be compared
	 * @param reference	the <code>File</code> of which the modification date is used
	 * @return <code>true</code> if the <code>File</code> exists and has been modified more
	 * 			recently than the reference <code>File</code>.
	 */
	public static boolean isNewer(File file, File reference) {
		if (!reference.exists()) {
			throw new IllegalArgumentException("Reference file not found: " + reference);
		}
		return isNewer(file, reference.lastModified());
	}


	public static boolean isOlder(String file, String reference) {
		return isOlder(file(file), file(reference));
	}

	public static boolean isOlder(File file, File reference) {
		if (!reference.exists()) {
			throw new IllegalArgumentException("Reference file not found: " + reference);
		}
		return isOlder(file, reference.lastModified());
	}

	/**
	 * Tests if the specified <code>File</code> is newer than the specified time reference.
	 *
	 * @param file			the <code>File</code> of which the modification date must be compared.
	 * @param timeMillis	the time reference measured in milliseconds since the
	 * 						epoch (00:00:00 GMT, January 1, 1970)
	 * @return <code>true</code> if the <code>File</code> exists and has been modified after
	 *         the given time reference.
	 */
	public static boolean isNewer(File file, long timeMillis) {
		if (!file.exists()) {
			return false;
		}
		return file.lastModified() > timeMillis;
	}

	public static boolean isNewer(String file, long timeMillis) {
		return isNewer(file(file), timeMillis);
	}


	public static boolean isOlder(File file, long timeMillis) {
		if (!file.exists()) {
			return false;
		}
		return file.lastModified() < timeMillis;
	}

	public static boolean isOlder(String file, long timeMillis) {
		return isOlder(file(file), timeMillis);
	}


	// ---------------------------------------------------------------- smart copy

	public static void copy(String src, String dest) throws IOException {
		copy(file(src), file(dest), fileUtilParams);
	}

	public static void copy(String src, String dest, FileUtilParams params) throws IOException {
		copy(file(src), file(dest), params);
	}

	public static void copy(File src, File dest) throws IOException {
		copy(src, dest, fileUtilParams);
	}
	/**
	 * Smart copy. If source is a directory, copy it to destination.
	 * Otherwise, if destination is directory, copy source file to it.
	 * Otherwise, try to copy source file to destination file.
	 */
	public static void copy(File src, File dest, FileUtilParams params) throws IOException {
		if (src.isDirectory()) {
			copyDir(src, dest, params);
			return;
		}
		if (dest.isDirectory()) {
			copyFileToDir(src, dest, params);
			return;
		}
		copyFile(src, dest, params);
	}

	// ---------------------------------------------------------------- smart move

	public static void move(String src, String dest) throws IOException {
		move(file(src), file(dest), fileUtilParams);
	}

	public static void move(String src, String dest, FileUtilParams params) throws IOException {
		move(file(src), file(dest), params);
	}

	public static void move(File src, File dest) throws IOException {
		move(src, dest, fileUtilParams);
	}
	/**
	 * Smart move. If source is a directory, move it to destination.
	 * Otherwise, if destination is directory, move source file to it.
	 * Otherwise, try to move source file to destination file.
	 */
	public static void move(File src, File dest, FileUtilParams params) throws IOException {
		if (src.isDirectory()) {
			moveDir(src, dest);
			return;
		}
		if (dest.isDirectory()) {
			moveFileToDir(src, dest, params);
			return;
		}
		moveFile(src, dest, params);
	}


	// ---------------------------------------------------------------- smart delete

	public static void delete(String dest) throws IOException {
		delete(file(dest), fileUtilParams);
	}

	public static void delete(String dest, FileUtilParams params) throws IOException {
		delete(file(dest), params);
	}

	public static void delete(File dest) throws IOException {
		delete(dest, fileUtilParams);
	}

	/**
	 * Smart delete of destination file or directory.
	 */
	public static void delete(File dest, FileUtilParams params) throws IOException {
		if (dest.isDirectory()) {
			deleteDir(dest, params);
			return;
		}
		deleteFile(dest);
	}

	// ---------------------------------------------------------------- misc

	/**
	 * Check if one file is an ancestor of second one.
	 *
	 * @param strict   if <code>false</code> then this method returns <code>true</code> if ancestor
	 *                 and file are equal
	 * @return <code>true</code> if ancestor is parent of file; <code>false</code> otherwise
	 */
	public static boolean isAncestor(File ancestor, File file, boolean strict) {
		File parent = strict ? getParentFile(file) : file;
		while (true) {
			if (parent == null) {
				return false;
			}
			if (parent.equals(ancestor)) {
				return true;
			}
			parent = getParentFile(parent);
		}
	}

	/**
	 * Returns parent for the file. The method correctly
	 * processes "." and ".." in file names. The name
	 * remains relative if was relative before.
	 * Returns <code>null</code> if the file has no parent.
	 */
	public static File getParentFile(final File file) {
		int skipCount = 0;
		File parentFile = file;
		while (true) {
			parentFile = parentFile.getParentFile();
			if (parentFile == null) {
				return null;
			}
			if (StringPool.DOT.equals(parentFile.getName())) {
				continue;
			}
			if (StringPool.DOTDOT.equals(parentFile.getName())) {
				skipCount++;
				continue;
			}
			if (skipCount > 0) {
				skipCount--;
				continue;
			}
			return parentFile;
		}
	}

	public static boolean isFilePathAcceptable(File file, FileFilter fileFilter) {
		do {
			if (fileFilter != null && !fileFilter.accept(file)) {
				return false;
			}
			file = file.getParentFile();
		} while (file != null);
		return true;
	}

	// ---------------------------------------------------------------- temp

	public static File createTempDirectory() throws IOException {
		return createTempDirectory(JoddCore.tempFilePrefix, null, null);
	}

	/**
	 * Creates temporary directory.
	 */
	public static File createTempDirectory(String prefix, String suffix) throws IOException {
		return createTempDirectory(prefix, suffix, null);
	}

	/**
	 * Creates temporary directory.
	 */
	public static File createTempDirectory(String prefix, String suffix, File tempDir) throws IOException {
		File file = createTempFile(prefix, suffix, tempDir);
		file.delete();
		file.mkdir();
		return file;
	}

	/**
	 * Simple method that creates temp file.
	 */
	public static File createTempFile() throws IOException {
		return createTempFile(JoddCore.tempFilePrefix, null, null, true);
	}

	/**
	 * Creates temporary file.
	 * If <code>create</code> is set to <code>true</code> file will be
	 * physically created on the file system. Otherwise, it will be created and then
	 * deleted - trick that will make temp file exist only if they are used.
	 */
	public static File createTempFile(String prefix, String suffix, File tempDir, boolean create) throws IOException {
		File file = createTempFile(prefix, suffix, tempDir);
		file.delete();
		if (create) {
			file.createNewFile();
		}
		return file;
	}

	/**
	 * Creates temporary file. Wraps java method and repeat creation several time
	 * if something fail.
	 */
	public static File createTempFile(String prefix, String suffix, File dir) throws IOException {
		int exceptionsCount = 0;
		while (true) {
			try {
				return File.createTempFile(prefix, suffix, dir).getCanonicalFile();
			} catch (IOException ioex) {	// fixes java.io.WinNTFileSystem.createFileExclusively access denied
				if (++exceptionsCount >= 50) {
					throw ioex;
				}
			}
		}
	}

	// ---------------------------------------------------------------- symlink

	/**
	 * Determines whether the specified file is a symbolic link rather than an actual file.
	 * Always returns <code>false</code> on Windows.
	 */
	public static boolean isSymlink(final File file) throws IOException {
		if (SystemUtil.isHostWindows()) {
			return false;
		}

		File fileInCanonicalDir;

		if (file.getParent() == null) {
			fileInCanonicalDir = file;
		} else {
			File canonicalDir = file.getParentFile().getCanonicalFile();
			fileInCanonicalDir = new File(canonicalDir, file.getName());
		}

		return !fileInCanonicalDir.getCanonicalFile().equals(fileInCanonicalDir.getAbsoluteFile());
	}

	// ---------------------------------------------------------------- digests

	/**
	 * Calculates digest for a file using provided algorithm.
	 */
	public static byte[] digest(final File file, MessageDigest algorithm) throws IOException {
		algorithm.reset();
		FileInputStream fis = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(fis);
		DigestInputStream dis = new DigestInputStream(bis, algorithm);

		try {
			while (dis.read() != -1) {
			}
		}
		finally {
			StreamUtil.close(fis);
		}

		return algorithm.digest();
	}

	/**
	 * Creates MD5 digest of a file.
	 */
	public static String md5(final File file) throws IOException {
		MessageDigest md5Digest = null;
		try {
			md5Digest = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException ignore) {
		}

		byte[] digest = digest(file, md5Digest);

		return StringUtil.toHexString(digest);
	}

	/**
	 * Creates SHA-1 digest of a file.
	 */
	public static String sha(final File file) throws IOException {
		MessageDigest md5Digest = null;
		try {
			md5Digest = MessageDigest.getInstance("SHA-1");
		} catch (NoSuchAlgorithmException ignore) {
		}

		byte[] digest = digest(file, md5Digest);

		return StringUtil.toHexString(digest);
	}

	/**
	 * Creates SHA-256 digest of a file.
	 */
	public static String sha256(final File file) throws IOException {
		MessageDigest md5Digest = null;
		try {
			md5Digest = MessageDigest.getInstance("SHA-256");
		} catch (NoSuchAlgorithmException ignore) {
		}

		byte[] digest = digest(file, md5Digest);

		return StringUtil.toHexString(digest);
	}

	/**
	 * Checks the start of the file for ASCII control characters
	 */
	public static boolean isBinary(final File file) throws IOException {
		byte[] bytes = readBytes(file, 128);

		for (byte b : bytes) {
			if (b < 32) {
				return true;
			}
		}

		return false;
	}
}