/**

  * Free Telco Dictionary

  * Copyright © 2013 František Kučera (frantovo.cz)

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. If not, see <http://www.gnu.org/licenses/>.

  */

 package cz.frantovo.telco.dictionary;

 import static cz.frantovo.telco.dictionary.Xmlns.*;

 import static cz.frantovo.telco.dictionary.Functions.*;

 import java.io.BufferedWriter;

 import java.io.ByteArrayOutputStream;

 import java.io.DataOutputStream;

 import java.io.File;

 import java.io.FileOutputStream;

 import java.io.FileWriter;

 import java.io.IOException;

 import java.text.SimpleDateFormat;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.List;

 import java.util.SortedSet;

 import java.util.TreeSet;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.Transformer;

 import javax.xml.transform.TransformerConfigurationException;

 import javax.xml.transform.TransformerException;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.dom.DOMSource;

 import javax.xml.transform.stream.StreamResult;

 import javax.xml.transform.stream.StreamSource;

 import javax.xml.xpath.XPath;

 import javax.xml.xpath.XPathConstants;

 import javax.xml.xpath.XPathExpression;

 import javax.xml.xpath.XPathExpressionException;

 import javax.xml.xpath.XPathFactory;

 import org.w3c.dom.Document;

 import org.w3c.dom.Node;

 import org.w3c.dom.NodeList;

 import org.xml.sax.SAXException;

 /**

  * <p>

  * Generates dictionary files in StarDict format from source in our XML format.

  * </p>

  *

  * <p>

  * Number format should be: 32-bits unsigned number in network byte order

  * </p>

  *

  * @author Ing. František Kučera (frantovo.cz)

  */

 public class Generator {

 	private static final Logger log = Logger.getLogger(Generator.class.getName());

 	private static final String EML_TO_KEN = "ixumhht68";

 	private final DocumentBuilderFactory documentBuilderFactory;

 	private final DocumentBuilder documentBuilder;

 	private final XPathFactory xpathFactory;

 	private final XPath xpath;

 	private final TransformerFactory xslFactory;

 	private final Transformer xsl;

 	private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy.MM.dd");

 	public Generator() throws ParserConfigurationException, TransformerConfigurationException {

 		documentBuilderFactory = DocumentBuilderFactory.newInstance();

 		documentBuilderFactory.setNamespaceAware(true);

 		documentBuilder = documentBuilderFactory.newDocumentBuilder();

 		xslFactory = TransformerFactory.newInstance();

 		xsl = xslFactory.newTransformer(new StreamSource("concept.xsl"));

 		xpathFactory = XPathFactory.newInstance();

 		xpath = xpathFactory.newXPath();

 		xpath.setNamespaceContext(getNamespaceContext());

 	}

 	private void generate(File folder, String filePrefix) {

 		File infoFile = new File(folder, filePrefix + ".ifo");

 		File dictFile = new File(folder, filePrefix + ".dict");

 		File indexFile = new File(folder, filePrefix + ".idx");

 		File synonymFile = new File(folder, filePrefix + ".syn");

 		FileOutputStream dictOutputStream = null;

 		DataOutputStream synonymOutputStream = null;

 		DataOutputStream indexOutputStream = null;

 		BufferedWriter infoWriter = null;

 		SortedSet<IndexEntry> indexEntries = new TreeSet<>();

 		SortedSet<SynonymsEntry> synonymsEntries = new TreeSet<>();

 		try {

 			dictOutputStream = new FileOutputStream(dictFile);

 			synonymOutputStream = new DataOutputStream(new FileOutputStream(synonymFile));

 			indexOutputStream = new DataOutputStream(new FileOutputStream(indexFile));

 			infoWriter = new BufferedWriter(new FileWriter(infoFile));

 			Document sourceDocument = documentBuilder.parse("../../data/dictionary.xml");

 			XPathExpression termsXPath = xpath.compile("d:term/@completeForm|d:term/@abbreviation");

 			// TODO: tags - labels/descriptions

 			xsl.setParameter("tags", sourceDocument.getElementsByTagNameNS(DICTIONARY, "tags").item(0));

 			long offset = 0;

 			long conceptIndex = 0;

 			for (Node conceptNode : nodeIterable(sourceDocument.getElementsByTagNameNS(DICTIONARY, "concept"))) {

 				ByteArrayOutputStream conceptXhtml = new ByteArrayOutputStream();

 				xsl.transform(new DOMSource(conceptNode), new StreamResult(conceptXhtml));

 				int length = conceptXhtml.size();

 				dictOutputStream.write(conceptXhtml.toByteArray());

 				NodeList nameNodes = (NodeList) termsXPath.evaluate(conceptNode, XPathConstants.NODESET);

 				List<String> names = new ArrayList<>();

 				for (Node nameNode : nodeIterable(nameNodes)) {

 					String name = nameNode.getTextContent().trim();

 					if (!name.isEmpty()) {

 						names.add(name);

 					}

 				}

 				String baseName = names.get(0);

 				IndexEntry indexEntry = new IndexEntry(baseName, offset, length);

 				indexEntries.add(indexEntry);

 				for (int i = 1; i < names.size(); i++) {

 					String name = names.get(i);

 					if (!baseName.equals(name)) {

 						synonymsEntries.add(new SynonymsEntry(indexEntry, name));

 					}

 				}

 				offset = offset + length;

 				conceptIndex++;

 			}

 			writeIndex(indexOutputStream, indexEntries);

 			writeSynonyms(synonymOutputStream, synonymsEntries);

 			indexOutputStream.flush();

 			writeInfo(infoWriter, sourceDocument, conceptIndex + 1, synonymsEntries.size(), indexFile.length());

 		} catch (SAXException | IOException | TransformerException | XPathExpressionException e) {

 			log.log(Level.SEVERE, "unable to generate", e);

 		} finally {

 			close(dictOutputStream);

 			close(synonymOutputStream);

 			close(indexOutputStream);

 			close(infoWriter);

 		}

 	}

 	private void writeIndex(DataOutputStream indexOutputStream, SortedSet<IndexEntry> indexEntries) throws IOException {

 		long ordinal = 0;

 		for (IndexEntry e : indexEntries) {

 			e.serialize(indexOutputStream);

 			e.setOrdinal(ordinal++);

 		}

 	}

 	private void writeSynonyms(DataOutputStream synonymOutputStream, SortedSet<SynonymsEntry> synonymsEntries) throws IOException {

 		for (SynonymsEntry s : synonymsEntries) {

 			s.serialize(synonymOutputStream);

 		}

 	}

 	private void writeInfo(BufferedWriter infoWriter, Document sourceDocument, long wordcount, long synwourdcount, long idxfilesize) throws IOException {

 		// TODO: values from document metadata

 		infoWriter.write("StarDict's dict ifo file\n");

 		infoWriter.write("version=2.4.2\n");

 		infoWriter.write("bookname=Free Telco Dictionary\n");

 		infoWriter.write("wordcount=" + wordcount + "\n");

 		infoWriter.write("synwordcount=" + synwourdcount + "\n");

 		infoWriter.write("idxfilesize=" + idxfilesize + "\n");

 		infoWriter.write("idxoffsetbits=32\n");

 		infoWriter.write("author=František Kučera\n");

 		infoWriter.write("em" + "ail=telco" + "-dictionary." + EML_TO_KEN + "@" + "fran" + "tovo.cz\n");

 		infoWriter.write("website=https://telco.frantovo.cz\n");

 		infoWriter.write("description=A dictionary for telecommunications licensed under GNU FDL\n");

 		infoWriter.write("date=" + dateFormat.format(new Date()) + "\n");

 		infoWriter.write("sametypesequence=h\n");

 	}

 	public static void main(String[] args) {

 		File outputFolder = new File("../../delivery/free-telco-dictionary");

 		outputFolder.mkdir();

 		try {

 			Generator g = new Generator();

 			g.generate(outputFolder, "telco");

 		} catch (ParserConfigurationException | TransformerConfigurationException e) {

 			log.log(Level.SEVERE, "error during initialization", e);

 		}

 	}

 }