package com.youlai.boot.common.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

public class FtpUtil {

	private String Control_Encoding = "UTF-8";

	private FTPClient client = null;

	private String host = "182.92.126.35";
	private int port = 21;
	private String user = "root";
	private String password = "Ccri123456";
	private String ftpPath = "/";

	private String absPath;
	@SuppressWarnings("unused")
	private FtpUtil() {
	}

	public FtpUtil(String absPath) {
		this.absPath = absPath;
	}

	/**
	 * 获取当前FTP所在目录位置
	 * 
	 * @return
	 */
	public String getHome() {
		return this.ftpPath;
	}

	/**
	 * 连接FTP Server
	 * 
	 * @throws IOException
	 */
	public static final String ANONYMOUS_USER = "anonymous";

	public void connect() throws Exception {
		if (client == null) {
			client = new FTPClient();
		}
		// 已经连接
		if (client.isConnected()) {
			return;
		}

		// 编码
		client.setControlEncoding(Control_Encoding);

		try {
			// 连接FTP Server
			client.connect(this.host, this.port);
			// 登陆
			if (this.user == null || "".equals(this.user)) {
				// 使用匿名登陆
				client.login(ANONYMOUS_USER, ANONYMOUS_USER);
			} else {
				client.login(this.user, this.password);
			}
			// 设置文件格式
			client.setFileType(FTPClient.BINARY_FILE_TYPE);
			// 获取FTP Server 应答
			int reply = client.getReplyCode();
			if (!FTPReply.isPositiveCompletion(reply)) {
				client.disconnect();
				throw new Exception("connection FTP fail!");
			}

			FTPClientConfig config = new FTPClientConfig(client.getSystemType().split(" ")[0]);
			config.setServerLanguageCode("zh");
			client.configure(config);
			// 使用被动模式设为默认
			client.enterLocalPassiveMode();
			// 二进制文件支持
			client.setFileType(FTP.BINARY_FILE_TYPE);
			// 设置模式
			client.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);

		} catch (IOException e) {
			throw new Exception("connection FTP fail! " + e);
		}
	}

	/**
	 * 断开FTP连接
	 * 
	 * @param ftpClient
	 * @throws IOException
	 */
	public void close() {
		if (client != null && client.isConnected()) {
			try {
				client.logout();
				client.disconnect();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 获取文件列表
	 * 
	 * @return
	 */
	public List<FTPFile> list() {
		List<FTPFile> list = null;
		try {
			FTPFile ff[] = client.listFiles(ftpPath);
			if (ff != null && ff.length > 0) {
				list = new ArrayList<FTPFile>(ff.length);
				Collections.addAll(list, ff);
			} else {
				list = new ArrayList<FTPFile>(0);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return list;
	}

	/**
	 * 切换目录
	 * 
	 * @param path
	 *            需要切换的目录
	 * @param forcedIncrease
	 *            如果目录不存在，是否增加
	 */
	public void switchDirectory(String path, boolean forcedIncrease) {
		try {
			if (path != null && !"".equals(path)) {
				boolean ok = client.changeWorkingDirectory(path);
				if (ok) {
					this.ftpPath = path;
				} else if (forcedIncrease) {
					// ftpPath 不存在，手动创建目录
					StringTokenizer token = new StringTokenizer(path, "\\//");
					while (token.hasMoreTokens()) {
						String npath = token.nextToken();
						client.makeDirectory(npath);
						client.changeWorkingDirectory(npath);
						if (ok) {
							this.ftpPath = path;
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 创建目录
	 * 
	 * @param path
	 */
	public void createDirectory(String path) {
		try {
			if (path != null && !"".equals(path)) {
				boolean ok = client.changeWorkingDirectory(path);
				if (!ok) {
					// ftpPath 不存在，手动创建目录
					StringTokenizer token = new StringTokenizer(path, "\\//");
					while (token.hasMoreTokens()) {
						String npath = token.nextToken();
						client.makeDirectory(npath);
						client.changeWorkingDirectory(npath);
					}
				}
			}
			client.changeWorkingDirectory(this.ftpPath);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 删除目录，如果目录中存在文件或者文件夹则删除失败
	 * 
	 * @param path
	 * @return
	 */
	public boolean deleteDirectory(String path) {
		boolean flag = false;
		try {
			flag = client.removeDirectory(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return flag;
	}

	/**
	 * 删除文件
	 * 
	 * @param path
	 * @return
	 */
	public boolean deleteFile(String path) {
		boolean flag = false;
		try {
			flag = client.deleteFile(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return flag;
	}

	/**
	 * 上传文件，上传文件只会传到当前所在目录
	 * 
	 * @param localFile
	 *            本地文件
	 * @return
	 */
	public boolean upload(File localFile) {
		return this.upload(localFile, "");
	}

	/**
	 * 上传文件，会覆盖FTP上原有文件
	 * 
	 * @param localFile
	 *            本地文件
	 * @param reName
	 *            重名
	 * @return
	 */
	public boolean upload(File localFile, String reName) {
		boolean flag = false;
		String targetName = reName;
		// 设置上传后文件名
		if (reName == null || "".equals(reName)) {
			targetName = localFile.getName();
		}
		FileInputStream fis = null;
		try {
			// 开始上传文件
			fis = new FileInputStream(localFile);
			client.setControlEncoding(Control_Encoding);
			client.setFileType(FTPClient.BINARY_FILE_TYPE);
			boolean ok = client.storeFile(targetName, fis);
			if (ok) {
				flag = true;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return flag;
	}

	/**
	 * 下载文件，如果存在会覆盖原文件
	 * 
	 * @param ftpFileName
	 *            文件名称，FTP上的文件名称
	 * @param savePath
	 *            保存目录，本地保存目录
	 * @return
	 */
	public boolean download(String ftpFileName, String savePath) {
		boolean flag = false;

		File dir = new File(savePath);

		if (!dir.exists()) {
			dir.mkdirs();
		}

		FileOutputStream fos = null;
		try {
			String saveFile = dir.getAbsolutePath() + File.separator + ftpFileName;
			fos = new FileOutputStream(new File(saveFile));
			boolean ok = client.retrieveFile(ftpFileName, fos);
			if (ok) {
				flag = true;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return flag;
	}


}
