/*

 *   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()));

	}

}