package com.walker.infrastructure.utils;

import com.walker.infrastructure.ApplicationRuntimeException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * JAR自定义组件部署者</p>
 * 
 * 此组件能够把打包好的jar文件中的所有文件（或者指定文件）解压到指定的地方,</br>
 * 通常是classpath下面。打包的文件是符合标准的*.jar，但里面具体内容并不一定</br>
 * 是编译好的class也能是一些资源文件，如：图片、js、css等。</p>
 * 
 * 最初编写的目的是把用户web项目lib中的组件内容解压的系统webroot目录中。
 * @author shikeying
 * @date 2013-8-29
 *
 */
public abstract class JarDeployer {

	private static final Logger logger = LoggerFactory.getLogger(JarDeployer.class);
	
	/**
	 * 部署jar的前缀，有默认值，也可设置
	 */
	public static String DEPLOY_JAR_PREFIX = "walkersoft-resource-";
		
	public static final String DEPLOY_FILENAME = "walker-deploy.properties";
	
	/**
	 * 尚未部署的应用jar集合
	 */
	public static final List<File> DEPLOY_WAIT_FILES = new ArrayList<File>();
	
	/**
	 * 已经部署过的jar列表，key = jarName, value = 解压时间毫秒值
	 */
	public static final Map<String, Long> DEPLOYED_FILES = new TreeMap<String, Long>();
	
	/**
	 * 返回系统<code>classpath</code>的根路径</br>
	 * 如：d:/webapp/demo/WEB-INF/classes/
	 */
	public static final String classpathAbsolute = PathSolver.classpathAbsolute;
	
	/**
	 * 返回系统web应用程序的根路径，如：d:/webapp/demo/
	 */
	public static final String webappRootAbsolute = PathSolver.webappRootAbsolute;
	
	/**
	 * 返回web应用程序lib路径，如：d:/webapp/demo/WEB-INF/lib/
	 */
	public static final String webappLibAbsolute = PathSolver.webappLibAbsolute;
	
	public static final String CLASSES_PATH = "classes/";
	public static final String WEBINF_PATH = "WEB-INF/";
	
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// instance variable
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	private String jarName; // jar名字，不包括路径
	
	private JarDeployer(){}

	public void setJarName(String jarName) {
		this.jarName = jarName;
	}

	/**
	 * 创建web项目发布者实现对象，从lib目录中找jar包，并解压到webroot中
	 * @param jarName
	 * @return
	 */
	public static final JarDeployer getWebappLibInstance(String jarName){
		JarDeployer webappLibJarDeployer = new WebAppLibJarDeployer();
		webappLibJarDeployer.setJarName(jarName);
		return webappLibJarDeployer;
	}
	
	/**
	 * 解压并部署文件</p>
	 * 系统会把 webapp/WEB-INF/lib 路径中的jar文件中的所有内容解压到 webapp/下面。
	 * @return
	 */
	public Object deploy(){
		String _srcPath  = getSourcePath();
		String _destPath = getDestinationPath();
		logger.debug("##############################################");
		logger.debug("getSourcePath() = " + _srcPath);
		logger.debug("getDestinationPath() = " + _destPath);
		logger.debug("##############################################");
		if(_srcPath != null && _destPath != null){
			return deploy(_srcPath, _destPath);
		}
		return null;
	}
	
