/*******************************************************************************
 * Copyright 2015 [email protected]
 * 
 * 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 com.laudandjolynn.mytv.utils;

import java.io.ByteArrayOutputStream;
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.Writer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.ReadableByteChannel;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

/**
 * @author: Laud
 * @email: [email protected]
 * @date: 2012-9-23
 * @copyright: www.dreamoriole.com
 */
public class FileUtils {
	/**
	 * 缓冲区大小
	 */
	private final static int BUFFER_SIZE = 1024;
	/**
	 * 默认编码类型
	 */
	public final static String DEFAULT_CHARSET_NAME = "UTF-8";

	/**
	 * 删除文件
	 * 
	 * @param filePath
	 */
	public static void delete(String filePath) {
		File file = new File(filePath);
		if (file.exists()) {
			file.delete();
		}
	}

	/**
	 * 读取本地文件,NIO方式
	 * 
	 * @param filePath
	 *            文件路径
	 * @throws IOException
	 * @throws FileNotFoundException
	 * @return
	 */
	public static byte[] readWithNIO(String filePath)
			throws FileNotFoundException, IOException {
		if (filePath == null) {
			return null;
		}
		FileInputStream fis = new FileInputStream(new File(filePath));
		byte[] data = readFromInputStream(fis);
		fis.close();
		return data;
	}

	/**
	 * 从输入流中读取数据,NIO方式
	 * 
	 * @param in
	 * @return
	 * @throws IOException
	 */
	public static byte[] readFromInputStream(InputStream in) throws IOException {
		if (in == null) {
			return null;
		}
		ReadableByteChannel rbc = Channels.newChannel(in);
		ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
		byte[] data = new byte[BUFFER_SIZE];
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		while (true) {
			int count = rbc.read(buffer);
			if (count == -1) {
				break;
			}
			if (count < BUFFER_SIZE) {
				data = new byte[count];
			}
			buffer.flip();
			buffer.get(data, 0, count);
			baos.write(data);
			buffer.clear();
		}
		rbc.close();
		return baos.toByteArray();
	}

	/**
	 * 读取本地文件,传统IO
	 * 
	 * @param filePath
	 *            文件路径
	 * @throws FileNotFoundException
	 * @throws IOException
	 * @return
	 */
	public static byte[] read(String filePath) throws IOException,
			FileNotFoundException {
		if (filePath == null) {
			return null;
		}
		FileInputStream fis = new FileInputStream(new File(filePath));
		int size = fis.available();
		ByteArrayOutputStream baos = new ByteArrayOutputStream(size);
		byte[] data = null;
		if (size < BUFFER_SIZE) {
			data = new byte[size];
		} else {
			data = new byte[BUFFER_SIZE];
		}
		while (true) {
			int count = fis.read(data);
			if (count == -1) {
				break;
			}
			baos.write(data);
		}
		fis.close();
		return baos.toByteArray();
	}

	/**
	 * 以指定编码读入本地文件,以UTF-8编码方式输出,NIO
	 * 
	 * @param filePath
	 *            文件路径
	 * @param inCharsetName
	 *            编码名称,读入
	 * @throws FileNotFoundException
	 * @throws IOException
	 * @return
	 */
	public static byte[] readWithNIO(String filePath, String inCharsetName)
			throws FileNotFoundException, IOException {
		return readWithNIO(filePath, inCharsetName, DEFAULT_CHARSET_NAME);
	}

	/**
	 * 以指定编码读入本地文件,以指定编码方式输出,NIO
	 * 
	 * @param filePath
	 *            文件路径
	 * @param inCharsetName
	 *            编码名称,读入
	 * @param outCharsetName
	 *            编码名称,输出
	 * @throws FileNotFoundException
	 * @throws IOException
	 * @return
	 */
	public static byte[] readWithNIO(String filePath, String inCharsetName,
			String outCharsetName) throws FileNotFoundException, IOException {
		if (filePath == null) {
			return null;
		}
		FileInputStream fis = new FileInputStream(new File(filePath));
		FileChannel fc = fis.getChannel();
		ByteBuffer byteBuffer = ByteBuffer.allocate(fis.available());
		ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);

