/*

  *   SONEWS News Server

  *   see AUTHORS for the list of contributors

  *

  *   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 org.sonews.storage;

 import java.io.BufferedReader;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.PrintStream;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.io.UnsupportedEncodingException;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Date;

 import java.util.Enumeration;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import javax.mail.Header;

 import javax.mail.MessagingException;

 import javax.mail.Multipart;

 import javax.mail.Session;

 import javax.mail.internet.InternetAddress;

 import javax.mail.internet.MimeBodyPart;

 import javax.mail.internet.MimeMessage;

 import javax.mail.internet.MimeMultipart;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.Transformer;

 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 org.sonews.daemon.NNTPConnection;

 import org.sonews.util.io.Resource;

 import org.w3c.dom.Document;

 import org.xml.sax.SAXException;

 /**

  * This is MimeMessage which enables custom Message-ID header

  * (this header will not be overwritten by the default one like in MimeMessage).

  * 

  * Also add header and body separate serialization.

  * 

  * And can be deserialized from SQL ResultSet

  * 

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

  */

 public class DrupalMessage extends MimeMessage {

 	/**

 	 * If body of message posted by user through NNTP starts with this text,

 	 * it will be treated as formated text in Markdown syntax.

 	 */

 	private static final String MARKDOWN_HEADER = "#!markdown\r\n";

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

 	private static final String MESSAGE_ID_HEADER = "Message-ID";

 	private static final String CRLF = "\r\n";

 	public static final String CHARSET = "UTF-8";

 	private static final String XHTML_CONTENT_TYPE = "text/html; charset=" + CHARSET;

 	private static final String ZNAKČKA_KONCE_ŘÁDKU = "◆";

 	private String messageID;

 	private Long parentID;

 	private Long groupID;

 	private TransformerFactory transformerFactory;

 	private DocumentBuilderFactory documentBuilderFactory;

 	/**

 	 * Initializes XML factories (Transformer, DocumentBuilder).

 	 */

 	private void initFactories() {

 		transformerFactory = TransformerFactory.newInstance();

 		documentBuilderFactory = DocumentBuilderFactory.newInstance();

 		/**

 		 * Komentáře nás nepotřebujeme 

 		 * (a museli bychom je brát v úvahu při dělení odstavců:

 		 * v současné verzi XSLT odstavcovače by nám případný komentář

 		 * rozdělil text na dva odstavce, přestože to má být odstavec jede).

 		 */

 		documentBuilderFactory.setIgnoringComments(true);

 	}

 	/**

 	 * Constructs MIME message from SQL result.

 	 * @param rs ResultSet containing message data. No {@link ResultSet#next()} will be called, just values from current row will be read.

 	 * @param constructBody true if whole message should be constructed | false if we need only message headers (body will be dummy).

 	 */

 	public DrupalMessage(ResultSet rs, String myDomain, boolean constructBody) throws SQLException, UnsupportedEncodingException, MessagingException, TransformerException, IOException, ParserConfigurationException, SAXException {

 		super(Session.getDefaultInstance(System.getProperties()));

 		initFactories();

 		groupID = rs.getLong("group_id");

 		addHeader("Message-id", constructMessageId(rs.getInt("id"), groupID, rs.getString("group_name"), myDomain));

 		addHeader("Newsgroups", rs.getString("group_name"));

 		setFrom(new InternetAddress(rs.getString("sender_email"), rs.getString("sender_name")));

 		setSubject(rs.getString("subject"));

 		setSentDate(new Date(rs.getLong("created")));

 		parentID = rs.getLong("parent_id");

 		if (parentID > 0) {

 			String parentMessageID = constructMessageId(parentID, rs.getInt("group_id"), rs.getString("group_name"), myDomain);

 			addHeader("In-Reply-To", parentMessageID);

 			addHeader("References", parentMessageID);

 		}

 		if (constructBody) {

 			Multipart multipart = new MimeMultipart("alternative");

 			setContent(multipart);

 			/** XHTML part */

 			MimeBodyPart htmlPart = new MimeBodyPart();

 			String xhtmlText = readXhtmlText(

 					rs.getString("text"),

 					rs.getString("subject"),

 					rs.getInt("parent_id"),

 					rs.getString("urlBase"),

 					rs.getString("wwwRead"),

 					rs.getString("wwwPost"));

 			htmlPart.setContent(xhtmlText, XHTML_CONTENT_TYPE);

 			/** Plain text part */

 			MimeBodyPart textPart = new MimeBodyPart();

 			String plainText = formatedToPlainText(xhtmlText);

 			textPart.setText(plainText);

 			//addHeader("Lines", String.valueOf(plainText.split("\n").length));

 			/**

 			 * Thunderbirdu záleží, v jakém pořadí části jsou 

 			 * (když je prostý text druhý, html se nezobrazí),

 			 * KNode zobrazuje HTML správně, i když je na prvním místě.

 			 */

 			multipart.addBodyPart(textPart);

 			multipart.addBodyPart(htmlPart);

 		} else {

 			/** empty body, just headers */

 			setText("");

 		}

 	}

 	/**

 	 * Constructs MIME message from article posted by user.

 	 * @param article article that came through NNTP.

 	 * @throws MessagingException 

 	 */

 	public DrupalMessage(Article article) throws MessagingException {

 		super(Session.getDefaultInstance(System.getProperties()), serializeArticle(article));

 		initFactories();

 		String[] replyToHeaders = getHeader("In-Reply-To");

 		String[] referencesHeaders = getHeader("References");

 		String parentMessageID;

 		if (replyToHeaders != null && replyToHeaders.length == 1) {

 			parentMessageID = replyToHeaders[0];

 		} else if (referencesHeaders != null && referencesHeaders.length == 1) {

 			Pattern p = Pattern.compile("(\\s*<.*>)*\\s*(<.*>)");

 			Matcher m = p.matcher(referencesHeaders[0]);

 			if (m.matches()) {

 				parentMessageID = m.group(2);

 			} else {

 				throw new MessagingException("Message posted by user had invalid References header: " + referencesHeaders[0]);

 			}

 		} else {

 			throw new MessagingException("Message posted by user must have exactly one In-Reply-To header. Reply-To headers: " + Arrays.toString(replyToHeaders) + " Referemces headers: " + Arrays.toString(referencesHeaders));

 		}

 		parentID = parseArticleID(parentMessageID);

 		groupID = parseGroupID(parentMessageID);

 	}

 	private static InputStream serializeArticle(Article a) {

 		byte articleHeaders[] = a.getHeaderSource().getBytes();

 		byte delimiter[] = (NNTPConnection.NEWLINE + NNTPConnection.NEWLINE).getBytes();

 		byte body[] = a.getBody();

 		byte message[] = new byte[articleHeaders.length + delimiter.length + body.length];

 		System.arraycopy(articleHeaders, 0, message, 0, articleHeaders.length);

 		System.arraycopy(delimiter, 0, message, articleHeaders.length, delimiter.length);

 		System.arraycopy(body, 0, message, articleHeaders.length + delimiter.length, body.length);

 		return new ByteArrayInputStream(message);

 	}

 	/**

 	 * @param xhtmlText well-formed XHTML

 	 * @return plain text representation of this formated text

 	 */

 	private String formatedToPlainText(String xhtmlText) {

 		try {

 			Transformer textTransformer = transformerFactory.newTransformer(new StreamSource(Resource.getAsStream("helpers/mimeTextPart.xsl")));

 			StringReader input = new StringReader(xhtmlText);

 			StringWriter output = new StringWriter(xhtmlText.length());

 			textTransformer.transform(new StreamSource(input), new StreamResult(output));

 			return output.toString();

 		} catch (Exception e) {

 			/**

 			 * TODO: lepší ošetření chyby

 			 */

 			log.log(Level.WARNING, "Error while transforming article to plain text", e);

 			return "Při transformaci příspěvku bohužel došlo k chybě.";

 		}

 	}

 	private DOMSource readDOM(String xml) throws ParserConfigurationException, SAXException, IOException {

 		DocumentBuilder db = documentBuilderFactory.newDocumentBuilder();

 		Document d = db.parse(new ByteArrayInputStream(xml.getBytes("UTF-8")));

 		return new DOMSource(d);

 	}

 	private String readXhtmlText(String sourceText, String subject, long parentId, String urlBase, String wwwRead, String wwwPost) throws TransformerException, IOException, ParserConfigurationException, SAXException {

 		/**

 		 * TODO: 

 		 *		- znovupoužívat XSL transformér (nejen v instanci)

 		 *		- používat cache, ukládat si vygenerované články

 		 */

 		String wrappedText = makeSimpleXHTML(sourceText);

 		Transformer paragraphTransformer = transformerFactory.newTransformer(new StreamSource(Resource.getAsStream("helpers/mimeXhtmlPart-make-paragraphs.xsl")));

 		String paragraphedText;

 		boolean tidyWasUsed = false;

 		try {

 			StringWriter output = new StringWriter(2 * wrappedText.length());

 			paragraphTransformer.transform(readDOM(wrappedText), new StreamResult(output));

 			paragraphedText = output.toString();

 		} catch (Exception e) {

 			log.log(Level.FINER, "HTML input was shitty – Tidy had to be called.", e);

 			StringWriter output = new StringWriter(2 * wrappedText.length());

 			paragraphTransformer.transform(readDOM(tidyXhtml(wrappedText)), new StreamResult(output));

 			paragraphedText = output.toString();

 			tidyWasUsed = true;

 		}

 		Transformer xhtmlTransformer = transformerFactory.newTransformer(new StreamSource(Resource.getAsStream("helpers/mimeXhtmlPart.xsl")));

 		xhtmlTransformer.setParameter("isRoot", (parentId == 0));

 		xhtmlTransformer.setParameter("title", subject);

 		xhtmlTransformer.setParameter("urlBase", urlBase);

 		xhtmlTransformer.setParameter("wwwRead", wwwRead);

 		xhtmlTransformer.setParameter("wwwPost", wwwPost);

 		xhtmlTransformer.setParameter("headComment", String.format("Drupal-NNTP bridge. Transformed: %1$tc. Tidy had to be used: %2$b", new Date(), tidyWasUsed));

 		StringReader paragraphedReader = new StringReader(paragraphedText);

 		StringWriter xhtmlWriter = new StringWriter(2 * paragraphedText.length());

 		xhtmlTransformer.transform(new StreamSource(paragraphedReader), new StreamResult(xhtmlWriter));

 		return xhtmlWriter.toString();

 	}

 	/**

 	 * Converts markdown to XHTML.

 	 * @param markdown text in Markdown syntax

 	 * @return XHTML document (with html/body elements)

 	 * @throws StorageBackendException when markdown proces returned any errors 

 	 * (other exceptions are thrown when afterwards XHTML validation fails).

 	 */

 	private String readXhtmlTextMarkdown(String markdown) throws TransformerException, IOException, ParserConfigurationException, SAXException, StorageBackendException {

 		Runtime r = Runtime.getRuntime();

 		Process p = r.exec(new String[]{"sudo", "-u", "markdown", "/usr/bin/markdown"});

 		PrintStream processInput = new PrintStream(p.getOutputStream());

 		processInput.print(markdown);

 		processInput.close();

 		String errors = streamToString(p.getErrorStream());

 		String htmlFragment = streamToString(p.getInputStream());

 		if (errors.length() == 0) {

 			String htmlDocument = makeSimpleXHTML(htmlFragment);

 			String xhtmlDocument = readXhtmlText(htmlDocument, null, -1, null, null, null);

 			return xhtmlDocument;

 		} else {

 			throw new StorageBackendException("Error while transforming Markdown to XHTML: " + errors);

 		}

 	}

 	/**

 	 * Does not parse XML works just with text.

 	 * @param body XHTML fragment that should be put between <body> and </body>

 	 * @return simple XHTML document (body wrapped in html and body tags)

 	 */

 	private static String makeSimpleXHTML(String body) {

 		return "<html xmlns=\"http://www.w3.org/1999/xhtml\"><body>" + body + "</body></html>";

 	}

 	/**

 	 * Does not parse XML works just with text.

 	 * @param xhtml whole XHTML page

 	 * @return content between <body> and </body> tags.

 	 */

 	private static String makeFragmentXHTML(String xhtml) {

 		final String startTag = "<body>";

 		final String endTag = "</body>";

 		int start = xhtml.indexOf(startTag) + startTag.length();

 		int end = xhtml.lastIndexOf(endTag);

 		return xhtml.substring(start, end);

 	}

 	/**

 	 * TODO: refaktorovat, přesunout

 	 */

 	private static String tidyXhtml(String inputText) throws IOException {

 		/*

 		 * Viz https://sourceforge.net/tracker/index.php?func=detail&aid=3424437&group_id=27659&atid=390966

 		 *

 		 * TODO:

 		 *		- použít delší zástupný řetězec, ne jen jeden znak

 		 *		- umísťovat ho jen tam, kde už nějaký text je (ne mezi >\s*<)

 		 */

 		inputText = označKonceŘádků(inputText);

 		Runtime r = Runtime.getRuntime();

 		Process p = r.exec(new String[]{"tidy", // http://tidy.sourceforge.net

 					"-asxml", // well formed XHTML

 					"-numeric", // číselné entity

 					"-utf8", // kódování

 					"--show-warnings", "false", // žádná varování nás nezajímají

 					"--show-errors", "0", // ani chyby

 					"--doctype", "omit", // doctype nepotřebujeme (doplníme si případně vlastní v XSLT)

 					"--logical-emphasis", "true", // em a strong místo i a b

 					"--literal-attributes", "true", // zachovat mezery a konce řádků v atributech

 					"--force-output", "true" // neznámé značky zahodíme, vložíme jen jejich obsah

 				});

 		PrintStream vstupProcesu = new PrintStream(p.getOutputStream());

 		vstupProcesu.print(inputText);

 		vstupProcesu.close();

 		String outputText = streamToString(p.getInputStream());

 		outputText = vraťKonceŘádků(outputText);

 		return outputText;

 	}

 	private static String označKonceŘádků(String text) {

 		text = text.replaceAll(">\\s+<", "> <");

 		text = text.replaceAll("\\n", ZNAKČKA_KONCE_ŘÁDKU + "\n");

 		return text;

 	}

 	private static String vraťKonceŘádků(String text) {

 		text = text.replaceAll(ZNAKČKA_KONCE_ŘÁDKU + "\\n", "\n");

 		text = text.replaceAll(ZNAKČKA_KONCE_ŘÁDKU, "\n");

 		return text;

 	}

 	/**

 	 * TODO: refaktorovat, přesunout

 	 */

 	private static String streamToString(InputStream proud) throws IOException {

 		StringBuilder výsledek = new StringBuilder();

 		BufferedReader buf = new BufferedReader(new InputStreamReader(proud));

 		while (true) {

 			String radek = buf.readLine();

 			if (radek == null) {

 				break;

 			} else {

 				výsledek.append(radek);

 				výsledek.append("\n");

 			}

 		}

 		return výsledek.toString();

 	}

 	public static String constructMessageId(long articleID, long groupID, String groupName, String domainName) {

 		StringBuilder sb = new StringBuilder();

 		sb.append("<");

 		sb.append(articleID);

 		sb.append("-");

 		sb.append(groupID);

 		sb.append("-");

 		sb.append(groupName);

 		sb.append("@");

 		sb.append(domainName);

 		sb.append(">");

 		return sb.toString();

 	}

 	/**

 	 * @return article ID of parent of this message | or null, if this is root article and not reply to another one

 	 */

 	public Long getParentID() {

 		return parentID;

 	}

 	/**

 	 * @return group ID of this message | or null, if this message is not reply to any other one – which is wrong because we have to know the group

 	 */

 	public Long getGroupID() {

 		return groupID;

 	}

 	/**

 	 * 

 	 * @param messageID <{0}-{1}-{2}@domain.tld> where {0} is nntp_id and {1} is group_id and {2} is group_name

 	 * @return array where [0] = nntp_id and [1] = group_id and [2] = group_name or returns null if messageID is invalid

 	 */

 	private static String[] parseMessageID(String messageID) {

 		if (messageID.matches("<[0-9]+\\-[0-9]+\\-[a-z0-9\\.]+@.+>")) {

 			return messageID.substring(1).split("@")[0].split("\\-");

 		} else {

 			return null;

 		}

 	}

 	public static Long parseArticleID(String messageID) {

 		String[] localPart = parseMessageID(messageID);

 		if (localPart == null) {

 			return null;

 		} else {

 			return Long.parseLong(localPart[0]);

 		}

 	}

 	public static Long parseGroupID(String messageID) {

 		String[] localPart = parseMessageID(messageID);

 		if (localPart == null) {

 			return null;

 		} else {

 			return Long.parseLong(localPart[1]);

 			// If needed:

 			// parseGroupName() will be same as this method, just with:

 			// return localPart[2];

 		}

 	}

 	@Override

 	public void setHeader(String name, String value) throws MessagingException {

 		super.setHeader(name, value);

 		if (MESSAGE_ID_HEADER.equalsIgnoreCase(name)) {

 			messageID = value;

 		}

 	}

 	@Override

 	public final void addHeader(String name, String value) throws MessagingException {

 		super.addHeader(name, value);

 		if (MESSAGE_ID_HEADER.equalsIgnoreCase(name)) {

 			messageID = value;

 		}

 	}

 	@Override

 	public void removeHeader(String name) throws MessagingException {

 		super.removeHeader(name);

 		if (MESSAGE_ID_HEADER.equalsIgnoreCase(name)) {

 			messageID = null;

 		}

 	}

 	public void setMessageID(String messageID) {

 		this.messageID = messageID;

 	}

 	@Override

 	protected void updateMessageID() throws MessagingException {

 		if (messageID == null) {

 			super.updateMessageID();

 		} else {

 			setHeader(MESSAGE_ID_HEADER, messageID);

 		}

 	}

 	/**

 	 * Call {@link #saveChanges()} before this method, if you want all headers including such ones like:

 	 * 

 	 * <pre>MIME-Version: 1.0

 	 *Content-Type: multipart/alternative;</pre>

 	 * 

 	 * @return serialized headers

 	 * @throws MessagingException if getAllHeaders() fails

 	 */

 	public String getHeaders() throws MessagingException {

 		StringBuilder sb = new StringBuilder();

 		for (Enumeration eh = getAllHeaderLines(); eh.hasMoreElements();) {

 			sb.append(eh.nextElement());

 			sb.append(CRLF);

 		}

 		return sb.toString();

 	}

 	public byte[] getBody() throws IOException, MessagingException {

 		saveChanges();

 		ArrayList<String> skipHeaders = new ArrayList<String>();

 		for (Enumeration eh = getAllHeaders(); eh.hasMoreElements();) {

 			Header h = (Header) eh.nextElement();

 			skipHeaders.add(h.getName());

 		}

 		ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);

 		writeTo(baos, skipHeaders.toArray(new String[skipHeaders.size()]));

 		return baos.toByteArray();

 	}

 	/**

 	 * Transforms message content to valid XHTML and strips html and body tags.

 	 * When receiving message from user through NNTP 

 	 * this method is used to get text that should be saved into databse.

 	 * @return XHTML fragment – content between <body> and </body> tags.

 	 */

 	public String getBodyXhtmlFragment() throws StorageBackendException {

 		/**

 		 * TODO: podporovat i zprávy přímo v HTML a multipart.

 		 */

 		try {

 			Object c = getContent();

 			if (isMimeType("text/plain") && c instanceof String) {

 				String inputText = (String) c;

 				String xhtml;

 				if (inputText.startsWith(MARKDOWN_HEADER)) {

 					xhtml = readXhtmlTextMarkdown(inputText.substring(MARKDOWN_HEADER.length()));

 				} else {

 					xhtml = readXhtmlText(

 							inputText,

 							getSubject(),

 							getParentID(),

 							null,

 							null,

 							null);

 				}

 				return makeFragmentXHTML(xhtml);

 			} else {

 				throw new StorageBackendException("Only text/plain messages are supported for now – post it as plain text please.");

 			}

 		} catch (Exception e) {

 			throw new StorageBackendException(e);

 		}

 	}

 	public String getBodyPlainText() throws StorageBackendException {

 		/**

 		 * TODO: netransformovat XHTML 2x

 		 */

 		return formatedToPlainText(makeSimpleXHTML(getBodyXhtmlFragment()));

 	}

 }