/**
    *
    * Copyright 2003-2006 The Apache Software Foundation
    *
    *  Licensed 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 javax.mail.internet;
  
  import java.io.BufferedOutputStream;
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.FileOutputStream;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.UnsupportedEncodingException;
  import java.util.Enumeration;
  
  import javax.activation.DataHandler;
  import javax.activation.FileDataSource;
  import javax.mail.BodyPart;
  import javax.mail.MessagingException;
  import javax.mail.Multipart;
  import javax.mail.Part;
  import javax.mail.internet.HeaderTokenizer.Token;
  import javax.swing.text.AbstractDocument.Content;
  
  import org.apache.geronimo.mail.util.ASCIIUtil;
  import org.apache.geronimo.mail.util.SessionUtil;
  
  /**
   * @version $Rev: 421852 $ $Date: 2006-07-14 03:02:19 -0700 (Fri, 14 Jul 2006) $
   */
  public class MimeBodyPart extends BodyPart implements MimePart {
  	 // constants for accessed properties
      private static final String MIME_DECODEFILENAME = "mail.mime.decodefilename";
      private static final String MIME_ENCODEFILENAME = "mail.mime.encodefilename";
      private static final String MIME_SETDEFAULTTEXTCHARSET = "mail.mime.setdefaulttextcharset";
      private static final String MIME_SETCONTENTTYPEFILENAME = "mail.mime.setcontenttypefilename";
  
  
      /**
       * The {@link DataHandler} for this Message's content.
       */
      protected DataHandler dh;
      /**
       * This message's content (unless sourced from a SharedInputStream).
       */
      protected byte content[];
      /**
       * If the data for this message was supplied by a {@link SharedInputStream}
       * then this is another such stream representing the content of this message;
       * if this field is non-null, then {@link #content} will be null.
       */
      protected InputStream contentStream;
      /**
       * This message's headers.
       */
      protected InternetHeaders headers;
  
      public MimeBodyPart() {
          headers = new InternetHeaders();
      }
  
      public MimeBodyPart(InputStream in) throws MessagingException {
          headers = new InternetHeaders(in);
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          byte[] buffer = new byte[1024];
          int count;
          try {
              while((count = in.read(buffer, 0, 1024)) != -1)
                  baos.write(buffer, 0, count);
          } catch (IOException e) {
              throw new MessagingException(e.toString(),e);
          }
          content = baos.toByteArray();
      }
  
      public MimeBodyPart(InternetHeaders headers, byte[] content) throws MessagingException {
          this.headers = headers;
          this.content = content;
      }
  
      /**
       * Return the content size of this message.  This is obtained
       * either from the size of the content field (if available) or
       * from the contentStream, IFF the contentStream returns a positive
      * size.  Returns -1 if the size is not available.
      *
      * @return Size of the content in bytes.
      * @exception MessagingException
      */
     public int getSize() throws MessagingException {
         if (content != null) {
             return content.length;
         }
         if (contentStream != null) {
             try {
                 int size = contentStream.available();
                 if (size > 0) {
                     return size;
                 }
             } catch (IOException e) {
             }
         }
         return -1;
     }
 
     public int getLineCount() throws MessagingException {
         return -1;
     }
 
     public String getContentType() throws MessagingException {
         String value = getSingleHeader("Content-Type");
         if (value == null) {
             value = "text/plain";
         }
         return value;
     }
 
     /**
      * Tests to see if this message has a mime-type match with the
      * given type name.
      *
      * @param type   The tested type name.
      *
      * @return If this is a type match on the primary and secondare portion of the types.
      * @exception MessagingException
      */
     public boolean isMimeType(String type) throws MessagingException {
         return new ContentType(getContentType()).match(type);
     }
 
     /**
      * Retrieve the message "Content-Disposition" header field.
      * This value represents how the part should be represented to
      * the user.
      *
      * @return The string value of the Content-Disposition field.
      * @exception MessagingException
      */
     public String getDisposition() throws MessagingException {
         String disp = getSingleHeader("Content-Disposition");
         if (disp != null) {
             return new ContentDisposition(disp).getDisposition();
         }
         return null;
     }
 
     /**
      * Set a new dispostion value for the "Content-Disposition" field.
      * If the new value is null, the header is removed.
      *
      * @param disposition
      *               The new disposition value.
      *
      * @exception MessagingException
      */
     public void setDisposition(String disposition) throws MessagingException {
         if (disposition == null) {
             removeHeader("Content-Disposition");
         }
         else {
             // the disposition has parameters, which we'll attempt to preserve in any existing header.
             String currentHeader = getSingleHeader("Content-Disposition");
             if (currentHeader != null) {
                 ContentDisposition content = new ContentDisposition(currentHeader);
                 content.setDisposition(disposition);
                 setHeader("Content-Disposition", content.toString());
             }
             else {
                 // set using the raw string.
                 setHeader("Content-Disposition", disposition);
             }
         }
     }
 
     /**
      * Retrieves the current value of the "Content-Transfer-Encoding"
      * header.  Returns null if the header does not exist.
      *
      * @return The current header value or null.
      * @exception MessagingException
      */
     public String getEncoding() throws MessagingException {
         // this might require some parsing to sort out.
         String encoding = getSingleHeader("Content-Transfer-Encoding");
         if (encoding != null) {
             // we need to parse this into ATOMs and other constituent parts.  We want the first
             // ATOM token on the string.
             HeaderTokenizer tokenizer = new HeaderTokenizer(encoding, HeaderTokenizer.MIME);
 
             Token token = tokenizer.next();
             while (token.getType() != Token.EOF) {
                 // if this is an ATOM type, return it.
                 if (token.getType() == Token.ATOM) {
                     return token.getValue();
                 }
             }
             // not ATOMs found, just return the entire header value....somebody might be able to make sense of
             // this.
             return encoding;
         }
         // no header, nothing to return.
         return null;
     }
 
 
     /**
      * Retrieve the value of the "Content-ID" header.  Returns null
      * if the header does not exist.
      *
      * @return The current header value or null.
      * @exception MessagingException
      */
     public String getContentID() throws MessagingException {
         return getSingleHeader("Content-ID");
     }
 
     public void setContentID(String cid) throws MessagingException {
         setOrRemoveHeader("Content-ID", cid);
     }
 
     public String getContentMD5() throws MessagingException {
         return getSingleHeader("Content-MD5");
     }
 
     public void setContentMD5(String md5) throws MessagingException {
         setHeader("Content-MD5", md5);
     }
 
     public String[] getContentLanguage() throws MessagingException {
         return getHeader("Content-Language");
     }
 
     public void setContentLanguage(String[] languages) throws MessagingException {
         if (languages == null) {
             removeHeader("Content-Language");
         } else if (languages.length == 1) {
             setHeader("Content-Language", languages[0]);
         } else {
             StringBuffer buf = new StringBuffer(languages.length * 20);
             buf.append(languages[0]);
             for (int i = 1; i < languages.length; i++) {
                 buf.append(',').append(languages[i]);
             }
             setHeader("Content-Language", buf.toString());
         }
     }
 
     public String getDescription() throws MessagingException {
         String description = getSingleHeader("Content-Description");
         if (description != null) {
             try {
                 // this could be both folded and encoded.  Return this to usable form.
                 return MimeUtility.decodeText(MimeUtility.unfold(description));
             } catch (UnsupportedEncodingException e) {
                 // ignore
             }
         }
         // return the raw version for any errors.
         return description;
     }
 
     public void setDescription(String description) throws MessagingException {
         setDescription(description, null);
     }
 
     public void setDescription(String description, String charset) throws MessagingException {
         if (description == null) {
             removeHeader("Content-Description");
         }
         else {
             try {
                 setHeader("Content-Description", MimeUtility.fold(21, MimeUtility.encodeText(description, charset, null)));
             } catch (UnsupportedEncodingException e) {
                 throw new MessagingException(e.getMessage(), e);
             }
         }
     }
 
     public String getFileName() throws MessagingException {
         // see if there is a disposition.  If there is, parse off the filename parameter.
         String disposition = getSingleHeader("Content-Disposition");
         String filename = null;
 
         if (disposition != null) {
             filename = new ContentDisposition(disposition).getParameter("filename");
         }
 
         // if there's no filename on the disposition, there might be a name parameter on a
         // Content-Type header.
         if (filename == null) {
             String type = getSingleHeader("Content-Type");
             if (type != null) {
                 try {
                     filename = new ContentType(type).getParameter("name");
                 } catch (ParseException e) {
                 }
             }
         }
         // if we have a name, we might need to decode this if an additional property is set.
         if (filename != null && SessionUtil.getBooleanProperty(MIME_DECODEFILENAME, false)) {
             try {
                 filename = MimeUtility.decodeText(filename);
             } catch (UnsupportedEncodingException e) {
                 throw new MessagingException("Unable to decode filename", e);
             }
         }
 
         return filename;
     }
 
 
     public void setFileName(String name) throws MessagingException {
         System.out.println("Setting file name to " + name);
         // there's an optional session property that requests file name encoding...we need to process this before
         // setting the value.
         if (name != null && SessionUtil.getBooleanProperty(MIME_ENCODEFILENAME, false)) {
             try {
                 name = MimeUtility.encodeText(name);
             } catch (UnsupportedEncodingException e) {
                 throw new MessagingException("Unable to encode filename", e);
             }
         }
 
         // get the disposition string.
         String disposition = getDisposition();
         // if not there, then this is an attachment.
         if (disposition == null) {
             disposition = Part.ATTACHMENT;
         }
 
         // now create a disposition object and set the parameter.
         ContentDisposition contentDisposition = new ContentDisposition(disposition);
         contentDisposition.setParameter("filename", name);
 
         // serialize this back out and reset.
         setHeader("Content-Disposition", contentDisposition.toString());
 
         // The Sun implementation appears to update the Content-type name parameter too, based on
         // another system property
         if (SessionUtil.getBooleanProperty(MIME_SETCONTENTTYPEFILENAME, true)) {
             ContentType type = new ContentType(getContentType());
             type.setParameter("name", name);
             setHeader("Content-Type", type.toString());
         }
     }
 
     public InputStream getInputStream() throws MessagingException, IOException {
         return getDataHandler().getInputStream();
     }
 
     protected InputStream getContentStream() throws MessagingException {
         if (contentStream != null) {
             return contentStream;
         }
 
         if (content != null) {
             return new ByteArrayInputStream(content);
         } else {
             throw new MessagingException("No content");
         }
     }
 
     public InputStream getRawInputStream() throws MessagingException {
         return getContentStream();
     }
 
     public synchronized DataHandler getDataHandler() throws MessagingException {
         if (dh == null) {
             dh = new DataHandler(new MimePartDataSource(this));
         }
         return dh;
     }
 
     public Object getContent() throws MessagingException, IOException {
         return getDataHandler().getContent();
     }
 
     public void setDataHandler(DataHandler handler) throws MessagingException {
         dh = handler;
         // if we have a handler override, then we need to invalidate any content
         // headers that define the types.  This information will be derived from the
         // data heander unless subsequently overridden.
         removeHeader("Content-Type");
         removeHeader("Content-Transfer-Encoding");
 
     }
 
     public void setContent(Object content, String type) throws MessagingException {
         // Multipart content needs to be handled separately.
         if (content instanceof Multipart) {
             setContent((Multipart)content);
         }
         else {
             setDataHandler(new DataHandler(content, type));
         }
 
     }
 
     public void setText(String text) throws MessagingException {
         setText(text, null);
     }
 
     public void setText(String text, String charset) throws MessagingException {
         // the default subtype is plain text.
         setText(text, charset, "plain");
     }
 
 
     public void setText(String text, String charset, String subtype) throws MessagingException {
         // we need to sort out the character set if one is not provided.
         if (charset == null) {
             // if we have non us-ascii characters here, we need to adjust this.
             if (!ASCIIUtil.isAscii(text)) {
                 charset = MimeUtility.getDefaultMIMECharset();
             }
             else {
                 charset = "us-ascii";
             }
         }
         setContent(text, "text/plain; charset=" + MimeUtility.quote(charset, HeaderTokenizer.MIME));
     }
 
     public void setContent(Multipart part) throws MessagingException {
         setDataHandler(new DataHandler(part, part.getContentType()));
         part.setParent(this);
     }
 
     public void writeTo(OutputStream out) throws IOException, MessagingException {
         headers.writeTo(out, null);
         // add the separater between the headers and the data portion.
         out.write('\r');
         out.write('\n');
         // we need to process this using the transfer encoding type
         OutputStream encodingStream = MimeUtility.encode(out, getEncoding());
         getDataHandler().writeTo(encodingStream);
         encodingStream.flush();
     }
 
     public String[] getHeader(String name) throws MessagingException {
         return headers.getHeader(name);
     }
 
     public String getHeader(String name, String delimiter) throws MessagingException {
         return headers.getHeader(name, delimiter);
     }
 
     public void setHeader(String name, String value) throws MessagingException {
         headers.setHeader(name, value);
     }
 
     /**
      * Conditionally set or remove a named header.  If the new value
      * is null, the header is removed.
      *
      * @param name   The header name.
      * @param value  The new header value.  A null value causes the header to be
      *               removed.
      *
      * @exception MessagingException
      */
     private void setOrRemoveHeader(String name, String value) throws MessagingException {
         if (value == null) {
             headers.removeHeader(name);
         }
         else {
             headers.setHeader(name, value);
         }
     }
 
     public void addHeader(String name, String value) throws MessagingException {
         headers.addHeader(name, value);
     }
 
     public void removeHeader(String name) throws MessagingException {
         headers.removeHeader(name);
     }
 
     public Enumeration getAllHeaders() throws MessagingException {
         return headers.getAllHeaders();
     }
 
     public Enumeration getMatchingHeaders(String[] name) throws MessagingException {
         return headers.getMatchingHeaders(name);
     }
 
     public Enumeration getNonMatchingHeaders(String[] name) throws MessagingException {
         return headers.getNonMatchingHeaders(name);
     }
 
     public void addHeaderLine(String line) throws MessagingException {
         headers.addHeaderLine(line);
     }
 
     public Enumeration getAllHeaderLines() throws MessagingException {
         return headers.getAllHeaderLines();
     }
 
     public Enumeration getMatchingHeaderLines(String[] names) throws MessagingException {
         return headers.getMatchingHeaderLines(names);
     }
 
     public Enumeration getNonMatchingHeaderLines(String[] names) throws MessagingException {
         return headers.getNonMatchingHeaderLines(names);
     }
 
     protected void updateHeaders() throws MessagingException {
         DataHandler handler = getDataHandler();
 
         try {
             // figure out the content type.  If not set, we'll need to figure this out.
             String type = dh.getContentType();
             // parse this content type out so we can do matches/compares.
             ContentType content = new ContentType(type);
             // is this a multipart content?
             if (content.match("multipart/*")) {
                 // the content is suppose to be a MimeMultipart.  Ping it to update it's headers as well.
                 try {
                     MimeMultipart part = (MimeMultipart)handler.getContent();
                     part.updateHeaders();
                 } catch (ClassCastException e) {
                     throw new MessagingException("Message content is not MimeMultipart", e);
                 }
             }
             else if (!content.match("message/rfc822")) {
                 // simple part, we need to update the header type information
                 // if no encoding is set yet, figure this out from the data handler.
                 if (getSingleHeader("Content-Transfer-Encoding") == null) {
                     setHeader("Content-Transfer-Encoding", MimeUtility.getEncoding(handler));
                 }
 
                 // is a content type header set?  Check the property to see if we need to set this.
                 if (getHeader("Content-Type") == null) {
                     if (SessionUtil.getBooleanProperty(MIME_SETDEFAULTTEXTCHARSET, true)) {
                         // is this a text type?  Figure out the encoding and make sure it is set.
                         if (content.match("text/*")) {
                             // the charset should be specified as a parameter on the MIME type.  If not there,
                             // try to figure one out.
                             if (content.getParameter("charset") == null) {
 
                                 String encoding = getEncoding();
                                 // if we're sending this as 7-bit ASCII, our character set need to be
                                 // compatible.
                                 if (encoding != null && encoding.equalsIgnoreCase("7bit")) {
                                     content.setParameter("charset", "us-ascii");
                                 }
                                 else {
                                     // get the global default.
                                     content.setParameter("charset", MimeUtility.getDefaultMIMECharset());
                                 }
                             }
                         }
                     }
                 }
             }
 
             // if we don't have a content type header, then create one.
             if (getSingleHeader("Content-Type") == null) {
                 // get the disposition header, and if it is there, copy the filename parameter into the
                 // name parameter of the type.
                 String disp = getHeader("Content-Disposition", null);
                 if (disp != null) {
                     // parse up the string value of the disposition
                     ContentDisposition disposition = new ContentDisposition(disp);
                     // now check for a filename value
                     String filename = disposition.getParameter("filename");
                     // copy and rename the parameter, if it exists.
                     if (filename != null) {
                         content.setParameter("name", filename);
                     }
                 }
                 // set the header with the updated content type information.
                 setHeader("Content-Type", content.toString());
             }
 
         } catch (IOException e) {
             throw new MessagingException("Error updating message headers", e);
         }
     }
 
     private String getSingleHeader(String name) throws MessagingException {
         String[] values = getHeader(name);
         if (values == null || values.length == 0) {
             return null;
         } else {
             return values[0];
         }
     }
 
 
     /**
      * Attach a file to this body part from a File object.
      *
      * @param file   The source File object.
      *
      * @exception IOException
      * @exception MessagingException
      */
     public void attachFile(File file) throws IOException, MessagingException {
     	FileDataSource dataSource = new FileDataSource(file);
         setDataHandler(new DataHandler(dataSource));
         setFileName(dataSource.getName());
     }
 
 
     /**
      * Attach a file to this body part from a file name.
      *
      * @param file   The source file name.
      *
      * @exception IOException
      * @exception MessagingException
      */
     public void attachFile(String file) throws IOException, MessagingException {
         // just create a File object and attach.
         attachFile(new File(file));
     }
 
 
     /**
      * Save the body part content to a given target file.
      *
      * @param file   The File object used to store the information.
      *
      * @exception IOException
      * @exception MessagingException
      */
     public void saveFile(File file) throws IOException, MessagingException {
     	OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
         // we need to read the data in to write it out (sigh).
         InputStream in = getInputStream();
         try {
             byte[] buffer = new byte[8192];
 	        int length;
 	        while ((length = in.read(buffer)) > 0) {
          		out.write(buffer, 0, length);
             }
         }
         finally {
             // make sure all of the streams are closed before we return
             if (in != null) {
                 in.close();
             }
             if (out != null) {
                 out.close();
             }
         }
     }
 
 
     /**
      * Save the body part content to a given target file.
      *
      * @param file   The file name used to store the information.
      *
      * @exception IOException
      * @exception MessagingException
      */
     public void saveFile(String file) throws IOException, MessagingException {
         saveFile(new File(file));
     }
 }