/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.xml.internal.messaging.saaj.soap;

import java.io.*;

import java.util.*;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.activation.DataHandler;

import javax.activation.DataSource;

import javax.xml.soap.*;

import javax.xml.transform.Source;

import javax.xml.transform.stream.StreamSource;

import com.sun.xml.internal.messaging.saaj.packaging.mime.Header;

import com.sun.xml.internal.messaging.saaj.packaging.mime.internet.*;

import com.sun.xml.internal.messaging.saaj.packaging.mime.util.*;

import com.sun.xml.internal.messaging.saaj.packaging.mime.MessagingException;

import com.sun.xml.internal.messaging.saaj.SOAPExceptionImpl;

import com.sun.xml.internal.messaging.saaj.soap.impl.EnvelopeImpl;

import com.sun.xml.internal.messaging.saaj.util.*;

import com.sun.xml.internal.org.jvnet.mimepull.MIMEPart;

/**

 * The message implementation for SOAP messages with

 * attachments. Messages for specific profiles will likely extend this

 * MessageImpl class and add more value for that particular profile.

 *

 * @author Anil Vijendran (akv@eng.sun.com)

 * @author Rajiv Mordani (rajiv.mordani@sun.com)

 * @author Manveen Kaur (manveen.kaur@sun.com)

 */

