/*

  *   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.mlgw;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import javax.mail.Address;

 import javax.mail.Authenticator;

 import javax.mail.Message;

 import javax.mail.MessagingException;

 import javax.mail.PasswordAuthentication;

 import javax.mail.internet.InternetAddress;

 import org.sonews.config.Config;

 import org.sonews.storage.Article;

 import org.sonews.storage.Group;

 import org.sonews.storage.Headers;

 import org.sonews.storage.StorageBackendException;

 import org.sonews.storage.StorageManager;

 import org.sonews.util.Log;

 import org.sonews.util.Stats;

 /**

  * Dispatches messages from mailing list to newsserver or vice versa.

  * @author Christian Lins

  * @since sonews/0.5.0

  */

 public class Dispatcher

 {

 	static class PasswordAuthenticator extends Authenticator

 	{

 		@Override

 		public PasswordAuthentication getPasswordAuthentication()

 		{

 			final String username =

 				Config.inst().get(Config.MLSEND_USER, "user");

 			final String password =

 				Config.inst().get(Config.MLSEND_PASSWORD, "mysecret");

 			return new PasswordAuthentication(username, password);

 		}

 	}

 	/**

 	 * Chunks out the email address of the full List-Post header field.

 	 * @param listPostValue

 	 * @return The matching email address or null

 	 */

 	private static String chunkListPost(String listPostValue)

 	{

 		// listPostValue is of form "<mailto:dev@openoffice.org>"

 		Pattern mailPattern = Pattern.compile("(\\w+[-|.])*\\w+@(\\w+.)+\\w+");

 		Matcher mailMatcher = mailPattern.matcher(listPostValue);

 		if (mailMatcher.find()) {

 			return listPostValue.substring(mailMatcher.start(), mailMatcher.end());

 		} else {

 			return null;

 		}

 	}

 	/**

 	 * This method inspects the header of the given message, trying

 	 * to find the most appropriate recipient.

 	 * @param msg

 	 * @param fallback If this is false only List-Post and X-List-Post headers

 	 *                 are examined.

 	 * @return null or fitting group name for the given message.

 	 */

 	private static List<String> getGroupFor(final Message msg, final boolean fallback)

 		throws MessagingException, StorageBackendException

 	{

 		List<String> groups = null;

 		// Is there a List-Post header?

 		String[] listPost = msg.getHeader(Headers.LIST_POST);

 		InternetAddress listPostAddr;

 		if (listPost == null || listPost.length == 0 || "".equals(listPost[0])) {

 			// Is there a X-List-Post header?

 			listPost = msg.getHeader(Headers.X_LIST_POST);

 		}

 		if (listPost != null && listPost.length > 0

 			&& !"".equals(listPost[0]) && chunkListPost(listPost[0]) != null) {

 			// listPost[0] is of form "<mailto:dev@openoffice.org>"

 			listPost[0] = chunkListPost(listPost[0]);

 			listPostAddr = new InternetAddress(listPost[0], false);

 			groups = StorageManager.current().getGroupsForList(listPostAddr.getAddress());

 		} else if (fallback) {

 			Log.get().info("Using fallback recipient discovery for: " + msg.getSubject());

 			groups = new ArrayList<String>();

 			// Fallback to TO/CC/BCC addresses

 			Address[] to = msg.getAllRecipients();

 			for (Address toa : to) // Address can have '<' '>' around

 			{

 				if (toa instanceof InternetAddress) {

 					List<String> g = StorageManager.current().getGroupsForList(((InternetAddress) toa).getAddress());

 					groups.addAll(g);

 				}

 			}

 		}

 		return groups;

 	}

 	/**

 	 * Posts a message that was received from a mailing list to the

 	 * appropriate newsgroup.

 	 * If the message already exists in the storage, this message checks

 	 * if it must be posted in an additional group. This can happen for

 	 * crosspostings in different mailing lists.

 	 * @param msg

 	 */

 	public static boolean toGroup(final Message msg)

 	{

 		if (msg == null) {

 			throw new IllegalArgumentException("Argument 'msg' must not be null!");

 		}

 		try {

 			// Create new Article object

 			Article article = new Article(msg);

 			boolean posted = false;

 			// Check if this mail is already existing the storage

 			boolean updateReq =

 				StorageManager.current().isArticleExisting(article.getMessageID());

 			List<String> newsgroups = getGroupFor(msg, !updateReq);

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

 			if (updateReq) {

 				// Check for duplicate entries of the same group

 				Article oldArticle = StorageManager.current().getArticle(article.getMessageID());

 				if (oldArticle != null) {

 					List<Group> oldGroups = oldArticle.getGroups();

 					for (Group oldGroup : oldGroups) {

 						if (!newsgroups.contains(oldGroup.getName())) {

 							oldgroups.add(oldGroup.getName());

 						}

 					}

 				}

 			}

 			if (newsgroups.size() > 0) {

 				newsgroups.addAll(oldgroups);

 				StringBuilder groups = new StringBuilder();

 				for (int n = 0; n < newsgroups.size(); n++) {

 					groups.append(newsgroups.get(n));

 					if (n + 1 != newsgroups.size()) {

 						groups.append(',');

 					}

 				}

 				Log.get().info("Posting to group " + groups.toString());

 				article.setGroup(groups.toString());

 				//article.removeHeader(Headers.REPLY_TO);

 				//article.removeHeader(Headers.TO);

 				// Write article to database

 				if (updateReq) {

 					Log.get().info("Updating " + article.getMessageID()

 						+ " with additional groups");

 					StorageManager.current().delete(article.getMessageID());

 					StorageManager.current().addArticle(article);

 				} else {

 					Log.get().info("Gatewaying " + article.getMessageID() + " to "

 						+ article.getHeader(Headers.NEWSGROUPS)[0]);

 					StorageManager.current().addArticle(article);

 					Stats.getInstance().mailGatewayed(

 						article.getHeader(Headers.NEWSGROUPS)[0]);

 				}

 				posted = true;

 			} else {

 				StringBuilder buf = new StringBuilder();

 				for (Address toa : msg.getAllRecipients()) {

 					buf.append(' ');

 					buf.append(toa.toString());

 				}

 				buf.append(" " + article.getHeader(Headers.LIST_POST)[0]);

 				Log.get().warning("No group for" + buf.toString());

 			}

 			return posted;

 		} catch (Exception ex) {

 			ex.printStackTrace();

 			return false;

 		}

 	}

 	/**

 	 * Mails a message received through NNTP to the appropriate mailing list.

 	 * This method MAY be called several times by PostCommand for the same

 	 * article.

 	 */

 	public static void toList(Article article, String group)

 		throws IOException, MessagingException, StorageBackendException

 	{

 		// Get mailing lists for the group of this article

 		List<String> rcptAddresses = StorageManager.current().getListsForGroup(group);

 		if (rcptAddresses == null || rcptAddresses.size() == 0) {

 			Log.get().warning("No ML-address for " + group + " found.");

 			return;

 		}

 		for (String rcptAddress : rcptAddresses) {

 			// Compose message and send it via given SMTP-Host

 			String smtpHost = Config.inst().get(Config.MLSEND_HOST, "localhost");

 			int smtpPort = Config.inst().get(Config.MLSEND_PORT, 25);

 			String smtpUser = Config.inst().get(Config.MLSEND_USER, "user");

 			String smtpPw = Config.inst().get(Config.MLSEND_PASSWORD, "mysecret");

 			String smtpFrom = Config.inst().get(

 				Config.MLSEND_ADDRESS, article.getHeader(Headers.FROM)[0]);

 			// TODO: Make Article cloneable()

 			article.getMessageID(); // Make sure an ID is existing

 			article.removeHeader(Headers.NEWSGROUPS);

 			article.removeHeader(Headers.PATH);

 			article.removeHeader(Headers.LINES);

 			article.removeHeader(Headers.BYTES);

 			article.setHeader("To", rcptAddress);

 			//article.setHeader("Reply-To", listAddress);

 			if (Config.inst().get(Config.MLSEND_RW_SENDER, false)) {

 				rewriteSenderAddress(article); // Set the SENDER address

 			}

 			SMTPTransport smtpTransport = new SMTPTransport(smtpHost, smtpPort);

 			smtpTransport.send(article, smtpFrom, rcptAddress);

 			smtpTransport.close();

 			Stats.getInstance().mailGatewayed(group);

 			Log.get().info("MLGateway: Mail " + article.getHeader("Subject")[0]

 				+ " was delivered to " + rcptAddress + ".");

 		}

 	}

 	/**

 	 * Sets the SENDER header of the given MimeMessage. This might be necessary

 	 * for moderated groups that does not allow the "normal" FROM sender.

 	 * @param msg

 	 * @throws javax.mail.MessagingException

 	 */

 	private static void rewriteSenderAddress(Article msg)

 		throws MessagingException

 	{

 		String mlAddress = Config.inst().get(Config.MLSEND_ADDRESS, null);

 		if (mlAddress != null) {

 			msg.setHeader(Headers.SENDER, mlAddress);

 		} else {

 			throw new MessagingException("Cannot rewrite SENDER header!");

 		}

 	}

 }