/*

 * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.

 * 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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.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.*;

/**

 * 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";

        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 XOP_FLAG = 13;                // 01101

    protected static final int FI_ENCODED_FLAG     = 16;     // 10000

    protected MimeHeaders headers;

    protected SOAPPartImpl soapPart;

    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;

    // switch back to old MimeMultipart incase of problem

    private static boolean switchOffBM = false;

    private static boolean switchOffLazyAttachment = false;

    static {

        try {

            String s = System.getProperty("saaj.mime.optimization");

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

                switchOffBM = true;

            }

            s = System.getProperty("saaj.lazy.mime.optimization");

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

                switchOffLazyAttachment = true;

            }

        } catch (SecurityException ex) {

            // ignore it

        }

    }

    //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.equals("text") && sub.equals("xml")

            || 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());

    }

    /**

     * 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.soapPart = src.soapPart;

        this.attachments = src.attachments;

        this.saved = src.saved;

        this.messageBytes = src.messageBytes;

        this.messageByteCount = src.messageByteCount;

        this.properties = src.properties;

    }

    /**

     * @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 isMimeMultipartXOPPackage(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) || 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 ct = parseContentType(headers);

        init(headers,identifyContentType(ct),ct,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);

    }

    private void init(MimeHeaders headers, int stat, final ContentType contentType, final InputStream in) throws SOAPExceptionImpl {

        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) {

                if (isFastInfoset) {

                    getSOAPPart().setContent(

                        FastInfosetReflection.FastInfosetSource_new(in));

                } else {

                    initCharsetProperty(contentType);

                    getSOAPPart().setContent(new StreamSource(in));

                }

            }

            else if ((stat & MIME_MULTIPART_FLAG) != 0) {

                DataSource ds = new DataSource() {

                    public InputStream getInputStream() {

                        return in;

                    }

                    public OutputStream getOutputStream() {

                        return null;

                    }

                    public String getContentType() {

                        return contentType.toString();

                    }

                    public String getName() {

                        return "";

                    }

                };

                multiPart = null;

                if (switchOffBM) {

                    multiPart = new MimeMultipart(ds,contentType);

                } else {

                    multiPart = new BMMimeMultipart(ds,contentType);

                }

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

                MimeBodyPart soapMessagePart = null;

                String contentID = 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();

                            if(!contentID.equals(startParam))

                                initializeAttachment(multiPart, i);

                        }

                    }

                } 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)) {

                                bp = bmMultipart.getNextPart(

                                    stream, bndbytes, sin);

                                contentID = bp.getContentID();

                            }

                            soapMessagePart = bp;

                            bmMultipart.removeBodyPart(bp);

                        } catch (Exception e) {

                            throw new SOAPExceptionImpl(e);

                        }

                    }

                }

                ContentType soapPartCType = new ContentType(

                                            soapMessagePart.getContentType());

                initCharsetProperty(soapPartCType);

                String baseType = soapPartCType.getBaseType().toLowerCase();

                if(!(isEqualToSoap1_1Type(baseType)

                  || isEqualToSoap1_2Type(baseType)

                  || isSOAPBodyXOPPackage(soapPartCType))) {

                    log.log(Level.SEVERE,

                            "SAAJ0549.soap.part.invalid.Content-Type",

                            new Object[] {baseType});

                    throw new SOAPExceptionImpl(

                            "Bad Content-Type for SOAP Part : " +

                            baseType);

                }

                SOAPPart soapPart = getSOAPPart();

                setMimeHeaders(soapPart, soapMessagePart);

                soapPart.setContent(isFastInfoset ?

                     (Source) FastInfosetReflection.FastInfosetSource_new(

                         soapMessagePart.getInputStream()) :

                     (Source) new StreamSource(soapMessagePart.getInputStream()));

            } else {

                log.severe("SAAJ0534.soap.unknown.Content-Type");

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

            }

        } catch (Throwable ex) {

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

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

        }

        needsSave();

    }

    public boolean isFastInfoset() {

        return isFastInfoset;

    }

    public boolean acceptFastInfoset() {

        return acceptFastInfoset;

    }

    public void setIsFastInfoset(boolean value) {

        if (value != isFastInfoset) {

            isFastInfoset = value;

            if (isFastInfoset) {

                acceptFastInfoset = true;

            }

            saved = false;      // ensure transcoding if necessary

        }

    }

    public Object getProperty(String property) {

        return (String) properties.get(property);

    }

    public void setProperty(String property, Object value) {

        verify(property, value);

        properties.put(property, value);

    }

    private void verify(String property, Object value) {

        if (property.equalsIgnoreCase(SOAPMessage.WRITE_XML_DECLARATION)) {

            if (!("true".equals(value) || "false".equals(value)))

                throw new RuntimeException(

                    property + " must have value false or true");

            try {

                EnvelopeImpl env = (EnvelopeImpl) getSOAPPart().getEnvelope();

                if ("true".equalsIgnoreCase((String)value)) {

                    env.setOmitXmlDecl("no");

                } else if ("false".equalsIgnoreCase((String)value)) {

                    env.setOmitXmlDecl("yes");

                }

            } catch (Exception e) {

                log.log(Level.SEVERE, "SAAJ0591.soap.exception.in.set.property",

                    new Object[] {e.getMessage(), "javax.xml.soap.write-xml-declaration"});

                throw new RuntimeException(e);

            }

            return;