/****************************************************************
    * 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.avalon.framework.activity.Disposable;
  import org.apache.avalon.framework.container.ContainerUtil;
  import org.apache.james.util.InternetPrintWriter;
  import org.apache.james.util.io.IOUtil;
  
  import javax.activation.DataHandler;
  import javax.mail.MessagingException;
  import javax.mail.Session;
  import javax.mail.internet.InternetHeaders;
  import javax.mail.internet.MimeMessage;
  import javax.mail.util.SharedByteArrayInputStream;
  
  import java.io.BufferedWriter;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.LineNumberReader;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.util.Enumeration;
  
  /**
   * This object wraps a MimeMessage, only loading the underlying MimeMessage
   * object when needed.  Also tracks if changes were made to reduce
   * unnecessary saves.
   */
  public class MimeMessageWrapper
      extends MimeMessage
      implements Disposable {
  
      /**
       * Can provide an input stream to the data
       */
      protected MimeMessageSource source = null;
      
      /**
       * This is false until we parse the message 
       */
      protected boolean messageParsed = false;
      
      /**
       * This is false until we parse the message 
       */
      protected boolean headersModified = false;
      
      /**
       * This is false until we parse the message 
       */
      protected boolean bodyModified = false;
  
      /**
       * Keep a reference to the sourceIn so we can close it
       * only when we dispose the message.
       */
      private InputStream sourceIn;
  
      private MimeMessageWrapper(Session session) throws MessagingException {
          super(session);
          this.headers = null;
          this.modified = false;
          this.headersModified = false;
          this.bodyModified = false;
      }
      
      /**
       * A constructor that instantiates a MimeMessageWrapper based on
       * a MimeMessageSource
       *
       * @param source the MimeMessageSource
       * @throws MessagingException 
       */
      public MimeMessageWrapper(Session session, MimeMessageSource source) throws MessagingException {
          this(session);
          this.source = source;
     }
 
     /**
      * A constructor that instantiates a MimeMessageWrapper based on
      * a MimeMessageSource
      *
      * @param source the MimeMessageSource
      * @throws MessagingException 
      * @throws MessagingException 
      */
     public MimeMessageWrapper(MimeMessageSource source) throws MessagingException {
         this(Session.getDefaultInstance(System.getProperties()),source);
     }
 
     public MimeMessageWrapper(MimeMessage original) throws MessagingException {
         this(Session.getDefaultInstance(System.getProperties()));
         flags = original.getFlags();
         
         // if the original is an unmodified MimeMessageWrapped we clone the headers and
         // take its source.
         /* Temporary commented out because of JAMES-474
         if (original instanceof MimeMessageWrapper && !((MimeMessageWrapper) original).bodyModified) {
             source = ((MimeMessageWrapper) original).source;
             // this probably speed up things
             if (((MimeMessageWrapper) original).headers != null) {
                 ByteArrayOutputStream temp = new ByteArrayOutputStream();
                 InternetHeaders ih = ((MimeMessageWrapper) original).headers;
                 MimeMessageUtil.writeHeadersTo(ih.getAllHeaderLines(),temp);
                 headers = createInternetHeaders(new ByteArrayInputStream(temp.toByteArray()));
                 headersModified = ((MimeMessageWrapper) original).headersModified;
             }
         }
         */
         
         if (source == null) {
             ByteArrayOutputStream bos;
             int size = original.getSize();
             if (size > 0)
                 bos = new ByteArrayOutputStream(size);
             else
                 bos = new ByteArrayOutputStream();
             try {
                 original.writeTo(bos);
                 bos.close();
                 SharedByteArrayInputStream bis =
                         new SharedByteArrayInputStream(bos.toByteArray());
                 parse(bis);
                 bis.close();
                 saved = true;
             } catch (IOException ex) {
                 // should never happen, but just in case...
                 throw new MessagingException("IOException while copying message",
                                 ex);
             }
         }
     }
     
     /**
      * Returns the source ID of the MimeMessageSource that is supplying this
      * with data.
      * @see MimeMessageSource
      */
     public synchronized String getSourceId() {
         return source != null ? source.getSourceId() : null;
     }
 
     /**
      * Load the message headers from the internal source.
      *
      * @throws MessagingException if an error is encountered while
      *                            loading the headers
      */
     protected synchronized void loadHeaders() throws MessagingException {
         if (headers != null) {
             //Another thread has already loaded these headers
             return;
         } else if (source != null) { 
             try {
                 InputStream in = source.getInputStream();
                 try {
                     headers = createInternetHeaders(in);
                 } finally {
                     IOUtil.shutdownStream(in);
                 }
             } catch (IOException ioe) {
                 throw new MessagingException("Unable to parse headers from stream: " + ioe.getMessage(), ioe);
             }
         } else {
             throw new MessagingException("loadHeaders called for a message with no source, contentStream or stream");
         }
     }
 
     /**
      * Load the complete MimeMessage from the internal source.
      *
      * @throws MessagingException if an error is encountered while
      *                            loading the message
      */
     protected synchronized void loadMessage() throws MessagingException {
         if (messageParsed) {
             //Another thread has already loaded this message
             return;
         } else if (source != null) {
             sourceIn = null;
             try {
                 sourceIn = source.getInputStream();
     
                 parse(sourceIn);
                 // TODO is it ok?
                 saved = true;
                 
             } catch (IOException ioe) {
                 IOUtil.shutdownStream(sourceIn);
                 sourceIn = null;
                 throw new MessagingException("Unable to parse stream: " + ioe.getMessage(), ioe);
             }
         } else {
             throw new MessagingException("loadHeaders called for an unparsed message with no source");
         }
     }
 
     /**
      * Get whether the message has been modified.
      *
      * @return whether the message has been modified
      */
     public synchronized boolean isModified() {
         return headersModified || bodyModified || modified;
     }
 
     /**
      * Rewritten for optimization purposes
      */
     public synchronized void writeTo(OutputStream os) throws IOException, MessagingException {
         if (source != null && !isModified()) {
             // We do not want to instantiate the message... just read from source
             // and write to this outputstream
             InputStream in = source.getInputStream();
             try {
                 MimeMessageUtil.copyStream(in, os);
             } finally {
                 IOUtil.shutdownStream(in);
             }
         } else {
             writeTo(os, os);
         }
     }
 
     /**
      * Rewritten for optimization purposes
      */
     public void writeTo(OutputStream os, String[] ignoreList) throws IOException, MessagingException {
         writeTo(os, os, ignoreList);
     }
 
     /**
      * Write
      */
     public void writeTo(OutputStream headerOs, OutputStream bodyOs) throws IOException, MessagingException {
         writeTo(headerOs, bodyOs, new String[0]);
     }
 
     public synchronized void writeTo(OutputStream headerOs, OutputStream bodyOs, String[] ignoreList) throws IOException, MessagingException {
         if (source != null && !isModified()) {
             //We do not want to instantiate the message... just read from source
             //  and write to this outputstream
 
             //First handle the headers
             InputStream in = source.getInputStream();
             try {
                 InternetHeaders headers = new InternetHeaders(in);
                 PrintWriter pos = new InternetPrintWriter(new BufferedWriter(new OutputStreamWriter(headerOs), 512), true);
                 for (Enumeration e = headers.getNonMatchingHeaderLines(ignoreList); e.hasMoreElements(); ) {
                     String header = (String)e.nextElement();
                     pos.println(header);
                 }
                 pos.println();
                 pos.flush();
                 MimeMessageUtil.copyStream(in, bodyOs);
             } finally {
                 IOUtil.shutdownStream(in);
             }
         } else {
             MimeMessageUtil.writeToInternal(this, headerOs, bodyOs, ignoreList);
         }
     }
 
     /**
      * This is the MimeMessage implementation - this should return ONLY the
      * body, not the entire message (should not count headers).  Will have
      * to parse the message.
      */
     public int getSize() throws MessagingException {
         if (!messageParsed) {
             loadMessage();
         }
         return super.getSize();
     }
 
     /**
      * Corrects JavaMail 1.1 version which always returns -1.
      * Only corrected for content less than 5000 bytes,
      * to avoid memory hogging.
      */
     public int getLineCount() throws MessagingException {
             InputStream in=null;
         try{
             in = getContentStream();
         }catch(Exception e){
             return -1;
         }
         if (in == null) {
             return -1;
         }
         //Wrap input stream in LineNumberReader
         //Not sure what encoding to use really...
         try {
             LineNumberReader counter;
             if (getEncoding() != null) {
                 counter = new LineNumberReader(new InputStreamReader(in, getEncoding()));
             } else {
                 counter = new LineNumberReader(new InputStreamReader(in));
             }
             //Read through all the data
             char[] block = new char[4096];
             while (counter.read(block) > -1) {
                 //Just keep reading
             }
             return counter.getLineNumber();
         } catch (IOException ioe) {
             return -1;
         } finally {
             IOUtil.shutdownStream(in);
         }
     }
 
     /**
      * Returns size of message, ie headers and content
      */
     public long getMessageSize() throws MessagingException {
         if (source != null && !isModified()) {
             try {
                 return source.getMessageSize();
             } catch (IOException ioe) {
                 throw new MessagingException("Error retrieving message size", ioe);
             }
         } else {
             return MimeMessageUtil.calculateMessageSize(this);
         }
     }
     
     /**
      * We override all the "headers" access methods to be sure that we
      * loaded the headers 
      */
     
     public String[] getHeader(String name) throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getHeader(name);
     }
 
     public String getHeader(String name, String delimiter) throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getHeader(name, delimiter);
     }
 
     public Enumeration getAllHeaders() throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getAllHeaders();
     }
 
     public Enumeration getMatchingHeaders(String[] names) throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getMatchingHeaders(names);
     }
 
     public Enumeration getNonMatchingHeaders(String[] names) throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getNonMatchingHeaders(names);
     }
 
     public Enumeration getAllHeaderLines() throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getAllHeaderLines();
     }
 
     public Enumeration getMatchingHeaderLines(String[] names) throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getMatchingHeaderLines(names);
     }
 
     public Enumeration getNonMatchingHeaderLines(String[] names) throws MessagingException {
         if (headers == null) {
             loadHeaders();
         }
         return headers.getNonMatchingHeaderLines(names);
     }
 
 
     private synchronized void checkModifyHeaders() throws MessagingException {
         // Disable only-header loading optimizations for JAMES-559
         if (!messageParsed) {
             loadMessage();
         }
         // End JAMES-559
         if (headers == null) {
             loadHeaders();
         }
         modified = true;
         saved = false;
         headersModified = true;
     }
 
     public void setHeader(String name, String value) throws MessagingException {
         checkModifyHeaders();
         super.setHeader(name, value);
     }
 
     public void addHeader(String name, String value) throws MessagingException {
         checkModifyHeaders();
         super.addHeader(name, value);
     }
 
     public void removeHeader(String name) throws MessagingException {
         checkModifyHeaders();
         super.removeHeader(name);
     }
 
     public void addHeaderLine(String line) throws MessagingException {
         checkModifyHeaders();
         super.addHeaderLine(line);
     }
 
 
     /**
      * The message is changed when working with headers and when altering the content.
      * Every method that alter the content will fallback to this one.
      * 
      * @see javax.mail.Part#setDataHandler(javax.activation.DataHandler)
      */
     public synchronized void setDataHandler(DataHandler arg0) throws MessagingException {
         modified = true;
         saved = false;
         bodyModified = true;
         super.setDataHandler(arg0);
     }
 
     /**
      * @see org.apache.avalon.framework.activity.Disposable#dispose()
      */
     public void dispose() {
         if (sourceIn != null) {
             IOUtil.shutdownStream(sourceIn);
         }
         if (source != null) {
             ContainerUtil.dispose(source);
         }
     }
 
     /**
      * @see javax.mail.internet.MimeMessage#parse(java.io.InputStream)
      */
     protected synchronized void parse(InputStream is) throws MessagingException {
         // the super implementation calls
         // headers = createInternetHeaders(is);
         super.parse(is);
         messageParsed = true;
     }
 
     /**
      * If we already parsed the headers then we simply return the updated ones.
      * Otherwise we parse
      * 
      * @see javax.mail.internet.MimeMessage#createInternetHeaders(java.io.InputStream)
      */
     protected synchronized InternetHeaders createInternetHeaders(InputStream is) throws MessagingException {
         /* This code is no more needed: see JAMES-570 and new tests
            
          * InternetHeaders can be a bit awkward to work with due to
          * its own internal handling of header order.  This hack may
          * not always be necessary, but for now we are trying to
          * ensure that there is a Return-Path header, even if just a
          * placeholder, so that later, e.g., in LocalDelivery, when we
          * call setHeader, it will remove any other Return-Path
          * headers, and ensure that ours is on the top. addHeader
          * handles header order, but not setHeader. This may change in
          * future JavaMail.  But if there are other Return-Path header
          * values, let's drop our placeholder.
 
         MailHeaders newHeaders = new MailHeaders(new ByteArrayInputStream((RFC2822Headers.RETURN_PATH + ": placeholder").getBytes()));
         newHeaders.setHeader(RFC2822Headers.RETURN_PATH, null);
         newHeaders.load(is);
         String[] returnPathHeaders = newHeaders.getHeader(RFC2822Headers.RETURN_PATH);
         if (returnPathHeaders.length > 1) newHeaders.setHeader(RFC2822Headers.RETURN_PATH, returnPathHeaders[1]);
         */
         
         // Keep this: skip the headers from the stream
         // we could put that code in the else and simple write an "header" skipping
         // reader for the others.
         MailHeaders newHeaders = new MailHeaders(is);
         
         if (headers != null) {
             return headers;
         } else {
             return newHeaders;
         }
     }
 
     /**
      * @see javax.mail.internet.MimeMessage#getContentStream()
      */
     protected InputStream getContentStream() throws MessagingException {
         if (!messageParsed) {
             loadMessage();
         }
         return super.getContentStream();
     }
 
     /**
      * @see javax.mail.internet.MimeMessage#getRawInputStream()
      */
     public InputStream getRawInputStream() throws MessagingException {
         if (!messageParsed && !isModified() && source != null) {
             InputStream is;
             try {
                 is = source.getInputStream();
                 // skip the headers.
                 new MailHeaders(is);
                 return is;
             } catch (IOException e) {
                 throw new MessagingException("Unable to read the stream: " + e.getMessage(), e);
             }
         } else return super.getRawInputStream();
     }
 
     
     
 }