		while (true) {
			int count = fc.read(buffer);
			if (count == -1) {
				break;
			}
			buffer.flip();
			byteBuffer.put(buffer);
			buffer.clear();
		}
		fc.close();
		fis.close();
		byteBuffer.flip();
		Charset inCharset = Charset.forName(inCharsetName);
		Charset outCharset = Charset.forName(outCharsetName);
		CharsetDecoder decoder = inCharset.newDecoder();
		CharsetEncoder encoder = outCharset.newEncoder();
		CharBuffer charBuffer = decoder.decode(byteBuffer);
		ByteBuffer resultBuffer = encoder.encode(charBuffer);
		int size = resultBuffer.limit();
		byte[] data = new byte[size];
		resultBuffer.get(data, 0, size);
		return data;
	}

	/**
	 * 写入本地文件,传统IO
	 * 
	 * @param data
	 *            数据
	 * @param filePath
	 *            文件路径
	 * @throws IOException
	 */
	public static void write(byte[] data, String filePath) throws IOException {
		write(data, filePath, false);
	}

	/**
	 * 写入本地文件,传统IO
	 * 
	 * @param data
	 *            数据
	 * @param filePath
	 *            文件路径
	 * @param append
	 *            是否追加
	 * @throws IOException
	 */
	public static void write(byte[] data, String filePath, boolean append)
			throws IOException {
		FileOutputStream fos = new FileOutputStream(new File(filePath), append);
		int byteCount = data.length;
		int q = byteCount / BUFFER_SIZE;
		int mod = byteCount % BUFFER_SIZE;
		int offset = 0;
		for (int i = 0; i < q; i++) {
			fos.write(data, offset, BUFFER_SIZE);
			offset += BUFFER_SIZE;
		}
		fos.write(data, offset, mod);
		fos.flush();
		fos.close();
	}

	/**
	 * 以指定编码方式,写入本地文件,传统IO
	 * 
	 * @param data
	 *            数据
	 * @param charsetName
	 *            编码名称
	 * @param filePath
	 *            文件路径
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	public static void write(byte[] data, String charsetName, String filePath)
			throws FileNotFoundException, IOException {
		String value = new String(data);
		write(value, charsetName, filePath);
	}

	/**
	 * 以指定编码方式,写入本地文件,传统IO
	 * 
	 * @param data
	 *            数据
	 * @param charsetName
	 *            编码名称
	 * @param filePath
	 *            文件路径
	 * @throws IOException
	 */
	public static void write(String data, String charsetName, String filePath)
			throws IOException {
		Charset charset = Charset.forName(charsetName);
		FileOutputStream fos = new FileOutputStream(new File(filePath));
		Writer writer = new OutputStreamWriter(fos, charset);
		writer.write(data);
		writer.close();
		fos.close();
	}

	/**
	 * 写入本地文件,NIO方式
	 * 
	 * @param data
	 *            数据
	 * @param filePath
	 *            文件路径
	 * @throws IOException
	 */
	public static void writeWithNIO(byte[] data, String filePath)
			throws IOException {
		FileOutputStream fos = new FileOutputStream(new File(filePath));
		FileChannel fc = fos.getChannel();

		ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
		int byteCount = data.length;
		int q = byteCount / BUFFER_SIZE;
		int mod = byteCount % BUFFER_SIZE;
		int offset = 0;
		for (int i = 0; i < q; i++) {
			buffer.put(data, offset, BUFFER_SIZE);
			buffer.flip();
			fc.write(buffer);
			buffer.clear();
			offset += BUFFER_SIZE;
		}
		buffer.put(data, offset, mod);
		buffer.flip();
		fc.write(buffer);
		buffer.clear();

		fc.close();
		fos.close();
	}

	/**
	 * 以指定编码方式,写入本地文件,NIO
	 * 
	 * @param data
	 *            数据
	 * @param charsetName
	 *            编码名称
	 * @param filePath
	 *            文件路径
	 * @throws CharacterCodingException
	 * @throws IOException
	 */
	public static void writeWithNIO(String data, String charsetName,
			String filePath) throws CharacterCodingException, IOException {
		writeWithNIO(data, charsetName, filePath, false);
	}

	/**
	 * 以指定编码方式,写入本地文件,NIO
	 * 
	 * @param data
	 *            数据
	 * @param charsetName
	 *            编码名称
	 * @param filePath
	 *            文件路径
	 * @param append
	 *            是否追加
	 * @throws CharacterCodingException
	 * @throws IOException
	 */
	public static void writeWithNIO(String data, String charsetName,
			String filePath, boolean append) throws CharacterCodingException,
			IOException {
		Charset charset = Charset.forName(charsetName);
		CharsetEncoder encoder = charset.newEncoder();
		CharBuffer charBuffer = CharBuffer.wrap(data, 0, data.length());
		ByteBuffer buffer = encoder.encode(charBuffer);
		FileOutputStream fos = new FileOutputStream(new File(filePath), append);
		FileChannel fc = fos.getChannel();
		fc.write(buffer);
		fc.close();
		fos.close();
	}

	/**
	 * 以指定编码方式,写入本地文件,NIO
	 * 
	 * @param data
	 *            数据
	 * @param charsetName
	 *            编码名称
	 * @param filePath
	 *            文件路径
	 * @throws CharacterCodingException
	 * @throws IOException
	 */
	public static void writeWithNIO(byte[] data, String charsetName,
			String filePath) throws CharacterCodingException, IOException {
		String value = new String(data);
		writeWithNIO(value, charsetName, filePath);
	}

	/**
	 * 将指定的输入流写入本地文件,NIO方式
	 * 
	 * @param in
	 * @param filePath
	 */
	public static void writeFromInputStream(InputStream in, String filePath)
			throws IOException {
		FileOutputStream fos = new FileOutputStream(new File(filePath));
		FileChannel fc = fos.getChannel();
		ReadableByteChannel rbc = Channels.newChannel(in);
		ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
		while (true) {
			int count = rbc.read(buffer);
			if (count == -1) {
				break;
			}
			buffer.flip();
			fc.write(buffer);
			buffer.clear();
		}

		rbc.close();
		fc.close();
		fos.close();
	}
}