package com.product.file.util;

import com.aspose.cells.PdfSaveOptions;
import com.aspose.cells.*;
import com.aspose.slides.Presentation;
import com.aspose.words.SaveFormat;
import com.aspose.words.*;
import com.product.core.exception.BaseException;
import com.product.core.spring.context.SpringMVCContextHolder;
import com.product.file.config.FileCode;

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class AsposeUtil {
	private static int OFFICE_XLS = 1;
	private static int OFFICE_WORD = 2;
	private static int OFFICE_PPT = 3;
	private static boolean OFFICE_XLS_ = false;
	private static boolean OFFICE_WORD_ = false;
	private static boolean OFFICE_PPT_ = false;
	//是否初始了license
	private static boolean isInitLicense = false;

	/**
	 * 获取license
	 *
	 * @return
	 */
	public static boolean getLicense(int type) throws BaseException {
		//已经初始过，不再初始
		if (isInitLicense) {
			return true;
		}
		boolean result = true;
		InputStream is = null;
		try {
			if (type == OFFICE_XLS && !OFFICE_XLS_) {
				is = AsposeUtil.class.getClassLoader().getResourceAsStream("license.xml");
				com.aspose.cells.License excel = new com.aspose.cells.License();
				excel.setLicense(is);
				OFFICE_XLS_ = true;
			} else if (type == OFFICE_WORD && !OFFICE_WORD_) {
				//判断根路径是否为web模块

				is = AsposeUtil.class.getClassLoader().getResourceAsStream("license.xml");
				com.aspose.words.License word = new com.aspose.words.License();
				word.setLicense(is);
				OFFICE_WORD_ = true;
			} else if (type == OFFICE_PPT && !OFFICE_PPT_) {
				is = AsposeUtil.class.getClassLoader().getResourceAsStream("license.xml");
				com.aspose.slides.License ppt = new com.aspose.slides.License();
				ppt.setLicense(is);
				OFFICE_PPT_ = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
			result = false;
			throw new BaseException(FileCode.DOC_CONVERT_FALL, e);
		} finally {
			if (is != null) {
				try {
					is.close();
				} catch (IOException e) {
					throw new BaseException(e);
				}
			}
		}
		return result;
	}

	/**
	 * @param officePath
	 * @param OutPutPath
	 * @throws BaseException
	 */
	public static void Excel2Pdf(String officePath, String OutPutPath) throws BaseException {
		// 验证License
		if (!getLicense(1)) {
			return;
		}
		FileOutputStream fileOS = null;
		try {
			File file = new File(OutPutPath);
			if (!file.getParentFile().exists()) {
				file.getParentFile().mkdirs();
			}
			Workbook wb = new Workbook(officePath);// 原始excel路径
			fileOS = new FileOutputStream(OutPutPath);
			//wb.save(fileOS, com.aspose.cells.SaveFormat.PDF);
			PdfSaveOptions pdfSaveOptions = new PdfSaveOptions();
			pdfSaveOptions.setAllColumnsInOnePagePerSheet(true);
			wb.save(fileOS, pdfSaveOptions);
		} catch (Exception e) {
			throw new BaseException(FileCode.DOC_CONVERT_FALL, e);
		} finally {
			if (fileOS != null) {
				try {
					fileOS.flush();
					fileOS.close();
				} catch (IOException e) {
					throw new BaseException(e);
				}
			}
		}
	}

	/**
	 * @param officePath
	 * @param OutPutPath
	 * @throws BaseException
	 */
	public static void xls2xlsx(String officePath, String OutPutPath, String officeType) throws BaseException {
		// 验证License
		if (!getLicense(1)) {
			return;
		}
		if ("xlsx".equals(officeType)) {
			FileUtil.copyFile(new File(officePath), OutPutPath);
			return;
		}
		FileOutputStream fileOS = null;
		try {
			File file = new File(OutPutPath);
			if (!file.getParentFile().exists()) {
				file.getParentFile().mkdirs();
			}
			Workbook wb = new Workbook(officePath);// 原始excel路径
			fileOS = new FileOutputStream(OutPutPath);
			wb.save(fileOS, com.aspose.cells.SaveFormat.XLSX);
		} catch (Exception e) {
			throw new BaseException(FileCode.DOC_CONVERT_FALL, e);
		} finally {
			if (fileOS != null) {
				try {
					fileOS.flush();
					fileOS.close();
				} catch (IOException e) {
					throw new BaseException(e);
				}
			}
		}
	}

	public static void Excel2Html(String officePath, String OutPutPath) throws BaseException {
		// 验证License
		if (!getLicense(1)) {
			return;
		}
		FileOutputStream fileOS = null;
		try {
			File file = new File(OutPutPath);
			if (!file.getParentFile().exists()) {
				file.getParentFile().mkdirs();
			}
			Workbook wb = new Workbook(officePath);// 原始excel路径
			WorksheetCollection sheets = wb.getWorksheets();
			System.out.println("sheet个数：" + sheets.getCount());
			for (int i = 0; i < sheets.getCount(); i++) {
				//setAutoWithHeight(sheets.get(i));
			}
//            HtmlSaveOptions options = new HtmlSaveOptions();
//            options.setPresentationPreference(true);
			fileOS = new FileOutputStream(OutPutPath);
			wb.save(fileOS, com.aspose.cells.SaveFormat.HTML);
		} catch (Exception e) {
			throw new BaseException(FileCode.DOC_CONVERT_FALL, e);
		} finally {
			if (fileOS != null) {
				try {
					fileOS.flush();
					fileOS.close();
				} catch (IOException e) {
					throw new BaseException(e);
				}
			}
		}
	}

	/**
	 * 设置单元格的自动适宽、高
	 *
	 * @param sheet
	 * @throws Exception
	 */
	public static void setAutoWithHeight(Worksheet sheet) throws Exception {
		Cells cells = sheet.getCells();
		int columnCount = cells.getMaxColumn();  //获取表页的最大列数
		int rowCount = cells.getMaxRow();        //获取表页的最大行数
		if (columnCount < 0 || rowCount < 0) return;
		for (int col = 0; col < columnCount; col++) {
			sheet.autoFitColumn(col, 0, rowCount);
		}
		for (int row = 0; row < rowCount; row++) {
			sheet.autoFitRow(row, 0, columnCount);
		}
	}

	/**
	 * @param officePath
	 * @param OutPutPath
	 * @throws BaseException
	 */
	public static void Word2Pdf(String officePath, String OutPutPath) throws BaseException {
		// 验证License
		if (!getLicense(2)) {
			return;
		}
		FileOutputStream fileOS = null;
		try {
			File file = new File(OutPutPath);
			if (!file.getParentFile().exists()) {
				file.getParentFile().mkdirs();
			}
			Document doc = new Document(officePath);// 原始word路径
			fileOS = new FileOutputStream(OutPutPath);
			//不保留修订痕迹
			doc.acceptAllRevisions();
			doc.save(fileOS, com.aspose.words.SaveFormat.PDF);
		} catch (Exception e) {
			throw new BaseException(FileCode.DOC_CONVERT_FALL, e);
		} finally {
			if (fileOS != null) {
				try {
					fileOS.flush();
					fileOS.close();
				} catch (IOException e) {
					throw new BaseException(e);
				}
			}
		}
	}

	/**
	 * @param officePath
	 * @param OutPutPath
	 * @throws BaseException
	 */
	public static void PPT2Pdf(String officePath, String OutPutPath) throws BaseException {
		// 验证License
		if (!getLicense(3)) {
			return;
		}
		FileOutputStream fileOS = null;
		try {
			File PathFile = new File(OutPutPath);
			if (!PathFile.getParentFile().exists()) {
				PathFile.getParentFile().mkdirs();
			}
			InputStream slides = new FileInputStream(officePath);// 原始ppt路径
			Presentation pres = new Presentation(slides);
			fileOS = new FileOutputStream(OutPutPath);
			pres.save(fileOS, com.aspose.slides.SaveFormat.Pdf);
		} catch (Exception e) {
			throw new BaseException(FileCode.DOC_CONVERT_FALL, e);
		} finally {
			if (fileOS != null) {
				try {
					fileOS.flush();
					fileOS.close();
				} catch (IOException e) {
					throw new BaseException(e);
				}
			}
		}
	}

	/**
	 * 文档转换
	 *
	 * @param officePath
	 * @param outFile
	 * @return
	 * @throws BaseException
	 */
	public static String OfficeToPdf(String officePath, String outFile, String officeType) throws BaseException {
		officeType = officeType.toLowerCase();
		SpringMVCContextHolder.getSystemLogger().info("The file of office type:" + officePath);
		if ("pdf".equals(officeType)) {
			return outFile;
		}
		File file = new File(officePath);
		//判断当前office文件是否已经转为PDF,如果已转为PDF就不需要再次转换。
		if (file.exists()) {
			if (officeType.equals("doc") || officeType.equals("docx")) {
				Word2Pdf(officePath, outFile);
			} else if (officeType.equals("xls") || officeType.equals("xlsx")) {
                Excel2Pdf(officePath,outFile);
//				Excel2Html(officePath, outFile);
//                xls2xlsx(officePath,outFile,officeType);
			} else if (officeType.equals("ppt") || officeType.equals("pptx")) {
				PPT2Pdf(officePath, outFile);
			} else {
				throw new BaseException(FileCode.DOC_CONVERT_NOT_SUPPORT_FILE_FALL);
			}
		} else {
			throw new BaseException(FileCode.DOC_CONVERT_FILE_NOT_EXIST_FALL);
		}
		return outFile;
	}

	/**
	 * 文档转换
	 *
	 * @param officePath
	 * @return
	 */
	public static String OfficeToPdf(String officePath) {

		String[] split = officePath.split("⌒");
		int lastIndex = split[0].lastIndexOf(".");
		int lastNameIndex = split[0].lastIndexOf("/");

		String officeType = split[0].substring(lastIndex + 1);
		String officeName = split[0].substring(lastNameIndex + 1, lastIndex);
		String OutPutPath = split[0].substring(0, lastNameIndex + 1) + "office/";
		System.out.println("输出目录：" + OutPutPath);
		File file = new File(split[0]);
		//判断当前office文件是否已经转为PDF,如果已转为PDF就不需要再次转换。
		if (file.exists()) {
			//"doc", "docx", "xls","xlsx", "ppt", "pptx"
			try {
				if (officeType.equals("doc") || officeType.equals("docx")) {
					Word2Pdf(split[0], OutPutPath + "/" + officeName + ".pdf");
				} else if (officeType.equals("xls") || officeType.equals("xlsx")) {
//                	Excel2Html(split[0],OutPutPath+"/"+officeName+".html");
					xls2xlsx(split[0], OutPutPath + "/" + officeName + ".xlsx", officeType);
				} else if (officeType.equals("ppt") || officeType.equals("pptx")) {
					PPT2Pdf(split[0], OutPutPath + "/" + officeName + ".pdf");
				} else {
					System.out.println("无法识别该文件！");
					return "Error";
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			return "NotExists";
		}
		return OutPutPath + officeName;
	}

	/**
	 * word文档的合并
	 *
	 * @param targetWordFile
	 * @param sourceWordFile
	 * @return
	 * @throws Exception
	 */
	public static File mergeWord(String targetWordFile, String sourceWordFile) throws BaseException {
		File target = new File(targetWordFile);
		File source = new File(sourceWordFile);
		return mergeWord(target, source);
	}

	/**
	 * word文档的合并
	 *
	 * @param
	 * @param
	 * @return
	 * @throws Exception
	 */
	public static File mergeWord(File target, File source) throws BaseException {

		if (!target.exists() && !source.exists()) {
			return null;
		} else if (!source.exists() && target.exists()) {
			return target;
		} else if (source.exists() && !target.exists()) {
			return source;
		}
		// 验证License
		if (!getLicense(OFFICE_WORD)) {
			return null;
		}
		FileInputStream tin = null;
		FileInputStream sin = null;
		FileOutputStream out = null;
		String temp = target.getParent() + File.separator + "mergeTemp";
		File temp_target = new File(temp + File.separator + target.getName());
		try {
			tin = new FileInputStream(target);
			sin = new FileInputStream(source);
			Document targetDoc = new Document(tin);
			Document sourceDoc = new Document(sin);
			docBlankProcess(targetDoc);
			targetDoc.appendDocument(sourceDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING);
//	    	NodeCollection t =sourceDoc.getChildNodes();
//			for (int c = 0; c < t.getCount(); c++) {
//				targetDoc.getChildNodes().add(t.get(c));
//			}
			File dir = new File(temp);
			if (!dir.exists()) {
				dir.mkdirs();
			}
			if (temp_target.exists()) {
				temp_target.delete();
			}
			if (temp_target.createNewFile()) {
				out = new FileOutputStream(temp_target);
				targetDoc.save(out, SaveFormat.DOCX);
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new BaseException(FileCode.DOC_MERGE_FALL, e);
		} finally {
			try {
				if (tin != null) {
					tin.close();
				}
				if (sin != null) {
					sin.close();
				}
				if (out != null) {
					out.flush();
					out.close();
				}
			} catch (IOException e) {
				throw new BaseException(FileCode.DOC_MERGE_FALL, e);
			}
		}
		return temp_target;
	}

	public static void docBlankProcess(Document targetDoc) {
		NodeCollection nodes = targetDoc.getChildNodes(NodeType.PARAGRAPH, true);
		System.out.println(nodes.getCount());
		List<Node> ss = new ArrayList<>();
		for (Paragraph para : (Iterable<Paragraph>) nodes) {
			System.out.println("===========================");
			System.out.println(para.isEndOfSection());
			System.out.println(para.hasChildNodes());
			String text = para.getText();
			if ("\r".equals(text)) System.out.println("\\\\r");
			else if ("\f".equals(text)) System.out.println("\\\\f");
			else if ("".equals(text.trim())) System.out.println("空格");
			else System.out.println(text);

			NodeCollection pnodes = para.getChildNodes();
			if (pnodes.getCount() == 0) para.appendChild(new Run(targetDoc, "a"));
			if (para.isEndOfSection()) para.appendChild(new Run(targetDoc, "B"));
			System.out.println("sub nodes:" + pnodes.getCount());
			for (int i = 0; i < pnodes.getCount(); i++) {
				Node d = pnodes.get(i);
				System.out.println("type:" + NodeType.getName(d.getNodeType()));

				if ("\r".equals(text)) System.out.println("\\\\r");
				else if ("\f".equals(text)) System.out.println("\\\\f");
				else if ("".equals(text.trim())) System.out.println("空格");
				else System.out.println(text);
				if ("BOOKMARK_END".equals(NodeType.getName(d.getNodeType()))) {
					BookmarkEnd b = (BookmarkEnd) d;
				}
				if (d.getNodeType() == NodeType.SHAPE) {
					ss.add(d);
				}
			}


		}
		for (Node d : ss) {
			d.remove();
		}

	}

	public static File appendDoc(File source, File target) throws Exception {
		return new File(appendDoc(source.getPath(), target.getPath(), false));
	}

	public static String appendDoc(String sohuyepath, String xuyepath, boolean includeSection) throws Exception {
		// 验证License
		if (!getLicense(OFFICE_WORD)) {
			return null;
		}
		Document dstDoc = new Document(sohuyepath);
		Document srcDoc = new Document(xuyepath);
		System.out.println("目标文档页数：" + dstDoc.getPageCount() + " | 源文档页数：" + srcDoc.getPageCount());
		if (includeSection) {
			Iterator<Section> var3 = srcDoc.getSections().iterator();
			while (var3.hasNext()) {
				Section srcSection = (Section) var3.next();
				Node dstNode = dstDoc.importNode(srcSection, true, 0);
				dstDoc.appendChild(dstNode);
			}
		} else {
			Node node = dstDoc.getLastSection().getBody().getLastParagraph();
			if (node == null) {
				node = new Paragraph(srcDoc);
				dstDoc.getLastSection().getBody().appendChild(node);
			}

			if (node.getNodeType() != 8 & node.getNodeType() != 5) {
				throw new Exception("Use appendDoc(dstDoc, srcDoc, true) instead of appendDoc(dstDoc, srcDoc, false)");
			}

			insertDocumentAfterNode(node, dstDoc, srcDoc);
		}
		File f = new File(sohuyepath);
		dstDoc.save(f.getParent() + "/merge/" + f.getName());
		return f.getParent() + "/merge/" + f.getName();
	}

	private static void insertDocumentAfterNode(Node insertAfterNode, Document mainDoc, Document srcDoc)
			throws Exception {
		if (insertAfterNode.getNodeType() != 8 & insertAfterNode.getNodeType() != 5) {
			throw new Exception("The destination node should be either a paragraph or table.");
		} else {
			CompositeNode dstStory = insertAfterNode.getParentNode();

			while (null != srcDoc.getLastSection().getBody().getLastParagraph()
					&& !srcDoc.getLastSection().getBody().getLastParagraph().hasChildNodes()) {
				srcDoc.getLastSection().getBody().getLastParagraph().remove();
			}

			NodeImporter importer = new NodeImporter(srcDoc, mainDoc, 1);
			int sectCount = srcDoc.getSections().getCount();

			for (int sectIndex = 0; sectIndex < sectCount; ++sectIndex) {
				Section srcSection = srcDoc.getSections().get(sectIndex);
				int nodeCount = srcSection.getBody().getChildNodes().getCount();

				for (int nodeIndex = 0; nodeIndex < nodeCount; ++nodeIndex) {
					Node srcNode = srcSection.getBody().getChildNodes().get(nodeIndex);
					Node newNode = importer.importNode(srcNode, true);
					dstStory.insertAfter(newNode, insertAfterNode);
					insertAfterNode = newNode;
				}
			}

		}
	}

	/**
	 * 把源文档内容放到最后一页的页末
	 *
	 * @param sohuyepath
	 * @return
	 * @throws Exception
	 */
	private static void appendDocToPageTail(String sohuyepath) throws Exception {
		Document dstDoc = new Document(sohuyepath);
		int destPages = dstDoc.getPageCount();
		System.out.println("合并合的最后总页数：" + destPages);
		Node lastNode = dstDoc.getLastSection().getBody().getLastChild();
		Paragraph lp = null;
		if (lastNode.getNodeType() == NodeType.PARAGRAPH) {
			lp = (Paragraph) lastNode;
			Node ld = lp.getFirstChild();
			while (ld != null && ld.getNodeType() != NodeType.SHAPE && ld.getNodeType() != NodeType.RUN && ld.getNodeType() != NodeType.TABLE) {
				System.out.println("type name " + NodeType.getName(ld.getNodeType()));
				ld = ld.getPreviousSibling();
			}
		}
		System.out.println("最后一节点：" + NodeType.getName(lastNode.getNodeType()));
		for (int i = 0; i < 40; i++) {
			Run t = new Run(dstDoc, "======\r");
			if (lp != null) {
				lp.insertBefore(t, lp.getLastChild());
				System.out.println("子元素数：" + lp.getChildNodes().getCount());
			}
			System.out.println("合并合的最后总页数：" + dstDoc.getPageCount());
			if (destPages < dstDoc.getPageCount()) {
				System.out.println("================分页=================");
			}
		}
		File ff = new File(sohuyepath);
		dstDoc.save(ff.getParent() + "/merge/" + ff.getName(), SaveFormat.DOCX);
	}

	public static void main(String args[]) {
//    	String file="E:/工作内容.xlsx";
//    	String file="E:/爆破母线.xls";
//    	String file="E:/采集提取日志表结构.xlsx";
		String file = "E:/FE信息系统国产化解决方案V1.0.docx";
//    	AsposeUtil.OfficeToPdf(file);

//    	AsposeUtil.mergeWord("E:\\QQ\\住房担保置换公司.docx","E:\\QQ\\住房担保置换公司2.docx");
//    	try {
//    		processDocPage();
//    	}catch(Exception e) {
//    		e.printStackTrace();
//    	}
		try {
//			String sohuyepath="E:/QQ/住房担保置换公司.docx";
//			String xuyepath="E:/QQ/FE信息系统国产化解决方案V1.0.docx";
//			String npath=appendDoc(sohuyepath, xuyepath, false);
			String tail = "E:/QQ/住房担保置换公司2.docx";
//            appendDoc(npath, tail, false);
			appendDocToPageTail(tail);


		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}