package com.nilhcem.fakesmtp.server;
   
   import com.nilhcem.fakesmtp.core.ArgsHandler;
   import com.nilhcem.fakesmtp.core.Configuration;
   import com.nilhcem.fakesmtp.core.I18n;
   import com.nilhcem.fakesmtp.model.EmailModel;
   import com.nilhcem.fakesmtp.model.UIModel;
   import org.apache.commons.io.FileUtils;
   import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.IOException;
  import java.io.StringReader;
  import java.nio.charset.Charset;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.List;
  import java.util.Map;
  import java.util.Observable;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * Saves emails and notifies components so they can refresh their views with new data.
   *
   * @author Nilhcem
   * @since 1.0
   */
  public final class MailSaver extends Observable {
  
  	private static final Logger LOGGER = LoggerFactory.getLogger(MailSaver.class);
  	private static final String LINE_SEPARATOR = System.getProperty("line.separator");
  	// This can be a static variable since it is Thread Safe
  	private static final Pattern SUBJECT_PATTERN = Pattern.compile("^Subject: (.*)$");
  
  	private final SimpleDateFormat dateFormat = new SimpleDateFormat("ddMMyyhhmmssSSS");
  
  	/**
  	 * Saves incoming email in file system and notifies observers.
  	 *
  	 * @param from the user who send the email.
  	 * @param to the recipient of the email.
  	 * @param data an InputStream object containing the email.
  	 * @see com.nilhcem.fakesmtp.gui.MainPanel#addObservers to see which observers will be notified
  	 */
  	public void saveEmailAndNotify(String from, String to, InputStream data) {
  		List<String> relayDomains = UIModel.INSTANCE.getRelayDomains();
  
  		if (relayDomains != null) {
  			boolean matches = false;
  			for (String domain : relayDomains) {
  				if (to.endsWith(domain)) {
  					matches = true;
  					break;
  				}
  			}
  
  			if (!matches) {
  				LOGGER.debug("Destination {} doesn't match relay domains", to);
  				return;
  			}
  		}
  
  		// We move everything that we can move outside the synchronized block to limit the impact
  		EmailModel model = new EmailModel();
  		model.setFrom(from);
  		model.setTo(to);
  		String mailContent = convertStreamToString(data);
  		model.setSubject(getSubjectFromStr(mailContent));
  		model.setEmailStr(mailContent);
  
  		synchronized (getLock()) {
  			String filePath = saveEmailToFile(mailContent);
  
  			model.setReceivedDate(new Date());
  			model.setFilePath(filePath);
  
  			setChanged();
  			notifyObservers(model);
  		}
  	}
  
  	/**
  	 * Deletes all received emails from file system.
  	 */
  	public void deleteEmails() {
  		Map<Integer, String> mails = UIModel.INSTANCE.getListMailsMap();
  		if (ArgsHandler.INSTANCE.memoryModeEnabled()) {
  			return;
  		}
  		for (String value : mails.values()) {
  			File file = new File(value);
  			if (file.exists()) {
  				try {
  					if (!file.delete()) {
 						LOGGER.error("Impossible to delete file {}", value);
 					}
 				} catch (SecurityException e) {
 					LOGGER.error("", e);
 				}
 			}
 		}
 	}
 
 	/**
 	 * Returns a lock object.
 	 * <p>
 	 * This lock will be used to make the application thread-safe, and
 	 * avoid receiving and deleting emails in the same time.
 	 * </p>
 	 *
 	 * @return a lock object <i>(which is actually the current instance of the {@code MailSaver} object)</i>.
 	 */
 	public Object getLock() {
 		return this;
 	}
 
 	/**
 	 * Converts an {@code InputStream} into a {@code String} object.
 	 * <p>
 	 * The method will not copy the first 4 lines of the input stream.<br>
 	 * These 4 lines are SubEtha SMTP additional information.
 	 * </p>
 	 *
 	 * @param is the InputStream to be converted.
 	 * @return the converted string object, containing data from the InputStream passed in parameters.
 	 */
 	private String convertStreamToString(InputStream is) {
 		final long lineNbToStartCopy = 4; // Do not copy the first 4 lines (received part)
 		BufferedReader reader = new BufferedReader(new InputStreamReader(is, Charset.forName(I18n.UTF8)));
 		StringBuilder sb = new StringBuilder();
 
 		String line;
 		long lineNb = 0;
 		try {
 			while ((line = reader.readLine()) != null) {
 				if (++lineNb > lineNbToStartCopy) {
 					sb.append(line).append(LINE_SEPARATOR);
 				}
 			}
 		} catch (IOException e) {
 			LOGGER.error("", e);
 		}
 		return sb.toString();
 	}
 
 	/**
 	 * Saves the content of the email passed in parameters in a file.
 	 *
 	 * @param mailContent the content of the email to be saved.
 	 * @return the path of the created file.
 	 */
 	private String saveEmailToFile(String mailContent) {
 		if (ArgsHandler.INSTANCE.memoryModeEnabled()) {
 			return null;
 		}
 		String filePath = String.format("%s%s%s", UIModel.INSTANCE.getSavePath(), File.separator,
 				dateFormat.format(new Date()));
 
 		// Create file
 		int i = 0;
 		File file = null;
 		while (file == null || file.exists()) {
 			String iStr;
 			if (i++ > 0) {
 				iStr = Integer.toString(i);
 			} else {
 				iStr = "";
 			}
 			file = new File(filePath + iStr + Configuration.INSTANCE.get("emails.suffix"));
 		}
 
 		// Copy String to file
 		try {
 			FileUtils.writeStringToFile(file, mailContent);
 		} catch (IOException e) {
 			// If we can't save file, we display the error in the SMTP logs
 			Logger smtpLogger = LoggerFactory.getLogger(org.subethamail.smtp.server.Session.class);
 			smtpLogger.error("Error: Can't save email: {}", e.getMessage());
 		}
 		return file.getAbsolutePath();
 	}
 
 	/**
 	 * Gets the subject from the email data passed in parameters.
 	 *
 	 * @param data a string representing the email content.
 	 * @return the subject of the email, or an empty subject if not found.
 	 */
 	private String getSubjectFromStr(String data) {
 		try {
 			BufferedReader reader = new BufferedReader(new StringReader(data));
 
 			String line;
 			while ((line = reader.readLine()) != null) {
 				 Matcher matcher = SUBJECT_PATTERN.matcher(line);
 				 if (matcher.matches()) {
 					 return matcher.group(1);
 				 }
 			}
 		} catch (IOException e) {
 			LOGGER.error("", e);
 		}
 		return "";
 	}
 }