/*                                                                             
 * Copyright 2004,2005 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 org.apache.axis2.saaj;

import org.apache.axiom.om.OMText;
import org.apache.axiom.om.impl.dom.DOOMAbstractFactory;
import org.apache.axiom.om.impl.dom.DocumentImpl;
import org.apache.axiom.om.impl.dom.TextImpl;
import org.apache.axis2.saaj.util.SAAJDataSource;
import org.apache.axis2.transport.http.HTTPConstants;

import javax.activation.DataHandler;
import javax.activation.UnsupportedDataTypeException;
import javax.xml.soap.AttachmentPart;
import javax.xml.soap.MimeHeader;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPException;
import javax.xml.transform.stream.StreamSource;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Iterator;

/**
 * 
 */
public class AttachmentPartImpl extends AttachmentPart {
    private DataHandler dataHandler;

    private MimeHeaders mimeHeaders = new MimeHeaders();
    private String attachmentFile;

    private OMText omText;
    private boolean isAttachmentReferenced;

    /**
     * Check whether at least one of the headers of this object matches a provided header
     *
     * @param headers
     * @return <b>true</b> if at least one header of this AttachmentPart matches
     *         a header in the provided <code>headers</code> parameter,
     *         <b>false</b> if none of the headers of this AttachmentPart matches
     *         at least one of the header in the provided <code>headers</code> parameter
     */
    public boolean matches(MimeHeaders headers) {
        for (Iterator i = headers.getAllHeaders(); i.hasNext();) {
            MimeHeader hdr = (javax.xml.soap.MimeHeader) i.next();
            String values[] = mimeHeaders.getHeader(hdr.getName());
            boolean found = false;
            if (values != null) {
                for (int j = 0; j < values.length; j++) {
                    if (!hdr.getValue().equalsIgnoreCase(values[j])) {
                        continue;
                    }
                    found = true;
                    break;
                }
            }
            if (!found) {
                return false;
            }
        }
        return true;
    }

    public boolean isAttachmentReferenced() {
        return isAttachmentReferenced;
    }

    public void setAttachmentReferenced(boolean attachmentReferenced) {
        isAttachmentReferenced = attachmentReferenced;
    }

    /**
     * Returns the number of bytes in this <CODE>
     * AttachmentPart</CODE> object.
     *
     * @return the size of this <CODE>AttachmentPart</CODE> object
     *         in bytes or -1 if the size cannot be determined
     * @throws javax.xml.soap.SOAPException if the content of this
     *                                      attachment is corrupted of if there was an exception
     *                                      while trying to determine the size.
     */
    public int getSize() throws SOAPException {
        if (dataHandler == null) {
            return 0;
        }
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        try {
            dataHandler.writeTo(bout);
        } catch (Exception ex) {
            throw new SOAPException(ex);
        }
        return bout.size();
    }

    /**
     * Clears out the content of this <CODE>
     * AttachmentPart</CODE> object. The MIME header portion is left
     * untouched.
     */
    public void clearContent() {
        dataHandler = null;
        omText = null;
    }

    /**
     * Gets the content of this <code>AttachmentPart</code> object as a Java
     * object. The type of the returned Java object depends on
     * <ol>
     * <li> the
     * <code>DataContentHandler</code> object that is used to interpret the bytes
     * </li>
     * <li> the <code>Content-Type</code> given in the header</li>
     * </ol>
     * <p/>
     * For the MIME content types "text/plain", "text/html" and "text/xml", the
     * <code>DataContentHandler</code> object does the conversions to and
     * from the Java types corresponding to the MIME types.
     * For other MIME types,the <code>DataContentHandler</code> object
     * can return an <code>InputStream</code> object that contains the content data
     * as raw bytes.
     * <p/>
     * A JAXM-compliant implementation must, as a minimum, return a
     * <code>java.lang.String</code> object corresponding to any content
     * stream with a <code>Content-Type</code> value of
     * <code>text/plain</code>, a
     * <code>javax.xml.transform.StreamSource</code> object corresponding to a
     * content stream with a <code>Content-Type</code> value of
     * <code>text/xml</code>, a <code>java.awt.Image</code> object
     * corresponding to a content stream with a
     * <code>Content-Type</code> value of <code>image/gif</code> or
     * <code>image/jpeg</code>.  For those content types that an
     * installed <code>DataContentHandler</code> object does not understand, the
     * <code>DataContentHandler</code> object is required to return a
     * <code>java.io.InputStream</code> object with the raw bytes.
     *
     * @return a Java object with the content of this <CODE>
     *         AttachmentPart</CODE> object
     * @throws javax.xml.soap.SOAPException if there is no content set
     *                                      into this <CODE>AttachmentPart</CODE> object or if there
     *                                      was a data transformation error
     */
    public Object getContent() throws SOAPException {
        if (dataHandler == null) {
            throw new SOAPException("No content is present in this AttachmentPart");
        }
        try {
            String contentType = dataHandler.getContentType();
            if (contentType.equals("text/plain") ||
                    contentType.equals("text/xml") ||
                    contentType.equals("text/html")) {

                //For these content types underlying DataContentHandler surely does
                //the conversion to appropriate java object and we will return that java object
                return dataHandler.getContent();
            } else {
                try {
                    return dataHandler.getContent();
                } catch (UnsupportedDataTypeException e) {

                    //If the underlying DataContentHandler can't handle the object contents,
                    //we will return an inputstream of raw bytes represneting the content data
                    return dataHandler.getDataSource().getInputStream();
                }
            }
        } catch (IOException e) {
            throw new SOAPException(e);
        }
    }