public abstract class MessageImpl

    extends SOAPMessage

    implements SOAPConstants {

    public static final String CONTENT_ID             = "Content-ID";

    public static final String CONTENT_LOCATION       = "Content-Location";

    protected static final Logger log =

        Logger.getLogger(LogDomainConstants.SOAP_DOMAIN,

                         "com.sun.xml.internal.messaging.saaj.soap.LocalStrings");

    protected static final int PLAIN_XML_FLAG      = 1;      // 00001

    protected static final int MIME_MULTIPART_FLAG = 2;      // 00010

    protected static final int SOAP1_1_FLAG = 4;             // 00100

    protected static final int SOAP1_2_FLAG = 8;             // 01000

    //protected static final int MIME_MULTIPART_XOP_FLAG = 14; // 01110

    protected static final int MIME_MULTIPART_XOP_SOAP1_1_FLAG = 6;  // 00110

    protected static final int MIME_MULTIPART_XOP_SOAP1_2_FLAG = 10; // 01010

    protected static final int XOP_FLAG = 13;                // 01101

    protected static final int FI_ENCODED_FLAG     = 16;     // 10000

    protected MimeHeaders headers;

    protected ContentType contentType;

    protected SOAPPartImpl soapPartImpl;

    protected FinalArrayList attachments;

    protected boolean saved = false;

    protected byte[] messageBytes;

    protected int messageByteCount;

    protected HashMap properties = new HashMap();

    // used for lazy attachment initialization

    protected MimeMultipart multiPart = null;

    protected boolean attachmentsInitialized = false;

    /**

     * True if this part is encoded using Fast Infoset.

     * MIME -> application/fastinfoset

     */

    protected boolean isFastInfoset = false;

    /**

     * True if the Accept header of this message includes

     * application/fastinfoset

     */

    protected boolean acceptFastInfoset = false;

    protected MimeMultipart mmp = null;

    // if attachments are present, don't read the entire message in byte stream in saveTo()

    private boolean optimizeAttachmentProcessing = true;

    private InputStream inputStreamAfterSaveChanges = null;

    // switch back to old MimeMultipart incase of problem

    private static boolean switchOffBM = false;

    private static boolean switchOffLazyAttachment = false;

    private static boolean useMimePull = false;

    static {

            String s = SAAJUtil.getSystemProperty("saaj.mime.optimization");

            if ((s != null) && s.equals("false")) {

                switchOffBM = true;

            }

            s = SAAJUtil.getSystemProperty("saaj.lazy.mime.optimization");

            if ((s != null) && s.equals("false")) {

                switchOffLazyAttachment = true;

            }

            useMimePull = SAAJUtil.getSystemBoolean("saaj.use.mimepull");

    }

    //property to indicate optimized serialization for lazy attachments

    private boolean lazyAttachments = false;

    // most of the times, Content-Types are already all lower cased.

    // String.toLowerCase() works faster in this case, so even if you

    // are only doing one comparison, it pays off to use String.toLowerCase()

    // than String.equalsIgnoreCase(). When you do more than one comparison,

    // the benefits of String.toLowerCase() dominates.

    //

    //

    // for FI,

    //   use application/fastinfoset for SOAP 1.1

    //   use application/soap+fastinfoset for SOAP 1.2

    // to speed up comparisons, test methods always use lower cases.

    /**

     * @param primary

     *      must be all lower case

     * @param sub

     *      must be all lower case

     */

    private static boolean isSoap1_1Type(String primary, String sub) {

        return primary.equalsIgnoreCase("text") && sub.equalsIgnoreCase("xml")

            || primary.equalsIgnoreCase("text") && sub.equalsIgnoreCase("xml-soap")

            || primary.equals("application")

               && sub.equals("fastinfoset");

    }

    /**

     * @param type

     *      must be all lower case

     */

    private static boolean isEqualToSoap1_1Type(String type) {

        return type.startsWith("text/xml") ||

               type.startsWith("application/fastinfoset");

    }

    /**

     * @param primary

     *      must be all lower case

     * @param sub

     *      must be all lower case

     */

    private static boolean isSoap1_2Type(String primary, String sub) {

        return primary.equals("application")

               && (sub.equals("soap+xml")

                   || sub.equals("soap+fastinfoset"));

    }

    /**

     * @param type

     *      must be all lower case

     */

    private static boolean isEqualToSoap1_2Type(String type) {

        return type.startsWith("application/soap+xml") ||

               type.startsWith("application/soap+fastinfoset");

    }

    /**

      * Construct a new message. This will be invoked before message

      * sends.

      */

    protected MessageImpl() {

        this(false, false);

        attachmentsInitialized = true;

    }

    /**

      * Construct a new message. This will be invoked before message

      * sends.

      */

    protected MessageImpl(boolean isFastInfoset, boolean acceptFastInfoset) {

        this.isFastInfoset = isFastInfoset;

        this.acceptFastInfoset = acceptFastInfoset;

        headers = new MimeHeaders();

        headers.setHeader("Accept", getExpectedAcceptHeader());

        contentType = new ContentType();

    }

    /**

     * Shallow copy.

     */

    protected MessageImpl(SOAPMessage msg) {

        if (!(msg instanceof MessageImpl)) {

            // don't know how to handle this.

        }

        MessageImpl src = (MessageImpl) msg;

        this.headers = src.headers;

        this.soapPartImpl = src.soapPartImpl;

        this.attachments = src.attachments;

        this.saved = src.saved;

        this.messageBytes = src.messageBytes;

        this.messageByteCount = src.messageByteCount;

        this.properties = src.properties;

        this.contentType = src.contentType;

    }

    /**

     * @param stat

     *      the mask value obtained from {@link #identifyContentType(ContentType)}

     */

    protected static boolean isSoap1_1Content(int stat) {

        return (stat & SOAP1_1_FLAG) != 0;

    }

    /**

     * @param stat

     *      the mask value obtained from {@link #identifyContentType(ContentType)}

     */

    protected static boolean isSoap1_2Content(int stat) {

        return (stat & SOAP1_2_FLAG) != 0;

    }

     private static boolean isMimeMultipartXOPSoap1_2Package(ContentType contentType) {

        String type = contentType.getParameter("type");

        if (type == null) {

            return false;

        }

        type = type.toLowerCase();

        if (!type.startsWith("application/xop+xml")) {

            return false;

        }

        String startinfo = contentType.getParameter("start-info");

        if (startinfo == null) {

            return false;

        }

        startinfo = startinfo.toLowerCase();

        return isEqualToSoap1_2Type(startinfo);

    }

     //private static boolean isMimeMultipartXOPPackage(ContentType contentType) {

     private static boolean isMimeMultipartXOPSoap1_1Package(ContentType contentType) {

        String type = contentType.getParameter("type");

        if(type==null)

            return false;

        type = type.toLowerCase();

        if(!type.startsWith("application/xop+xml"))

            return false;

        String startinfo = contentType.getParameter("start-info");

        if(startinfo == null)

            return false;

        startinfo = startinfo.toLowerCase();

        return isEqualToSoap1_1Type(startinfo);

    }

    private static boolean isSOAPBodyXOPPackage(ContentType contentType){

        String primary = contentType.getPrimaryType();

        String sub = contentType.getSubType();

        if (primary.equalsIgnoreCase("application")) {

            if (sub.equalsIgnoreCase("xop+xml")) {

                String type = getTypeParameter(contentType);

                return isEqualToSoap1_2Type(type) || isEqualToSoap1_1Type(type);

            }

        }

        return false;

    }

    /**

     * Construct a message from an input stream. When messages are

     * received, there's two parts -- the transport headers and the

     * message content in a transport specific stream.

     */

    protected MessageImpl(MimeHeaders headers, final InputStream in)

        throws SOAPExceptionImpl {

        contentType = parseContentType(headers);

        init(headers,identifyContentType(contentType),contentType,in);

    }

    private static ContentType parseContentType(MimeHeaders headers) throws SOAPExceptionImpl {

        final String ct;

        if (headers != null)

            ct = getContentType(headers);

        else {

            log.severe("SAAJ0550.soap.null.headers");

            throw new SOAPExceptionImpl("Cannot create message: " +

                                        "Headers can't be null");

        }

        if (ct == null) {

            log.severe("SAAJ0532.soap.no.Content-Type");

            throw new SOAPExceptionImpl("Absent Content-Type");

        }

        try {

            return new ContentType(ct);

        } catch (Throwable ex) {

            log.severe("SAAJ0535.soap.cannot.internalize.message");

            throw new SOAPExceptionImpl("Unable to internalize message", ex);

        }

    }

    /**

     * Construct a message from an input stream. When messages are

     * received, there's two parts -- the transport headers and the

     * message content in a transport specific stream.

     *

     * @param contentType

     *      The parsed content type header from the headers variable.

     *      This is redundant parameter, but it avoids reparsing this header again.

     * @param stat

     *      The result of {@link #identifyContentType(ContentType)} over

     *      the contentType parameter. This redundant parameter, but it avoids

     *      recomputing this information again.

     */

    protected MessageImpl(MimeHeaders headers, final ContentType contentType, int stat, final InputStream in) throws SOAPExceptionImpl {

        init(headers, stat, contentType, in);

    }

        this.headers = headers;

        try {

            // Set isFastInfoset/acceptFastInfoset flag based on MIME type

            if ((stat & FI_ENCODED_FLAG) > 0) {

                isFastInfoset = acceptFastInfoset = true;

            }

            // If necessary, inspect Accept header to set acceptFastInfoset

            if (!isFastInfoset) {

                String[] values = headers.getHeader("Accept");

                if (values != null) {

                    for (int i = 0; i < values.length; i++) {

                        StringTokenizer st = new StringTokenizer(values[i], ",");

                        while (st.hasMoreTokens()) {

                            final String token = st.nextToken().trim();

                            if (token.equalsIgnoreCase("application/fastinfoset") ||

                                token.equalsIgnoreCase("application/soap+fastinfoset")) {

                                acceptFastInfoset = true;

                                break;

                            }

                        }

                    }

                }

            }

            if (!isCorrectSoapVersion(stat)) {

                log.log(

                    Level.SEVERE,

                    "SAAJ0533.soap.incorrect.Content-Type",

                    new String[] {

                        contentType.toString(),

                        getExpectedContentType()});

                throw new SOAPVersionMismatchException(

                    "Cannot create message: incorrect content-type for SOAP version. Got: "

                        + contentType

                        + " Expected: "

                        + getExpectedContentType());

            }

            if ((stat & PLAIN_XML_FLAG) != 0) {

                } else {

                }

            }

                DataSource ds = new DataSource() {

                    public InputStream getInputStream() {

                    }

                    public OutputStream getOutputStream() {

                        return null;

                    }

                    public String getContentType() {

                        return contentType.toString();

                    }

                    public String getName() {

                        return "";

                    }

                };

                multiPart = null;

                if (useMimePull) {

                    multiPart = new MimePullMultipart(ds,contentType);

                } else if (switchOffBM) {

                    multiPart = new MimeMultipart(ds,contentType);

                } else {

                    multiPart = new BMMimeMultipart(ds,contentType);

                }

                String startParam = contentType.getParameter("start");

                MimeBodyPart soapMessagePart = null;

                InputStream soapPartInputStream = null;

                String contentID = null;

                String contentIDNoAngle = null;

                if (switchOffBM || switchOffLazyAttachment) {

                    if(startParam == null) {

                        soapMessagePart = multiPart.getBodyPart(0);

                        for (int i = 1; i < multiPart.getCount(); i++) {

                            initializeAttachment(multiPart, i);

                        }

                    } else {

                        soapMessagePart = multiPart.getBodyPart(startParam);

                        for (int i = 0; i < multiPart.getCount(); i++) {

                            contentID = multiPart.getBodyPart(i).getContentID();

                            // Old versions of AXIS2 put angle brackets around the content

                            // id but not the start param

                            contentIDNoAngle = (contentID != null) ?

                                contentID.replaceFirst("^<", "").replaceFirst(">$", "") : null;

                            if(!startParam.equals(contentID) && !startParam.equals(contentIDNoAngle))

                                initializeAttachment(multiPart, i);

                        }

                    }

                } else {

                    if (useMimePull) {

                        MimePullMultipart mpMultipart = (MimePullMultipart)multiPart;

                        MIMEPart sp = mpMultipart.readAndReturnSOAPPart();

                        soapMessagePart = new MimeBodyPart(sp);

                        soapPartInputStream = sp.readOnce();

                    } else {

                        BMMimeMultipart bmMultipart =

                                (BMMimeMultipart) multiPart;

                        InputStream stream = bmMultipart.initStream();

                        SharedInputStream sin = null;

                        if (stream instanceof SharedInputStream) {

                            sin = (SharedInputStream) stream;

                        }

                        String boundary = "--" +

                                contentType.getParameter("boundary");

                        byte[] bndbytes = ASCIIUtility.getBytes(boundary);

                        if (startParam == null) {

                            soapMessagePart =

                                    bmMultipart.getNextPart(stream, bndbytes, sin);

                            bmMultipart.removeBodyPart(soapMessagePart);

                        } else {

                            MimeBodyPart bp = null;

                            try {

                               while (!startParam.equals(contentID) && !startParam.equals(contentIDNoAngle)) {

                                    bp = bmMultipart.getNextPart(

                                            stream, bndbytes, sin);

                                    contentID = bp.getContentID();

                                    // Old versions of AXIS2 put angle brackets around the content

                                    // id but not the start param

                                    contentIDNoAngle = (contentID != null) ?

                                        contentID.replaceFirst("^<", "").replaceFirst(">$", "") : null;

                                }

                                soapMessagePart = bp;

                                bmMultipart.removeBodyPart(bp);

                            } catch (Exception e) {

                                throw new SOAPExceptionImpl(e);

                            }

                        }

                    }

                }