/*****************************************************************
    * Licensed to the Apache Software Foundation (ASF) under one   *
    * or more contributor license agreements.  See the NOTICE file *
    * distributed with this work for additional information        *
    * regarding copyright ownership.  The ASF licenses this file   *
    * to you under the Apache License, Version 2.0 (the            *
    * "License"); you may not use this file except in compliance   *
    * with the License.  You may obtain a copy of the License at   *
    *                                                              *
   *   http://www.apache.org/licenses/LICENSE-2.0                 *
   *                                                              *
   * Unless required by applicable law or agreed to in writing,   *
   * software distributed under the License is distributed on an  *
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
   * KIND, either express or implied.  See the License for the    *
   * specific language governing permissions and limitations      *
   * under the License.                                           *
   ****************************************************************/
  package org.apache.james.core;
  
  import org.apache.james.util.InternetPrintWriter;
  import org.apache.james.util.io.IOUtil;
  
  import javax.activation.UnsupportedDataTypeException;
  import javax.mail.MessagingException;
  import javax.mail.internet.MimeMessage;
  import javax.mail.internet.MimeUtility;
  
  import java.io.BufferedWriter;
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.util.Enumeration;
  
  /***
   * Utility class to provide optimized write methods for the various MimeMessage
   * implementations.
   */
  public class MimeMessageUtil {
  
      /***
       * Convenience method to take any MimeMessage and write the headers and body to two
       * different output streams
       */
      public static void writeTo(MimeMessage message, OutputStream headerOs, OutputStream bodyOs) throws IOException, MessagingException {
          writeTo(message, headerOs, bodyOs, null);
      }
  
      /***
       * Convenience method to take any MimeMessage and write the headers and body to two
       * different output streams, with an ignore list
       */
      public static void writeTo(MimeMessage message, OutputStream headerOs, OutputStream bodyOs, String[] ignoreList) throws IOException, MessagingException {
          MimeMessage testMessage = message;
          if (message instanceof MimeMessageCopyOnWriteProxy) {
              MimeMessageCopyOnWriteProxy wr = (MimeMessageCopyOnWriteProxy) message;
              testMessage = wr.getWrappedMessage();
          }
          if (testMessage instanceof MimeMessageWrapper) {
              MimeMessageWrapper wrapper = (MimeMessageWrapper)testMessage;
              if (!wrapper.isModified()) {
                  wrapper.writeTo(headerOs, bodyOs, ignoreList);
                  return;
              }
          }
          writeToInternal(message, headerOs, bodyOs, ignoreList);
      }
  
      /***
       * @param message
       * @param headerOs
       * @param bodyOs
       * @param ignoreList
       * @throws MessagingException
       * @throws IOException
       * @throws UnsupportedDataTypeException
       */
      public static void writeToInternal(MimeMessage message, OutputStream headerOs, OutputStream bodyOs, String[] ignoreList) throws MessagingException, IOException, UnsupportedDataTypeException {
          if(message.getMessageID() == null) {
              message.saveChanges();
          }
  
          writeHeadersTo(message, headerOs, ignoreList);
  
          // Write the body to the output stream
          writeMessageBodyTo(message, bodyOs);
      }
  
      public static void writeMessageBodyTo(MimeMessage message, OutputStream bodyOs) throws IOException, UnsupportedDataTypeException, MessagingException {
          OutputStream bos;
          InputStream bis;
  
          try {
              // Get the message as a stream.  This will encode
              // objects as necessary, and we have some input from
             // decoding an re-encoding the stream.  I'd prefer the
             // raw stream, but see
             bos = MimeUtility.encode(bodyOs, message.getEncoding());
             bis = message.getInputStream();
         } catch(UnsupportedDataTypeException udte) {
             /* If we get an UnsupportedDataTypeException try using
              * the raw input stream as a "best attempt" at rendering
              * a message.
              *
              * WARNING: JavaMail v1.3 getRawInputStream() returns
              * INVALID (unchanged) content for a changed message.
              * getInputStream() works properly, but in this case
              * has failed due to a missing DataHandler.
              *
              * MimeMessage.getRawInputStream() may throw a "no
              * content" MessagingException.  In JavaMail v1.3, when
              * you initially create a message using MimeMessage
              * APIs, there is no raw content available.
              * getInputStream() works, but getRawInputStream()
              * throws an exception.  If we catch that exception,
              * throw the UDTE.  It should mean that someone has
              * locally constructed a message part for which JavaMail
              * doesn't have a DataHandler.
             */
 
             try {
                 bis = message.getRawInputStream();
                 bos = bodyOs;
             } catch(javax.mail.MessagingException _) {
                 throw udte;
             }
         }
         catch(javax.mail.MessagingException me) {
             /* This could be another kind of MessagingException
              * thrown by MimeMessage.getInputStream(), such as a
              * javax.mail.internet.ParseException.
              *
              * The ParseException is precisely one of the reasons
              * why the getRawInputStream() method exists, so that we
              * can continue to stream the content, even if we cannot
              * handle it.  Again, if we get an exception, we throw
              * the one that caused us to call getRawInputStream().
              */
             try {
                 bis = message.getRawInputStream();
                 bos = bodyOs;
             } catch(javax.mail.MessagingException _) {
                 throw me;
             }
         }
 
         try {
             copyStream(bis, bos);
         }
         finally {
             IOUtil.shutdownStream(bis);
         }
     }
 
     /***
      * Convenience method to copy streams
      */
     public static void copyStream(InputStream in, OutputStream out) throws IOException {
         // TODO: This is really a bad way to do this sort of thing.  A shared buffer to
         //       allow simultaneous read/writes would be a substantial improvement
         byte[] block = new byte[1024];
         int read = 0;
         while ((read = in.read(block)) > -1) {
             out.write(block, 0, read);
         }
         out.flush();
     }
 
 
     /***
      * Write the message headers to the given outputstream
      * 
      * @param message
      * @param headerOs
      * @param ignoreList
      * @throws MessagingException
      */
     private static void writeHeadersTo(MimeMessage message, OutputStream headerOs, String[] ignoreList) throws MessagingException {
         //Write the headers (minus ignored ones)
         Enumeration headers = message.getNonMatchingHeaderLines(ignoreList);
         writeHeadersTo(headers, headerOs);
     }
 
     /***
      * Write the message headers to the given outputstream
      * 
      * @param message
      * @param headerOs
      * @param ignoreList
      * @throws MessagingException
      */
     public static void writeHeadersTo(Enumeration headers, OutputStream headerOs) throws MessagingException {
         PrintWriter hos = new InternetPrintWriter(new BufferedWriter(new OutputStreamWriter(headerOs), 512), true);
         while (headers.hasMoreElements()) {
             hos.println((String)headers.nextElement());
         }
         // Print header/data separator
         hos.println();
         hos.flush();
     }
     
     /***
      * @param message
      * @param ignoreList
      * @return
      * @throws MessagingException
      */
     public static InputStream getHeadersInputStream(MimeMessage message, String[] ignoreList) throws MessagingException {
         ByteArrayOutputStream bo = new ByteArrayOutputStream();
         writeHeadersTo(message,bo,ignoreList);
         return new ByteArrayInputStream(bo.toByteArray());
     }
 
 
     /***
      * Slow method to calculate the exact size of a message!
      */
     private static final class SizeCalculatorOutputStream extends OutputStream {
         long size = 0;
 
         public void write(int arg0) throws IOException {
             size++;
         }
 
         public long getSize() {
             return size;
         }
 
         public void write(byte[] arg0, int arg1, int arg2) throws IOException {
             size += arg2;
         }
 
         public void write(byte[] arg0) throws IOException {
             size += arg0.length;
         }
     }
 
     /***
      * @return size of full message including headers
      * 
      * @throws MessagingException if a problem occours while computing the message size
      */
     public static long getMessageSize(MimeMessage message) throws MessagingException {
         //If we have a MimeMessageWrapper, then we can ask it for just the
         //  message size and skip calculating it
         long size = -1;
         
         if (message instanceof MimeMessageWrapper) {
             MimeMessageWrapper wrapper = (MimeMessageWrapper) message;
             size = wrapper.getMessageSize();
         } else if (message instanceof MimeMessageCopyOnWriteProxy) {
             MimeMessageCopyOnWriteProxy wrapper = (MimeMessageCopyOnWriteProxy) message;
             size = wrapper.getMessageSize();
         }
         
         if (size == -1) {
             size = calculateMessageSize(message);
         }
         
         return size;
     }
 
     /***
      * @param message
      * @return the calculated size
      * @throws MessagingException
      */
     public static long calculateMessageSize(MimeMessage message) throws MessagingException {
         long size;
         //SK: Should probably eventually store this as a locally
         //  maintained value (so we don't have to load and reparse
         //  messages each time).
         size = message.getSize();
         if (size != -1) {
             Enumeration e = message.getAllHeaderLines();
             if (e.hasMoreElements()) {
                 size += 2;
             }
             while (e.hasMoreElements()) {
                 // add 2 bytes for the CRLF
                 size += ((String) e.nextElement()).length()+2;
             }
         }
         
         
         if (size == -1) {
             SizeCalculatorOutputStream out = new SizeCalculatorOutputStream();
             try {
                 message.writeTo(out);
             } catch (IOException e) {
                 // should never happen as SizeCalculator does not actually throw IOExceptions.
                 throw new MessagingException("IOException wrapped by getMessageSize",e);
             }
             size = out.getSize();
         }
         return size;
     }
     
 
 }