/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 bvt.gui;

import static org.openoffice.test.common.Testspace.*;
import static testlib.gui.AppTool.*;
import static testlib.gui.UIMap.*;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;
import java.util.concurrent.TimeoutException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStreamReader;
import java.lang.RuntimeException;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.openoffice.test.common.Condition;
import org.openoffice.test.common.DataSheet;
import org.openoffice.test.common.FileUtil;
import org.openoffice.test.common.Logger;
import org.openoffice.test.common.Testspace;
import org.openoffice.test.vcl.widgets.VclDialog;


public class FileExport {
	private static class TestType {

		public TestType(boolean doc, boolean spread, boolean slide) {
			documentT = doc;
			spreadsheetT = spread;
			slideT = slide;
		}

		public boolean documentT;
		public boolean spreadsheetT;
		public boolean slideT;
	};

	private static class ContinuePoint {
		public String path;
		public int i;

		ContinuePoint() {
			path = "";
			i = 0;
		}
	}

	// for example
	// the path is "D:\\aoo\\utaoo\\testspace\\ooxmlsamples"
	String samplespath = "";// a dir
	String outpath = ""; // a dir
	static double timeout = 100;
	static double interval = 0.1;
	double sleeptime = 1;
	boolean bContinue = false;// if failed,next execute from the continue point
	TestType atest = new TestType(true, true, true);// doc,spreadsheet,slide
	ContinuePoint thepoint = null;
	BufferedWriter fwContinue = null;
	String testedlogfile = "";

	private static DataSheet result;
	private String scenario = null;
	private File sourceFile = null;

	public static final VclDialog passwdDlg = dialog("");

	public List<String> recursionfiles(File path, List<String> resultFileName) {
		File[] files = path.listFiles();
		if (files == null)
			return resultFileName;
		for (File f : files) {
			if (f.isDirectory()) {// a path
				if (!f.isHidden() && !f.getName().startsWith(".")) {
					sampledirs.add(f.getPath());
					recursionfiles(f, resultFileName);
				}
			} else {// a file
				if (!f.isHidden() && !f.getName().startsWith(".")) {
					String apath = f.getPath();

					int sepIndex = apath.indexOf(File.separatorChar);
					String userpath = apath.substring(sepIndex);
					String newpath = outpath + userpath;

					File file = new File(newpath);
					File parent = file.getParentFile();
					if (parent != null && !parent.exists()) {
						parent.mkdirs();
					}
					resultFileName.add(f.getPath());
				}
			}
		}
		return resultFileName;
	}

	private String getrealoutpath(String p) {
		String apath = p;

		int sepIndex = apath.indexOf(File.separatorChar);
		int sepIndexLast = apath.lastIndexOf(File.separatorChar);
		String userpath = apath.substring(sepIndex, sepIndexLast);
		String newpath = outpath + userpath;
		File tempFolderFile = new File(newpath);
		if (!tempFolderFile.exists()) {
			tempFolderFile.mkdirs();
		}
		return newpath;
	}

	private List<String> samplelist = null;
	private List<String> sampledirs = null;

	@Rule
	public Logger log = Logger.getLogger(this);

	@BeforeClass
	public static void beforeClass() {
		app.clean();
	}

	@AfterClass
	public static void afterClass() {
		app.stop();
	}

	@Before
	public void before() {

	}

	@After
	public void after() throws Exception {
		app.stop();
	}

