/*
* 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.transport;

import org.apache.axiom.attachments.Attachments;
import org.apache.axiom.om.OMException;
import org.apache.axiom.om.util.StAXUtils;
import org.apache.axiom.om.impl.MTOMConstants;
import org.apache.axiom.om.impl.builder.StAXBuilder;
import org.apache.axiom.om.impl.builder.StAXOMBuilder;
import org.apache.axiom.om.impl.builder.XOPAwareStAXOMBuilder;
import org.apache.axiom.soap.SOAP11Constants;
import org.apache.axiom.soap.SOAP12Constants;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.SOAPFactory;
import org.apache.axiom.soap.impl.builder.MTOMStAXSOAPModelBuilder;
import org.apache.axiom.soap.impl.builder.StAXSOAPModelBuilder;
import org.apache.axiom.soap.impl.llom.soap11.SOAP11Factory;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.context.OperationContext;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.transport.http.HTTPConstants;

import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PushbackInputStream;
import java.io.Reader;

public class TransportUtils {
    private static final int BOM_SIZE = 4;

    public static SOAPEnvelope createSOAPMessage(MessageContext msgContext, String soapNamespaceURI)
            throws AxisFault {
        InputStream inStream = (InputStream) msgContext.getProperty(MessageContext.TRANSPORT_IN);

        msgContext.setProperty(MessageContext.TRANSPORT_IN, null);

        // this inputstram is set by the TransportSender represents a two way transport or
        // by a Transport Recevier
        if (inStream == null) {
            throw new AxisFault(Messages.getMessage("inputstreamNull"));
        }

        return createSOAPMessage(msgContext, inStream, soapNamespaceURI);
    }

    public static SOAPEnvelope createSOAPMessage(MessageContext msgContext, InputStream inStream,
                                                  String soapNamespaceURI)
            throws AxisFault {
        try {
            Object contentType ;
            OperationContext opContext = msgContext.getOperationContext();

            if (opContext != null) {
                contentType = opContext.getProperty(HTTPConstants.MTOM_RECEIVED_CONTENT_TYPE);
            } else {
                throw new AxisFault(Messages.getMessage("cannotBeNullOperationContext"));
            }

            StAXBuilder builder;
            SOAPEnvelope envelope ;
            String charSetEnc =
                    (String) msgContext.getProperty(Constants.Configuration.CHARACTER_SET_ENCODING);

            if (charSetEnc == null) {
                charSetEnc = (String) opContext.getProperty(Constants.Configuration.CHARACTER_SET_ENCODING);
            }

            if (charSetEnc == null) {
                charSetEnc = MessageContext.DEFAULT_CHAR_SET_ENCODING;
            }

            if (contentType != null) {
                msgContext.setDoingMTOM(true);
                builder = selectBuilderForMIME(msgContext, inStream,
                        (String) contentType,true);
                envelope = (SOAPEnvelope) builder.getDocumentElement();
            } else if (msgContext.isDoingREST()) {
                XMLStreamReader xmlreader =
                        StAXUtils.createXMLStreamReader(inStream, charSetEnc);
                SOAPFactory soapFactory = new SOAP11Factory();

                builder = new StAXOMBuilder(xmlreader);
                builder.setOMBuilderFactory(soapFactory);
                envelope = soapFactory.getDefaultEnvelope();
                envelope.getBody().addChild(builder.getDocumentElement());
                
                // We now have the message inside an envolope. However, this is 
                // only an OM; We need to build a SOAP model from it.

                builder = new StAXSOAPModelBuilder(envelope.getXMLStreamReader(), soapNamespaceURI);
                envelope = (SOAPEnvelope) builder.getDocumentElement();
            } else {
                XMLStreamReader xmlreader =
                        StAXUtils.createXMLStreamReader(inStream, charSetEnc);

                builder = new StAXSOAPModelBuilder(xmlreader, soapNamespaceURI);
                envelope = (SOAPEnvelope) builder.getDocumentElement();
            }

            return envelope;
        } catch (Exception e) {
            throw new AxisFault(e);
        }
    }

    /**
     * Extracts and returns the character set encoding from the
     * Content-type header
     * Example:
     * Content-Type: text/xml; charset=utf-8
     *
     * @param contentType
     */
    public static String getCharSetEncoding(String contentType) {
        int index = contentType.indexOf(HTTPConstants.CHAR_SET_ENCODING);

        if (index == -1) {    // Charset encoding not found in the content-type header
            // Using the default UTF-8
            return MessageContext.DEFAULT_CHAR_SET_ENCODING;
        }

        // If there are spaces around the '=' sign
        int indexOfEq = contentType.indexOf("=", index);

        // There can be situations where "charset" is not the last parameter of the Content-Type header
        int indexOfSemiColon = contentType.indexOf(";", indexOfEq);
        String value;

        if (indexOfSemiColon > 0) {
            value = (contentType.substring(indexOfEq + 1, indexOfSemiColon));
        } else {
            value = (contentType.substring(indexOfEq + 1, contentType.length())).trim();
        }

        // There might be "" around the value - if so remove them
        if(value.indexOf('\"')!=-1){
            value = value.replaceAll("\"", "");
        }

        return value.trim();
    }

	public static StAXBuilder selectBuilderForMIME(MessageContext msgContext,
			InputStream inStream, String contentTypeString, boolean isSOAP)
			throws OMException, XMLStreamException, FactoryConfigurationError {
		StAXBuilder builder = null;

		Object cacheAttachmentProperty = msgContext
				.getProperty(Constants.Configuration.CACHE_ATTACHMENTS);
		String cacheAttachmentString = null;
		boolean fileCacheForAttachments;

		if (cacheAttachmentProperty != null
				&& cacheAttachmentProperty instanceof String) {
			cacheAttachmentString = (String) cacheAttachmentProperty;
			fileCacheForAttachments = (Constants.VALUE_TRUE
					.equals(cacheAttachmentString));
		} else {
			Parameter parameter_cache_attachment = msgContext
					.getParameter(Constants.Configuration.CACHE_ATTACHMENTS);
			cacheAttachmentString = (parameter_cache_attachment != null) ? (String) parameter_cache_attachment
					.getValue()
					: null;
		}
		fileCacheForAttachments = (Constants.VALUE_TRUE
				.equals(cacheAttachmentString));

		String attachmentRepoDir = null;
		String attachmentSizeThreshold = null;

		if (fileCacheForAttachments) {
			Object attachmentRepoDirProperty = msgContext
					.getProperty(Constants.Configuration.ATTACHMENT_TEMP_DIR);

			if (attachmentRepoDirProperty != null) {
				attachmentRepoDir = (String) attachmentRepoDirProperty;
			} else {
				Parameter attachmentRepoDirParameter = msgContext
						.getParameter(Constants.Configuration.ATTACHMENT_TEMP_DIR);
				attachmentRepoDir = (attachmentRepoDirParameter != null) ? (String) attachmentRepoDirParameter
						.getValue()
						: null;
			}

			Object attachmentSizeThresholdProperty = msgContext
					.getProperty(Constants.Configuration.FILE_SIZE_THRESHOLD);
			if (attachmentSizeThresholdProperty != null
					&& attachmentSizeThresholdProperty instanceof String) {
				attachmentSizeThreshold = (String) attachmentSizeThresholdProperty;
			} else {
				Parameter attachmentSizeThresholdParameter = msgContext
						.getParameter(Constants.Configuration.FILE_SIZE_THRESHOLD);
				attachmentSizeThreshold = attachmentSizeThresholdParameter
						.getValue().toString();
			}
		}

		Attachments attachments = new Attachments(inStream, contentTypeString,
				fileCacheForAttachments, attachmentRepoDir,
				attachmentSizeThreshold);
		String charSetEncoding = getCharSetEncoding(attachments
				.getSOAPPartContentType());
		XMLStreamReader streamReader;

		if ((charSetEncoding == null)
				|| "null".equalsIgnoreCase(charSetEncoding)) {
			charSetEncoding = MessageContext.UTF_8;
		}

		try {
			streamReader = StAXUtils.createXMLStreamReader(getReader(
					attachments.getSOAPPartInputStream(), charSetEncoding));
		} catch (IOException e) {
			throw new XMLStreamException(e);
		}

		msgContext.setProperty(Constants.Configuration.CHARACTER_SET_ENCODING,
				charSetEncoding);

		/*
		 * Put a reference to Attachments Map in to the message context For
		 * backword compatibility with Axis2 1.0
		 */
		msgContext.setProperty(MTOMConstants.ATTACHMENTS, attachments);

		/*
		 * Setting the Attachments map to new SwA API
		 */
		msgContext.setAttachmentMap(attachments);

		String soapEnvelopeNamespaceURI = null;
		if (contentTypeString.indexOf(SOAP12Constants.SOAP_12_CONTENT_TYPE) > -1) {
			soapEnvelopeNamespaceURI = SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI;
		} else if (contentTypeString
				.indexOf(SOAP11Constants.SOAP_11_CONTENT_TYPE) > -1) {
			soapEnvelopeNamespaceURI = SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI;
		}

		if (isSOAP) {
			if (attachments.getAttachmentSpecType().equals(
					MTOMConstants.MTOM_TYPE)
					& null != soapEnvelopeNamespaceURI) {

				/*
				 * Creates the MTOM specific MTOMStAXSOAPModelBuilder
				 */
				builder = new MTOMStAXSOAPModelBuilder(streamReader,
						attachments, soapEnvelopeNamespaceURI);

			} else if (attachments.getAttachmentSpecType().equals(
					MTOMConstants.SWA_TYPE)
					& null != soapEnvelopeNamespaceURI) {
				builder = new StAXSOAPModelBuilder(streamReader,
						soapEnvelopeNamespaceURI);
			}
		}
		// To handle REST XOP case
		else {
			if (attachments.getAttachmentSpecType().equals(
					MTOMConstants.MTOM_TYPE)) {
				XOPAwareStAXOMBuilder stAXOMBuilder = new XOPAwareStAXOMBuilder(
						streamReader, attachments);
				builder = stAXOMBuilder;

			} else if (attachments.getAttachmentSpecType().equals(
					MTOMConstants.SWA_TYPE)) {
				builder = new StAXOMBuilder(streamReader);
			}
		}

		return builder;
	}

    /**
	 * Use the BOM Mark to identify the encoding to be used. Fall back to
	 * default encoding specified
	 * 
	 * @param is
	 * @param charSetEncoding
	 * @throws java.io.IOException
	 */
    private static Reader getReader(InputStream is, String charSetEncoding) throws IOException {
        PushbackInputStream is2 = new PushbackInputStream(is, BOM_SIZE);
        String encoding;
        byte bom[] = new byte[BOM_SIZE];
        int n, unread;

        n = is2.read(bom, 0, bom.length);

        if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) {
            encoding = "UTF-8";
            unread = n - 3;
        } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
            encoding = "UTF-16BE";
            unread = n - 2;
        } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
            encoding = "UTF-16LE";
            unread = n - 2;
        } else if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE)
                && (bom[3] == (byte) 0xFF)) {
            encoding = "UTF-32BE";
            unread = n - 4;
        } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00)
                && (bom[3] == (byte) 0x00)) {
            encoding = "UTF-32LE";
            unread = n - 4;
        } else {

            // Unicode BOM mark not found, unread all bytes
            encoding = charSetEncoding;
            unread = n;
        }

        if (unread > 0) {
            is2.unread(bom, (n - unread), unread);
        }

        return new BufferedReader(new InputStreamReader(is2, encoding));
    }
}