package pl.psnc.dl.ege.tei;
   
   import java.io.BufferedOutputStream;
   import java.io.BufferedWriter;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.FileOutputStream;
   import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.util.UUID;
  import java.util.zip.ZipOutputStream;
  
  import javax.xml.transform.stream.StreamSource;
  
  import net.sf.saxon.s9api.Processor;
  import net.sf.saxon.s9api.QName;
  import net.sf.saxon.s9api.SaxonApiException;
  import net.sf.saxon.s9api.Serializer;
  import net.sf.saxon.s9api.XdmAtomicValue;
  import net.sf.saxon.s9api.XdmDestination;
  import net.sf.saxon.s9api.XdmNode;
  import net.sf.saxon.s9api.XsltCompiler;
  import net.sf.saxon.s9api.XsltExecutable;
  import net.sf.saxon.s9api.XsltTransformer;
  
  import org.tei.docx.DocXPropertiesProvider;
  import org.tei.exceptions.ConfigurationException;
  import org.tei.utils.FileUtils;
  import org.tei.utils.SaxonProcFactory;
  import org.tei.utils.XMLUtils;
  
  import pl.psnc.dl.ege.utils.EGEIOUtils;
  
  /**
   * <p>
   * Class responsible for DocX document transformation operations.
   * </p>
   * Performs transformation from DocX to TEI XML format and vice versa.
   * 
   * @author mariuszs
   * 
   */
  class DocXConverter {
  
  	private String directoryName;
  
  	private File zipFile;
  
  	private File teiArchive;
  
  	/**
  	 * provides all the properties that we might need.
  	 */
  	private DocXPropertiesProvider propertiesProvider;
  
  	private String directoryNameURI;
  
  	/**
  	 * Defines which directories are copied to and from the archive
  	 */
  	private String[] archiveDirectoriesToCopy = new String[] { "word/media",
  			"word/embeddings", "word/fonts" };
  
  	/**
  	 * Constructs a docx object from the empty template
  	 * 
  	 * @param teiDoc
  	 * @param propertiesProvider
  	 * @throws ConfigurationException
  	 * @throws IOException
  	 */
  	public DocXConverter(DocXPropertiesProvider propertiesProvider)
  			throws ConfigurationException, IOException {
  		this.propertiesProvider = propertiesProvider;
  		initTemplate();
  	}
  
  	/**
  	 * Alternative constructor : can specify if created object is for DocX->XML
  	 * conversion or XML->DocX.
  	 * 
  	 * @param pp
  	 * @param toXml
  	 * @throws IOException
  	 * @throws ConfigurationException
  	 */
  	public DocXConverter(DocXPropertiesProvider pp, boolean toXml)
  			throws IOException, ConfigurationException {
  		this.propertiesProvider = pp;
  		if (!toXml) {
  			initTemplate();
  		} else {
  			String tmpDir = propertiesProvider.docx_pp_getTempDir();
  			String uid = UUID.randomUUID().toString();
  			directoryName = tmpDir + File.separator + uid;
 			this.directoryNameURI = new File(directoryName).toURI().toString();
 		}
 	}
 
 	/*
 	 * Initialization for XML->DocX transformation - unpacking template file.
 	 */
 	private void initTemplate() throws IOException, ConfigurationException {
 		// copy template somewhere
 		File templateFile = new File(propertiesProvider
 				.docx_pp_getDocXTemplateFile());
 		try {
 			InputStream in = new FileInputStream(templateFile);
 			unzipData(in);
 		} catch (FileNotFoundException e) {
 			ConfigurationException ic = new ConfigurationException(
 					"Could not load docx template at: "
 							+ propertiesProvider.docx_pp_getDocXTemplateFile());
 			ic.initCause(e);
 			throw ic;
 		}
 	}
 
 	/**
 	 * Unzips the .docx file
 	 * 
 	 * @param in
 	 * @throws IOException
 	 * @throws FileNotFoundException
 	 */
 	private void unzipData(InputStream in) throws FileNotFoundException,
 			IOException {
 		// where should we unzip the file to
 		String tmpDir = propertiesProvider.docx_pp_getTempDir();
 		// name of the directory
 		String uid = UUID.randomUUID().toString();
 		directoryName = tmpDir + File.separator + uid;
 		this.directoryNameURI = new File(directoryName).toURI().toString();
 		FileUtils.unzipFile(in, new File(directoryName));
 	}
 
 	/**
 	 * Constructs XML TEI document from DocX version.
 	 * 
 	 * @param is
 	 * @param os
 	 * @return
 	 * @throws SaxonApiException
 	 * @throws IOException
 	 * @throws FileNotFoundException
 	 */
 	public void docXToTEI(InputStream is, OutputStream os)
 			throws SaxonApiException, IOException {
 
 		String tmpDir = propertiesProvider.docx_pp_getTempDir();
 		String tmpArchiveDirName = tmpDir + File.separator
 				+ UUID.randomUUID().toString();
 		File tmpArchiveDir = new File(tmpArchiveDirName);
 		tmpArchiveDir.mkdir();
 		try{
 		XdmNode tei = getTEI(is);
 		try {
 			XMLUtils.storeDocument(tei, new File(tmpArchiveDirName
 					+ File.separator + "tei.xml"));
 		} catch (IOException ex) {
 			throw ex;
 		}
 
 		// copy directories
 		for (String dirName : archiveDirectoriesToCopy) {
 			File dir = new File(directoryName + File.separator + dirName);
 			if (dir.exists() && dir.isDirectory()) {
 				// try to create necessary directories
 				if (dirName.indexOf('/') != -1
 						&& !dirName.substring(0, dirName.lastIndexOf('/'))
 								.equals("")) {
 					File dirToCreate = new File(tmpArchiveDirName
 							+ File.separator
 							+ dirName.substring(0, dirName.lastIndexOf('/')));
 					if (!dirToCreate.isDirectory())
 						dirToCreate.mkdirs();
 				}
 
 				// copy directory
 				try {
 					FileUtils.copyDir(dir, new File(tmpArchiveDirName
 							+ File.separator
 							+ dirName.substring(dirName.lastIndexOf('/'),dirName.length())));
 				} catch (IOException e) {
 					e.printStackTrace();
 				}
 			}
 		}
 		// pack tmp dir to zip and send it to output stream.
 		zipToStream(os, tmpArchiveDir);
 		}finally{
 			EGEIOUtils.deleteDirectory(tmpArchiveDir);
 		}
 	}
 
 	/*
 	 * Gets xml TEI document from docx
 	 */
 	private XdmNode getTEI(InputStream is) throws FileNotFoundException,
 			IOException, SaxonApiException {
 
 		FileUtils.unzipFile(is, new File(directoryName));
 		File dxF = new File(directoryName + File.separator + "word"
 				+ File.separator + "document.xml");
 		Processor proc = SaxonProcFactory.getProcessor();
 		net.sf.saxon.s9api.DocumentBuilder builder = proc.newDocumentBuilder();
 		XdmNode doc = builder.build(dxF);
 
 		XsltCompiler comp = proc.newXsltCompiler();
 		XsltExecutable normalizerExec = comp
 				.compile(new StreamSource(new File(propertiesProvider
 						.docx_pp_getStylesheetNormalizeWordStyles())));
 		XsltExecutable docx2teiExec = comp.compile(new StreamSource(new File(
 				propertiesProvider.docx_pp_getStylesheetDocx2TEI())));
 		XsltTransformer normalizer = normalizerExec.load();
 		XsltTransformer docx2tei = docx2teiExec.load();
 
 		// set directory
 		normalizer.setParameter(new QName("word-directory"),
 				new XdmAtomicValue(directoryNameURI));
 		docx2tei.setParameter(new QName("word-directory"), new XdmAtomicValue(
 				directoryNameURI));
 
 		// transform part1
 		normalizer.setInitialContextNode(doc);
 		XdmDestination tmpDest = new XdmDestination();
 		normalizer.setDestination(tmpDest);
 		normalizer.transform();
 
 		// transform part2
 		XdmDestination result = new XdmDestination();
 		docx2tei.setInitialContextNode(tmpDest.getXdmNode());
 		docx2tei.setDestination(result);
 		docx2tei.transform();
 
 		return result.getXdmNode();
 	}
 
 	/**
 	 * Merges a TEI document back into a docx
 	 * 
 	 * @param teiDoc
 	 */
 	public void mergeTEI(XdmNode teiDoc) throws SaxonApiException,
 			FileNotFoundException, IOException {
 		// prepare transformation
 		Processor proc = SaxonProcFactory.getProcessor();
 		XsltCompiler comp = proc.newXsltCompiler();
 		XsltExecutable toDocXExec = comp.compile(new StreamSource(new File(
 				propertiesProvider.docx_pp_getStylesheetTEI2Docx())));
 		XsltTransformer toDocX = toDocXExec.load();
 
 		toDocX.setParameter(new QName("word-directory"), new XdmAtomicValue(
 				directoryNameURI));
 
 		// transform and write back to document.xml
 		File wordDotXMLFile = new File(directoryName + File.separator + "word"
 				+ File.separator + "document.xml");
 		Serializer result = new Serializer();
 		Writer writer = new BufferedWriter(new OutputStreamWriter(
 				new FileOutputStream(wordDotXMLFile), "UTF-8"));
 		result.setOutputWriter(writer);
 		toDocX.setInitialContextNode(teiDoc);
 		toDocX.setDestination(result);
 		toDocX.transform();
 		writer.close();
 		// remove original core.xml file
 		File orgCoreFile = new File(directoryName + File.separator + "docProps"
 				+ File.separator + "core.xml");
 		orgCoreFile.delete();
 		// move new core.xml
 		File newCoreFile = new File(directoryName + File.separator + "docProps"
 				+ File.separator + "newcore.xml");
 		newCoreFile.renameTo(orgCoreFile);
 
 	}
 
 	/**
 	 * Packs selected directory into streamed zip archive.
 	 * 
 	 * @param os
 	 * @param dir
 	 * @throws IOException
 	 */
 	public void zipToStream(OutputStream os, File dir) throws IOException {
 		ZipOutputStream zipOs = new ZipOutputStream(
 				new BufferedOutputStream(os));
 		EGEIOUtils.constructZip(dir, zipOs, "");
 		zipOs.close();
 	}
 
 	public void cleanUp() {
 		// delete temporary dir
 		EGEIOUtils.deleteDirectory(new File(directoryName));
 
 		// delete zip file
 		if (null != zipFile && zipFile.exists())
 			zipFile.delete();
 
 		// delete archive
 		if (null != teiArchive && teiArchive.exists())
 			teiArchive.delete();
 
 	}
 
 	public String getDirectoryName() {
 		return directoryName;
 	}
 
 }