	void getcontinuepoint() {

		if (bContinue == false) {
			thepoint.path = "";
			thepoint.i = 0;
			return;
		}
		File ftestedlog = new File(testedlogfile);
		Reader reader = null;
		try {
			reader = new InputStreamReader(new FileInputStream(ftestedlog));
		} catch (FileNotFoundException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		BufferedReader br = new BufferedReader(reader);

		String line = null;
		int countline = 0;
		int m = 0;
		try {
			if ((line = br.readLine()) != null) {
				if (countline == 0) {
					thepoint.path = line;
				} else {

					m = Integer.parseInt(line);
					if (m > 0)
						thepoint.i = m;
				}
			}
		} catch (NumberFormatException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}

	/**
	 * Test Open/SaveAs ooxml file by Aoo
	 * 
	 * @throws Exception
	 */
	@Test
	public void testSaveAs() throws Exception {
		samplelist = new ArrayList<String>();
		sampledirs = new ArrayList<String>();
		thepoint = new ContinuePoint();
		File spacepath = new File(Testspace.getPath());
		File absspath = spacepath.getAbsoluteFile();
		String abspre = absspath.getParent();

		result = new DataSheet(getFile("outputlog" + File.separatorChar
				+ FileExport.class.getName() + ".xml"));
		result.addRow("data", "File Path", "File Size", "Scenario",
				"Exported File Path", "Exported File Size", "Result", "Error");

		testedlogfile = abspre + "testgui" + File.separatorChar + "cases_tested.txt";
		samplespath = "samples";
		
		if (outpath.length() == 0) {
			File workspacepath = Testspace.getFile("output");// ..\\testspace\\output
			outpath = workspacepath.getAbsolutePath();

			// outpath = "D:\\AOOautomation\\Docs sample files\\out";
		}

		if (bContinue)
			getcontinuepoint();

		File samplesDir = Testspace.getFile(samplespath);
		recursionfiles(samplesDir, samplelist);
		ListIterator<String> it = sampledirs.listIterator();

		boolean bstartfromthis = false;
		while (it.hasNext()) {

			String str = (String) it.next();
			if (!bContinue) {
				File afiledir = new File(str);
				dotest(afiledir);
			} else {
				File file = new File(thepoint.path);
				File parent = file.getParentFile();
				if (parent != null) {
					String pathbegin = parent.getAbsolutePath();
					if (pathbegin.equalsIgnoreCase(str)) {
						bstartfromthis = true;

					}
				}
				if (bstartfromthis == true) {
					File afiledir = new File(str);
					dotest(afiledir);
				}
			}
		}
	}

	public void dotest(File samplesDir) throws Exception {
		FilenameFilter testFilter = new FilenameFilter() {
			public boolean accept(File file, String name) {
				if (name.endsWith(".doc") || name.endsWith(".docx")
						|| name.endsWith(".dot") || name.endsWith(".xls")
						|| name.endsWith(".xlsx") || name.endsWith(".ods")
						|| name.endsWith(".ppt") || name.endsWith(".pptx")
						|| name.endsWith(".odp")) {
					// filters files
					return true;
				} else {
					return false;
				}
			}
		};
		File[] files = samplesDir.listFiles(testFilter);
		Arrays.sort(files);
		int nfiles = files.length;
		if (nfiles == 0)
			return;

		int i = thepoint.i;
		for (; i < nfiles; i++) {
			File afile = files[i];
			String path = afile.getAbsolutePath();

			String extName = FileUtil.getFileExtName(path).toLowerCase();
			boolean bShouldTest = false;
			if (extName.equals("doc") || extName.equals("docx")
					|| extName.equals("odt")) {
				bShouldTest = true;
				if (atest.documentT == false)
					continue;
			}
			if (extName.equals("ppt") || extName.equals("pptx")
					|| extName.equals("odp")) {
				bShouldTest = true;
				if (atest.slideT == false)
					continue;
			}
			if (extName.equals("xls") || extName.equals("xlsx")
					|| extName.equals("ods")) {
				bShouldTest = true;
				if (atest.spreadsheetT == false)
					continue;
			}
			if (!bShouldTest)
				continue;
			String exportname = "aoo_" + afile.getName();

			sourceFile = new File(path);

			app.stop();
			app.start();

			if(!Open(path)){
				continue;
			}

			String newpath = getrealoutpath(path);

			// do testing
			if (!savetosameformat(exportname, newpath)) {
				continue;
			}

			if(!Open(path)) {
				continue;

			}
			if (!savetodiffformat(exportname, newpath)) {
				continue;
			}

			if(!Open(path)) {
				continue;

			}

			if (!savetopdfformat(exportname, newpath)) {
				continue;
			}			
		}
	}

	private boolean Open(String path) throws Exception {
		try {
			open(path);
			if (!app.exists())
				throw new RuntimeException();
			HandleBlockers(false);
			if(statusBar.exists(timeout))
				statusBar.waitForEnabled(timeout, interval);
			else
				throw new TimeoutException("time out");
			HandleBlockers(false);
			if (!app.exists())
				throw new RuntimeException();
			return true;
		} catch (Exception e) {
			try {
				String reason = e.getMessage();
				if (reason == null || reason.isEmpty())
					reason = "Opening";
				result.addRow("data", sourceFile.getCanonicalPath(),
						sourceFile.length(), scenario, "", "", "Fail", reason);
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			return false;
		}
	}

	private boolean savetosameformat(String file, String outpath) {
		try {
			File reportDir = Testspace.getFile(outpath);

			String extName = FileUtil.getFileExtName(file).toLowerCase();

			boolean formatchanged = false;
			if (extName.equals("docx")) {
				extName = "doc";
				formatchanged = true;
			} else if (extName.equals("pptx")) {
				extName = "ppt";
				formatchanged = true;
			} else if (extName.equals("xlsx")) {
				extName = "xls";
				formatchanged = true;
			}
			
			scenario = FileUtil.getFileExtName(file).toLowerCase() + " to " + extName;

			int dotIndex = file.lastIndexOf(".");
			String pre = file.substring(0, dotIndex + 1);
			String newfile = pre + extName;

			String saveTo = reportDir + File.separator + file;
			if (formatchanged)
				saveTo = reportDir + File.separator + newfile;
			// Save the text document
			deleteFile(saveTo);
			SaveAs(saveTo);
			Close();
			if(!Open(saveTo))
				return false;

			String exception = "";
			String resultflag = "";
			try {
				Close();
				resultflag = "Pass";
			} catch (Exception e) {
				exception = e.getMessage();
				resultflag = "Fail";
			}

			File targetFile = new File(saveTo);
			result.addRow("data", sourceFile.getCanonicalPath(),
					sourceFile.length(), scenario, saveTo, targetFile.length(),
					resultflag, exception);

			return true;
		} catch (Exception e) {
			try {
				String exception = e.getMessage();
				if (exception == null || exception.isEmpty())
					exception = "Saving to the same format";
				result.addRow("data", sourceFile.getCanonicalPath(),
						sourceFile.length(), scenario, "", "", "Fail", exception);
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}

			return false;
		}
	}

	private boolean savetodiffformat(String file, String outpath) {
		try {
			File reportDir = Testspace.getFile(outpath);

			String extName = FileUtil.getFileExtName(file).toLowerCase();

			String targetExtName = null;

			if (extName.equals("doc") || extName.equals("docx"))
				targetExtName = "odt";
			else if (extName.equals("ppt") || extName.equals("pptx"))
				targetExtName = "odp";
			else if (extName.equals("xls") || extName.equals("xlsx"))
				targetExtName = "ods";
			else if (extName.equals("odt"))
				targetExtName = "doc";
			else if (extName.equals("odp"))
				targetExtName = "ppt";
			else if (extName.equals("ods"))
				targetExtName = "xls";
			
			scenario = extName + " to " + targetExtName;
			
			int dotIndex = file.lastIndexOf(".");
			String pre = file.substring(0, dotIndex + 1);
			String saveTo = reportDir + File.separator + pre + targetExtName;
			deleteFile(saveTo);
			// long base = System.currentTimeMillis();
			SaveAs(saveTo);
			Close();
			if(!Open(saveTo))
				return false;

			String exception = "";
			String resultflag = "";
			try {
				Close();
				resultflag = "Pass";
			} catch (Exception e) {
				exception = e.getMessage();
				resultflag = "Fail";
			}

			File targetFile = new File(saveTo);
			result.addRow("data", sourceFile.getCanonicalPath(),
					sourceFile.length(), scenario, saveTo, targetFile.length(),
					resultflag, exception);

			return true;
		} catch (Exception e) {
			try {
				String exception = e.getMessage();
				if (exception == null || exception.isEmpty())
					exception = "Saving to a different format";
				result.addRow("data", sourceFile.getCanonicalPath(),
						sourceFile.length(), scenario, "", "", "Fail", exception);
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}

			return false;
		}

	}

	private void Close() throws Exception {
		close();
		HandleBlockers(false);
	}

	public static void HandleBlockers(final boolean Positive) throws Exception {
		new Condition() {
			@Override
			public boolean value() {
				while (activeMsgBox.exists()) {

					String context = activeMsgBox.getMessage();
					if (context.toLowerCase().indexOf("has been modified") >= 0
							&& context.toLowerCase().indexOf(
									"do you want to save your changes") >= 0)
						throw new RuntimeException("A wrong dirty flag");
					if (context.toLowerCase().indexOf("read-error") >= 0)
						throw new RuntimeException("Read Error");
					if (context.toLowerCase().indexOf("does not exist") >= 0)
						throw new RuntimeException("File not exist");

					try {
						if (Positive)
							activeMsgBox.ok();
						else
							activeMsgBox.no();
					} catch (Exception e) {
						try {
							if (Positive)
								activeMsgBox.yes();
							else
								activeMsgBox.no();
						} catch (Exception e1) {
							try {
								activeMsgBox.doDefault();
							} catch (Exception e2) {
								try {
									activeMsgBox.ok();
								} catch (Exception e3) {
									activeMsgBox.yes();
								}
							}
						}
					}
				}
				if (passwdDlg.exists()) {
					String caption = passwdDlg.getCaption();
					if (caption.toLowerCase().indexOf(
							"enter password to open file") >= 0)
						throw new RuntimeException("A password protected file");
					if (caption.toLowerCase().indexOf("properties") >= 0)
						throw new RuntimeException("An unsupported format");
					if (SupportedFormats(caption))
						throw new RuntimeException("An unreadable file");
				}
				return true;
			}
		
		}.test(timeout, interval);
	}

	private static boolean SupportedFormats(String filename) {
		if (filename.endsWith(".doc") || filename.endsWith(".docx")
				|| filename.endsWith(".dot") || filename.endsWith(".xls")
				|| filename.endsWith(".xlsx") || filename.endsWith(".ods")
				|| filename.endsWith(".ppt") || filename.endsWith(".pptx")
				|| filename.endsWith(".odp")) {
			return true;
		} else {
			return false;
		}
	}

	private void SaveAs(String newfile) throws Exception {
		saveAs(newfile);
		HandleBlockers(true);
		if(statusBar.exists(timeout))
			statusBar.waitForEnabled(timeout, interval);
		else
			throw new TimeoutException("time out");
	}

	private boolean savetopdfformat(String file, String outpath) {
		try {
			File reportDir = Testspace.getFile(outpath);
			String extName = "pdf";

			int dotIndex = file.lastIndexOf(".");
			String pre = file.substring(0, dotIndex + 1);
			String newfile = pre + extName;

			scenario = FileUtil.getFileExtName(file).toLowerCase() + " to pdf";
			
			String saveTo = reportDir + File.separator + newfile;
			// Save the text document
			app.dispatch(".uno:ExportToPDF");
			pdfGeneralPage.ok();

			submitSaveDlg(saveTo);
			HandleBlockers(true);
			
			if(statusBar.exists(timeout))
				statusBar.waitForEnabled(timeout, interval);
			else
				throw new TimeoutException("time out");

			String outcome = "Pass";
			try {
				Close();
			} catch (Exception e) {
				if (!e.getMessage().matches("A wrong dirty flag"))
					outcome = e.getMessage();
				else
					throw e;
			}

			
			File targetFile = new File(saveTo);
			result.addRow("data", sourceFile.getCanonicalPath(),
					sourceFile.length(), scenario, saveTo, targetFile.length(),
					outcome);

			return true;
		} catch (Exception e) {
			try {
				String reason = e.getMessage();
				if (reason == null || reason.isEmpty())
					reason = "Exporting to pdf format";
				result.addRow("data", sourceFile.getCanonicalPath(),
						sourceFile.length(), scenario, "", "", "Fail", reason);
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}

			return false;
		}
	}

}