    /**
     * Sets the content of this attachment part to that of the
     * given <CODE>Object</CODE> and sets the value of the <CODE>
     * Content-Type</CODE> header to the given type. The type of the
     * <CODE>Object</CODE> should correspond to the value given for
     * the <CODE>Content-Type</CODE>. This depends on the particular
     * set of <CODE>DataContentHandler</CODE> objects in use.
     *
     * @param object      the Java object that makes up
     *                    the content for this attachment part
     * @param contentType the MIME string that
     *                    specifies the type of the content
     * @throws IllegalArgumentException if
     *                                  the contentType does not match the type of the content
     *                                  object, or if there was no <CODE>
     *                                  DataContentHandler</CODE> object for this content
     *                                  object
     * @see #getContent()
     */
    public void setContent(Object object, String contentType) {
        SAAJDataSource source;
        setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, contentType);
        Object contentObject;
        if (object instanceof String) {
            try {
                String s = (String) object;
                java.io.ByteArrayInputStream bais = new java.io.ByteArrayInputStream(s.getBytes());
                source = new SAAJDataSource(bais,
                        SAAJDataSource.MAX_MEMORY_DISK_CACHED,
                        contentType, true);
                extractFilename(source);
                dataHandler = new DataHandler(source);
                contentObject = object;
            } catch (java.io.IOException io) {
                throw new java.lang.IllegalArgumentException("Illegal Argument");
            }
        } else if (object instanceof java.io.InputStream) {
            try {
                source = new SAAJDataSource((java.io.InputStream) object,
                        SAAJDataSource.MAX_MEMORY_DISK_CACHED,
                        contentType, true);
                extractFilename(source);
                dataHandler = new DataHandler(source);
                contentObject = null; // the stream has been consumed
            } catch (java.io.IOException io) {
                throw new java.lang.IllegalArgumentException("Illegal Argument");
            }
        } else if (object instanceof StreamSource) {
            try {
                source = new SAAJDataSource(((StreamSource) object).getInputStream(),
                        SAAJDataSource.MAX_MEMORY_DISK_CACHED,
                        contentType, true);
                extractFilename(source);
                dataHandler = new DataHandler(source);
                contentObject = null; // the stream has been consumed
            } catch (java.io.IOException io) {
                throw new java.lang.IllegalArgumentException("Illegal Argument");
            }
        } else {
            throw new java.lang.IllegalArgumentException("Illegal Argument");
        }
    }

    /**
     * Gets the <CODE>DataHandler</CODE> object for this <CODE>
     * AttachmentPart</CODE> object.
     *
     * @return the <CODE>DataHandler</CODE> object associated with
     *         this <CODE>AttachmentPart</CODE> object
     * @throws javax.xml.soap.SOAPException if there is
     *                                      no data in this <CODE>AttachmentPart</CODE> object
     */
    public DataHandler getDataHandler() throws SOAPException {
//        if (getContent() == null) {
//            throw new SOAPException("No Content present in the Attachment part");
//        }
        //commented to fix AXIS2-778
        if (dataHandler == null) {
            throw new SOAPException("No Content present in the Attachment part");
        }

        return dataHandler;
    }

    /**
     * Sets the given <CODE>DataHandler</CODE> object as the
     * data handler for this <CODE>AttachmentPart</CODE> object.
     * Typically, on an incoming message, the data handler is
     * automatically set. When a message is being created and
     * populated with content, the <CODE>setDataHandler</CODE>
     * method can be used to get data from various data sources into
     * the message.
     *
     * @param datahandler <CODE>DataHandler</CODE> object to
     *                    be set
     * @throws IllegalArgumentException if
     *                                  there was a problem with the specified <CODE>
     *                                  DataHandler</CODE> object
     */
    public void setDataHandler(DataHandler datahandler) {
        if (datahandler != null) {
            this.dataHandler = datahandler;
            setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, datahandler.getContentType());
            omText = DOOMAbstractFactory.getOMFactory().createOMText(dataHandler, true);
        } else {
            throw new IllegalArgumentException("Cannot set null DataHandler");
        }
    }

    /**
     * Removes all MIME headers that match the given name.
     *
     * @param header - the string name of the MIME
     *               header/s to be removed
     */
    public void removeMimeHeader(String header) {
        mimeHeaders.removeHeader(header);
    }

    /**
     * Removes all the MIME header entries.
     */
    public void removeAllMimeHeaders() {
        mimeHeaders.removeAllHeaders();
    }

    /**
     * Gets all the values of the header identified by the given
     * <CODE>String</CODE>.
     *
     * @param name the name of the header; example:
     *             "Content-Type"
     * @return a <CODE>String</CODE> array giving the value for the
     *         specified header
     * @see #setMimeHeader(String, String) setMimeHeader(java.lang.String, java.lang.String)
     */
    public String[] getMimeHeader(String name) {
        return mimeHeaders.getHeader(name);
    }

    /**
     * Changes the first header entry that matches the given name
     * to the given value, adding a new header if no existing
     * header matches. This method also removes all matching
     * headers but the first.
     * <p/>
     * <P>Note that RFC822 headers can only contain US-ASCII
     * characters.</P>
     *
     * @param name  a <CODE>String</CODE> giving the
     *              name of the header for which to search
     * @param value a <CODE>String</CODE> giving the
     *              value to be set for the header whose name matches the
     *              given name
     * @throws IllegalArgumentException if
     *                                  there was a problem with the specified mime header name
     *                                  or value
     */
    public void setMimeHeader(String name, String value) {
        mimeHeaders.setHeader(name, value);
    }

    /**
     * Adds a MIME header with the specified name and value to
     * this <CODE>AttachmentPart</CODE> object.
     * <p/>
     * <P>Note that RFC822 headers can contain only US-ASCII
     * characters.</P>
     *
     * @param name  a <CODE>String</CODE> giving the
     *              name of the header to be added
     * @param value a <CODE>String</CODE> giving the
     *              value of the header to be added
     * @throws IllegalArgumentException if
     *                                  there was a problem with the specified mime header name
     *                                  or value
     */
    public void addMimeHeader(String name, String value) {
        mimeHeaders.addHeader(name, value);
    }

    /**
     * Retrieves all the headers for this <CODE>
     * AttachmentPart</CODE> object as an iterator over the <CODE>
     * MimeHeader</CODE> objects.
     *
     * @return an <CODE>Iterator</CODE> object with all of the Mime
     *         headers for this <CODE>AttachmentPart</CODE> object
     */
    public Iterator getAllMimeHeaders() {
        return mimeHeaders.getAllHeaders();
    }

    /**
     * Retrieves all <CODE>MimeHeader</CODE> objects that match
     * a name in the given array.
     *
     * @param names a <CODE>String</CODE> array with
     *              the name(s) of the MIME headers to be returned
     * @return all of the MIME headers that match one of the names
     *         in the given array as an <CODE>Iterator</CODE>
     *         object
     */
    public Iterator getMatchingMimeHeaders(String names[]) {
        return mimeHeaders.getMatchingHeaders(names);
    }

    /**
     * Retrieves all <CODE>MimeHeader</CODE> objects whose name
     * does not match a name in the given array.
     *
     * @param names a <CODE>String</CODE> array with
     *              the name(s) of the MIME headers not to be returned
     * @return all of the MIME headers in this <CODE>
     *         AttachmentPart</CODE> object except those that match one
     *         of the names in the given array. The nonmatching MIME
     *         headers are returned as an <CODE>Iterator</CODE>
     *         object.
     */
    public Iterator getNonMatchingMimeHeaders(String names[]) {
        return mimeHeaders.getNonMatchingHeaders(names);
    }

    /**
     * Retrieve the OMText
     *
     * @return the OMText
     * @throws SOAPException If omText is not available
     */
    public OMText getOMText() throws SOAPException {
        if (omText == null) {
            throw new SOAPException("OMText set to null");
        }
        return omText;
    }

    public TextImpl getText(DocumentImpl doc) {
        return new TextImpl(doc, omText.getText(), doc.getOMFactory());
    }

    /**
     * Set the filename of this attachment part.
     *
     * @param path the new file path
     */
    protected void setAttachmentFile(String path) {
        attachmentFile = path;
    }

    /**
     * Detach the attachment file from this class, so it is not cleaned up.
     * This has the side-effect of making subsequent calls to
     * getAttachmentFile() return <code>null</code>.
     */
    public void detachAttachmentFile() {
        attachmentFile = null;
    }

    /**
     * Get the filename of this attachment.
     *
     * @return the filename or null for an uncached file
     */
    public String getAttachmentFile() {
        return attachmentFile;
    }

    private void extractFilename(SAAJDataSource source) {

        //check for there being a file
        if (source.getDiskCacheFile() != null) {
            String path = source.getDiskCacheFile().getAbsolutePath();
            setAttachmentFile(path);
        }
    }
}