	/**
	 * 解压并部署文件</p>
	 * 系统会把输入路径中的jar文件中的所有内容解压到目的地。
	 * @param srcPath 源路径，如：d:/src
	 * @param destinationPath 目的地路径，如：d:/webroot
	 * @return
	 */
	public Object deploy(String srcPath, String destinationPath){
		String _srcPath  = getSourcePath();
		String _destPath = getDestinationPath();
		logger.debug("deploy --> getSourcePath() = " +_srcPath);
		
		if(_srcPath == null)
			_srcPath = srcPath;
		if(_srcPath == null)
			throw new NullPointerException("srcPath is required.");
		
		if(_destPath == null)
			_destPath = destinationPath;
		if(_destPath == null)
			throw new NullPointerException("destinationPath is required.");
		
		if(!_srcPath.trim().endsWith("/")){
			_srcPath += "/";
		}
		_srcPath += jarName; // jar文件完整路径
		
		_srcPath = FileSystemUtils.trimFileSchema(_srcPath);
		_destPath = FileSystemUtils.trimFileSchema(_destPath);
		
		logger.debug("要解压的jar文件是：" + _srcPath);
		logger.debug("目的路径                       ：" + _destPath);
		
		try{
			decompress(_srcPath, _destPath);
		} catch(Error e){
			throw new Error("部署文件失败! \t可能文件不存在，或者不符合jar文件规范。", e);
		}
		
		return "success";
	}
	
