package com.product.file.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

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

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_ ){
                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.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();
    	}
    	
    }

    private 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();
		}
    }
}