	public synchronized void decompress(String fileName,String outputPath){
		if(!outputPath.endsWith(File.separator)){
			outputPath += File.separator;
		}
		File dir = new File(outputPath);
		if(!dir.exists()){
			dir.mkdirs();
		}
		JarFile jf = null;
		String outFileName = null; 
		try {
			jf = new JarFile(fileName);
			for(Enumeration<JarEntry> e = jf.entries();e.hasMoreElements();){
				JarEntry je = e.nextElement();
				if(je == null) continue;
				
				// jar中的META-INF目录忽略
				if(je.getName().indexOf("META-INF") >= 0){
					logger.debug("忽略META-INF目录");
					continue;
				}
				outFileName = outputPath + je.getName();
				File f = new File(outFileName);
				if(je.isDirectory()){
					if(!f.exists()) f.mkdirs();
				}else{
					File pf = f.getParentFile();
					if(!pf.exists()){
						pf.mkdirs();
					}
					
					InputStream in = null;
					OutputStream out = null;
					try{
						in = jf.getInputStream(je);
						if(in == null){
							logger.error("......InputStream is null,未发现对象,je: " + je.getName());
							continue;
						}
						
						out = new BufferedOutputStream(new FileOutputStream(f));
						byte[] buffer = new byte[2048];
						int nBytes = 0;
						while((nBytes = in.read(buffer)) > 0 ){
							out.write(buffer,0,nBytes);
						}
					} catch(Exception ex){
						ex.printStackTrace();
						logger.error("复制文件发生错误: " + je.getName() + ", " + ex.getMessage());
						continue;
					} finally {
						if(out != null){
							out.flush();
							out.close();
						}
						if(in != null){
							in.close();
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			String s = "解压" + outFileName + "出错, "+e.getMessage();
			logger.error(s);
			throw new Error(s, e);
		}finally{
			if(jf != null){
				try {
					logger.info("jar file is closed: " + jf.getName());
					jf.close();
//					File jar = new File(jf.getName());
//					if(jar.exists()){
//						jar.delete();
//					}
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	 * 返回原始目标路径，即：要读取JAR文件的路径
	 * @return
	 */
	public abstract String getSourcePath();
	
	/**
	 * 返回目的路径，即：要拷贝文件的路径
	 * @return
	 */
	public abstract String getDestinationPath();

	private static class PathSolver {
		
		static String classpathAbsolute = getClasspathAbsolute();
		static String webappRootAbsolute = getWebAppRootAbsolute(classpathAbsolute);
		static String webappLibAbsolute = getWebAppLibAbsolute(classpathAbsolute);
		
		static final String getClasspathAbsolute(){
			ClassPathResource cpr = new ClassPathResource(".");
			try {
				return FileSystemUtils.trimFileSchema(cpr.getURL().toString());
			} catch (IOException e) {
				// TODO Auto-generated catch block
				logger.error(e.getMessage());
				throw new Error("classpath solver error! cause = " + e);
			}
		}
		
		static final String getWebAppRootAbsolute(String classpathAbs){
			if(StringUtils.isNotEmpty(classpathAbs)){
				return classpathAbs.replaceFirst(WEBINF_PATH + CLASSES_PATH, "");
			}
			return null;	
		}
		
		static final String getWebAppLibAbsolute(String classpathAbs){
			if(StringUtils.isNotEmpty(classpathAbs)){
				return classpathAbs.replaceFirst(CLASSES_PATH, "lib/");
			}
			return null;
		}
	}
	
	private static class WebAppLibJarDeployer extends JarDeployer{

		private String sourcePath;
		private String destinationPath;
		
		public WebAppLibJarDeployer(){}
		
		@Override
		public String getSourcePath() {
			// TODO Auto-generated method stub
			if(this.sourcePath == null){
//				int classesStartInx = JarDeployer.classpathAbsolute.lastIndexOf(CLASSES_PATH);
//				int classesEndInx = classesStartInx + 8;
//				StringBuilder p = new StringBuilder(JarDeployer.classpathAbsolute);
//				p.delete(classesStartInx, classesEndInx);
//				p.append("lib/");
//				this.sourcePath = p.toString();
				this.sourcePath = combinLibByClasspath();
			}
			return this.sourcePath;
		}

		/**
		 * 原始返回目的拷贝路径，如：d:/webapp/demo/，但目前由于需要拷贝freemarker模板文件，<br>
		 * 因此先改为：d:/webapp/demo/WEB-INF/pages/ftl/
		 */
		@Override
		public String getDestinationPath() {
			if(this.destinationPath == null){
//				int webinfStartInx = JarDeployer.classpathAbsolute.lastIndexOf(WEBINF_PATH);
//				this.destinationPath = JarDeployer.classpathAbsolute.substring(0, webinfStartInx);
				int classesStartInx = JarDeployer.classpathAbsolute.lastIndexOf(CLASSES_PATH);
				this.destinationPath = JarDeployer.classpathAbsolute.substring(0, classesStartInx)
						+ "pages/ftl/";
			}
			return this.destinationPath;
		}
	}
	
	/**
	 * 返回WEB应用程序的lib目录的绝对路径</p>
	 * 如：d:/test/webapp/WEB-INF/lib/
	 * @return
	 */
	public static String getWebLibPath(){
		return FileSystemUtils.trimFileSchema(combinLibByClasspath());
	}
	
	static String combinLibByClasspath(){
		int classesStartInx = JarDeployer.classpathAbsolute.lastIndexOf(CLASSES_PATH);
		int classesEndInx = classesStartInx + 8;
		StringBuilder p = new StringBuilder(JarDeployer.classpathAbsolute);
		p.delete(classesStartInx, classesEndInx);
		p.append("lib/");
		return p.toString();
	}
	
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// 部署jar相关代码，2014-11-06
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	/**
	 * 部署的状态，默认：未部署
	 */
	private static AtomicBoolean deployedStatus = new AtomicBoolean(false);
	
	/**
	 * 返回部署状态，如果已经部署成功，返回<code>true</code>
	 * @return
	 */
	public static final boolean getDeployedStatus(){
		return deployedStatus.get();
	}
	
	/** 
	 * 检查部署情况，如果不存在classpath:walker-deploy.properties文件说明初始化，需要直接跳转到部署页面；<br>
	 * 如果已经存在了，还需要检查lib下面的相关jar是否与文件中的对应，因为有可能会新添加文件；
	 *  
	 */
	public static boolean checkDeployStatus(String deployJarPrefix){
		List<File> availableJars = getMatchDeployedJars(deployJarPrefix);
		if(StringUtils.isEmptyList(availableJars)){
			// 如果没有可用的jar，就不再提示用户。
			deployedStatus.compareAndSet(false, true);
			return deployedStatus.get();
		}
		
		ClassPathResource deployFile = new ClassPathResource(JarDeployer.DEPLOY_FILENAME);
		if(deployFile.exists()){
			// 存在部署文件
			Properties deployProperties = new Properties();
			try {
				deployProperties.load(deployFile.getInputStream());
			} catch (IOException e) {
				throw new ApplicationRuntimeException("加载文件:'"+JarDeployer.DEPLOY_FILENAME+"' 出现异常", e);
			}
			
			// 如果存在部署文件，而且存在内容，需要与现有lib中jar比对
			// 如果配置文件中记录了，比较时间戳，时间戳变化了也要重新部署。
			String jarName = null;
			for(File jarFile : availableJars){
				jarName = jarFile.getName();
				if(deployProperties.containsKey(jarName)){
//					long recordTime = Long.parseLong(deployProperties.getProperty(jarName));
					// 时间间隔在30秒之内都视为部署成功，因为写磁盘时间和java记录时间有延时。
					// 2-不好判断，因为拷贝写入jar的时间和程序运行后部署记录的时间没任何关系
//					if(Math.abs(recordTime - jarFile.lastModified()) >= 30*1000){
//						JarDeployer.DEPLOY_WAIT_FILES.add(jarFile);
//					}
					logger.debug("=============> 找到了一个匹配的(部署过)jar: " + jarName);
					JarDeployer.DEPLOYED_FILES.put(jarName, Long.parseLong(deployProperties.getProperty(jarName)));
				} else {
					logger.debug("-------------> 找到一个未更新的jar,记录并在后续解压:" + jarName);
					JarDeployer.DEPLOY_WAIT_FILES.add(jarFile);
				}
			}
			// 仍然存在需要更新的，如：刚添加了新jar
			if(JarDeployer.DEPLOY_WAIT_FILES.size() > 0){
				return false;
			} else {
				deployedStatus.compareAndSet(false, true);
				return deployedStatus.get();
			}
			
		} else {
			// 不存在部署文件
			try {
				createEmptyFile(JarDeployer.classpathAbsolute + JarDeployer.DEPLOY_FILENAME);
				for(File jarFile : availableJars){
					JarDeployer.DEPLOY_WAIT_FILES.add(jarFile);
				}
				return false;
			} catch (IOException e) {
				throw new ApplicationRuntimeException("创建部署文件失败，系统启动没有成功", e);
			}
		}
	}

	/**
	 * 创建空文件
	 * @param filepath
	 * @throws IOException
	 */
	public static final void createEmptyFile(String filepath) throws IOException{
		File file = new File(filepath);
		if(!file.exists()){
			file.createNewFile();
		} else
			System.out.println("file exist: " + filepath);
	}
	
	private static File[] getAppLibFiles(){
		File appLibFolder = new File(JarDeployer.webappLibAbsolute);
		return appLibFolder.listFiles();
	}
	
	/**
	 * 返回找到的应用可部署的jar集合
	 * @param deployJarPrefix 可部署的jar文件名前缀，如：walkersoft-resource-
	 * @return
	 */
	public static List<File> getMatchDeployedJars(String deployJarPrefix){
		File[] jarList = getAppLibFiles();
		if(jarList != null){
			List<File> result = new ArrayList<File>(8);
			for(File f : jarList){
				// 因为都是jar文件，不会存在其他
				if(f.getName().startsWith(deployJarPrefix)){
					logger.debug("找到了匹配的jar: " + f.getName());
					result.add(f);
				}
			}
			return result;
		}
		return null;
	}
	
	/**
	 * 更新jar部署包的时间戳，并记录到文件。
	 * @throws IOException
	 */
	public static final void updateDeployedJarTimestamp() throws Exception{
		if(DEPLOY_WAIT_FILES.size() > 0){
			// 加载现有的记录更新配置文件
			ClassPathResource deployFile = new ClassPathResource(JarDeployer.DEPLOY_FILENAME);
			Properties deployProperties = new Properties();
			try {
				deployProperties.load(deployFile.getInputStream());
			} catch (IOException e) {
				throw new ApplicationRuntimeException("加载文件:'"+JarDeployer.DEPLOY_FILENAME+"' 出现异常", e);
			}
			
			long timestamp = 0;
			for(File f : DEPLOY_WAIT_FILES){
				JarDeployer jarDeployer = JarDeployer.getWebappLibInstance(f.getName());
				jarDeployer.deploy();
				timestamp = System.currentTimeMillis();
				// 部署时间戳记录到文件
				deployProperties.setProperty(f.getName(), String.valueOf(timestamp));
				// 系统缓存'已部署文件'列表
				JarDeployer.DEPLOYED_FILES.put(f.getName(), timestamp);
			}
			// 持久化更新文件
			deployProperties.store(new FileWriter(new File(classpathAbsolute + DEPLOY_FILENAME)), "更新记录");
		}
		
		// 从系统'等待部署'列表中删除
//		removeWaitDeployList(f.getName());
		DEPLOY_WAIT_FILES.clear();
		deployedStatus.compareAndSet(false, true);
	}
	
	/**
	 * 返回给定jar包中特定属性文件的内容，可能会有多个，因此返回集合
	 * @param jarFileName jar包的文件名，全路径
	 * @param resourcePrefix 指定属性文件的前缀，如：app_
	 * @return
	 */
	public static final List<Properties> getJarRootResources(String jarFileName, String resourcePrefix){
		if(StringUtils.isEmpty(jarFileName)) return null;
		List<Properties> propertiesList = new ArrayList<Properties>(2);
		JarFile jf = null;
		try {
			jf = new JarFile(jarFileName);
			JarEntry je = null;
			Properties properties = null;
			for(Enumeration<JarEntry> e = jf.entries();e.hasMoreElements();){
				je = e.nextElement();
				if(je == null) continue;
				if(je.isDirectory()) continue;
				if(je.getName().startsWith(resourcePrefix)){
					logger.debug("找到了需要的entry: " + je.getName());
					properties = new Properties();
					properties.load(jf.getInputStream(je));
					propertiesList.add(properties);
				} else
					continue;
			}
			return propertiesList;
		} catch (IOException e) {
			throw new ApplicationRuntimeException("加载JAR中的文件出现错误: " + jarFileName, e);
		} finally {
			if(jf != null){
				try {
					jf.close();
				} catch (IOException e) {
				}
			}
		}
	}
	
//	/**
//	 * 返回规则的系统路径，去掉前面的文件协议：file:/或者file:///</br>
//	 * 因为发现JAVA中的<code>File</code>对象不认带协议的文件路径。
//	 * @param path
//	 * @return
//	 */
//	private static String getFileSystemPath(String path){
//		if(path.startsWith("file:/")){
//			path = path.substring(6);
//		} else if(path.startsWith("file:///")){
//			path = path.substring(8);
//		}
//		return path;
//	}
	
	/**
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * test code
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
//		ClassPathResource cpr = new ClassPathResource("com/walker/infrastructure/utils/JarDeployer.class");
//		ClassPathResource cpr = new ClassPathResource(".");
//		System.out.println("file path = " + cpr.getPath());
//		System.out.println("file path = " + JarDeployer.classpathAbsolute);
//		JarDeployer jarDeployer = JarDeployer.getWebappLibInstance("walker-nanoreport-web-resource-0.1.1.jar");
//		System.out.println("resource = " + jarDeployer.getSourcePath());
//		System.out.println("destinat = " + jarDeployer.getDestinationPath());
//		jarDeployer.deploy();
//		System.out.println(JarDeployer.getWebLibPath());
		System.out.println(JarDeployer.classpathAbsolute);
		System.out.println(JarDeployer.webappRootAbsolute);
		// d:/logs/walkersoft-flow-v1.0.jar
		JarDeployer.getJarRootResources("d:/logs/walkersoft-flow-v1.0.jar", "app_");
	}

}