/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.jaxws.handler;

import org.apache.axis2.AxisFault;
import org.apache.axis2.jaxws.Constants;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.context.factory.MessageContextFactory;
import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.axis2.jaxws.handler.factory.HandlerPostInvokerFactory;
import org.apache.axis2.jaxws.handler.factory.HandlerPreInvokerFactory;
import org.apache.axis2.jaxws.i18n.Messages;
import org.apache.axis2.jaxws.marshaller.impl.alt.MethodMarshallerUtils;
import org.apache.axis2.jaxws.message.Message;
import org.apache.axis2.jaxws.message.Protocol;
import org.apache.axis2.jaxws.message.XMLFault;
import org.apache.axis2.jaxws.message.factory.MessageFactory;
import org.apache.axis2.jaxws.message.util.MessageUtils;
import org.apache.axis2.jaxws.message.util.XMLFaultUtils;
import org.apache.axis2.jaxws.registry.FactoryRegistry;
import org.apache.axis2.jaxws.utility.SAAJFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import javax.xml.soap.SOAPBody;
import javax.xml.soap.SOAPConstants;
import javax.xml.soap.SOAPFault;
import javax.xml.soap.SOAPMessage;
import javax.xml.ws.ProtocolException;
import javax.xml.ws.WebServiceException;
import javax.xml.ws.handler.Handler;
import javax.xml.ws.handler.LogicalHandler;
import javax.xml.ws.handler.soap.SOAPHandler;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class HandlerChainProcessor {

    private static final Log log = LogFactory.getLog(HandlerChainProcessor.class);
    private HandlerPreInvoker handlerPreInvoker = null;
    private HandlerPostInvoker handlerPostInvoker = null;
    
    public enum Direction {
        IN, OUT
    };

    // the type of message, not indicative of one-way vs. request-response
    public enum MEP {
        REQUEST, RESPONSE
    };

    private javax.xml.ws.handler.MessageContext currentMC;  // just a pointer
    private LogicalMessageContext logicalMC = null;
    private SoapMessageContext soapMC = null;

    private MEPContext mepCtx;

    // Copy of the handler chain used by HandlerChainProcessor
    private List<Handler> handlers = null;
    private static final List<Handler> EMPTY_CHAIN = new ArrayList<Handler>(0); 
    
    // for tracking purposes -- see trackInternalCall
    private static Handler currentHandler = null;
    private static String currentMethod = null;

    // track start/end of logical and protocol handlers in the list
    // The two scenarios are:  1) run logical handlers only, 2) run all handlers
    // logical start is always 0
    // protocol start is always logicalLength + 1
    // list end is always handlers.size()-1
    private int logicalLength = 0;

    private final static int SUCCESSFUL = 0;
    private final static int FAILED = 1;
    private final static int PROTOCOL_EXCEPTION = 2;
    private final static int OTHER_EXCEPTION = 3;
    // save it if Handler.handleMessage throws one in
    // HandlerChainProcessor.handleMessage
    private RuntimeException savedException;
    private Protocol proto; // need to save it incase we have to make a fault message

    // we track whether the SOAPHeadersAdapter and SAAJ are both used in a given handler
    // method.  If the tracker property is set, and both are called in a handler method,
    // we throw an exception.  This behavior can easily be turned off by a handler method
    // by removing or setting to true the Constants.JAXWS_HANDLER_TRACKER property
    public enum TRACKER {
        SOAP_HEADERS_ADAPTER_CALLED, SAAJ_CALLED
    };
    private static boolean soap_headers_adapter_called = false;
    private static boolean saaj_called = false;

    /*
     * The HandlerChainProcessor is constructed with the handler chain.
     * The handler chain may be null, empty or already sorted.
     * It also may be shared.  For this reason a copy of chain is made
     * so that the sort and other manipulation does not affect the original
     * chain.
     * @param chain Handler chain
     * @param proto Protocol
      */
	public HandlerChainProcessor(List<Handler> chain, Protocol proto) {
	    if (chain != null) {
            synchronized (chain) {
                if (chain.size() == 0) {
                    // Use empty chain to avoid excessive garbage collection
                    this.handlers = EMPTY_CHAIN;
                } else {
                    this.handlers = new CopyOnWriteArrayList<Handler>(chain); 
                }
            }
        } else {
            handlers = EMPTY_CHAIN;
        }
        this.proto = proto;
    }

	/*
	 * sortChain sorts the local copy of the handlers chain.
	 * The logical handlers are first followed by the protocol handlers.
	 * sortChain also keeps track of the start/end of each type of handler.
	 */
	private void sortChain() throws WebServiceException {
        
        if (handlers.size() == 0) {
            logicalLength = 0;
            return;
        }
        
        ArrayList<Handler> logicalHandlers = new ArrayList<Handler>();
        ArrayList<Handler> protocolHandlers = new ArrayList<Handler>();
        
        Iterator handlerIterator = handlers.iterator();
        
        while (handlerIterator.hasNext()) {
            // this is a safe cast since the handlerResolver and binding.setHandlerChain
            // and InvocationContext.setHandlerChain verifies it before we get here
            Handler handler = (Handler)handlerIterator.next();
            // JAXWS 9.2.1.2 sort them by Logical, then SOAP
            if (LogicalHandler.class.isAssignableFrom(handler.getClass()))
                logicalHandlers.add((LogicalHandler) handler);
            else if (SOAPHandler.class.isAssignableFrom(handler.getClass()))
                // instanceof ProtocolHandler
                protocolHandlers.add((SOAPHandler) handler);
            else if (Handler.class.isAssignableFrom(handler.getClass())) {
                throw ExceptionFactory.makeWebServiceException(Messages
                    .getMessage("handlerChainErr1", handler.getClass().getName()));
            } else {
                throw ExceptionFactory.makeWebServiceException(Messages
                    .getMessage("handlerChainErr2", handler.getClass().getName()));
            }
        }
        
        logicalLength = logicalHandlers.size();
        
        // JAXWS 9.2.1.2 sort them by Logical, then SOAP
        handlers.clear();
        handlers.addAll(logicalHandlers);
        handlers.addAll(protocolHandlers);
	}
	

	/**
	 * @param mc
	 * By the time processChain method is called, we already have the sorted chain,
	 * and now we have the direction, MEP, MessageContext, and if a response is expected.  We should
	 * be able to handle everything from here, no pun intended.
	 * 
	 * Two things a user of processChain should check when the method completes:
	 * 1.  Has the MessageContext.MESSAGE_OUTBOUND_PROPERTY changed, indicating reversal of message direction
	 * 2.  Has the message been converted to a fault message? (indicated by a flag in the message)
	 */
    public boolean processChain(MEPContext mepCtx, Direction direction, MEP mep,
                                boolean expectResponse) {

        if (handlers.size() == 0)
            return true;
        
        this.mepCtx = mepCtx;
        sortChain();
        initContext(direction);
        boolean result = true;

        if (direction == Direction.OUT) { // 9.3.2 outbound
            currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
                            (direction == Direction.OUT));
            result = callGenericHandlers(mep, expectResponse, 0, handlers.size() - 1, direction);
        } else { // IN case - 9.3.2 inbound
            currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
                            (direction == Direction.OUT));
            result = callGenericHandlers(mep, expectResponse, handlers.size() - 1, 0, direction);
        }

        // message context may have been changed to be response, and message
        // converted
        // according to the JAXWS spec 9.3.2.1 footnote 2
        if ((Boolean) (currentMC.get(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY)) != (direction == Direction.OUT))
            return false;
        return result;

	}

    public boolean processChainForClose(MEPContext mepCtx, Direction direction) {

        boolean result = true;
        if (handlers.size() == 0)
            return true;
        
        this.mepCtx = mepCtx;
        sortChain();
        initContext(direction);
        callCloseHandlers(handlers.size() - 1, 0, direction);
        return result;
    }
    
     /*
      * This is the implementation of JAX-WS 2.0 section 9.3.2.1
      */
    private boolean callGenericHandlers(MEP mep, boolean expectResponse, int start, int end,
                                     Direction direction) throws RuntimeException {

        // if this is a response message, expectResponse should always be false
        if (mep == MEP.RESPONSE)
            expectResponse = false;

        int i = start;
        int result = SUCCESSFUL;

        // declared and initialized just in case we need them
        // in a reverse flow situation
        int newStart = 0, newStart_inclusive = 0, newEnd = 0;
        Direction newDirection = direction;

        if (direction == Direction.OUT) {
            while ((i <= end) && (result == SUCCESSFUL)) {
                result = handleMessage(((Handler)handlers.get(i)), direction, expectResponse);
                newStart = i - 1;
                newStart_inclusive = i;
                newEnd = 0;
                newDirection = Direction.IN;
                i++;
                if (result == SUCCESSFUL)  // don't switch if failed, since we'll be reversing directions
                    switchContext(direction, i);
            }
        } else { // IN case
            while ((i >= end) && (result == SUCCESSFUL)) {
                result = handleMessage(((Handler)handlers.get(i)), direction, expectResponse);
                newStart = i + 1;
                newStart_inclusive = i;
                newEnd = handlers.size() - 1;
                newDirection = Direction.OUT;
                i--;
                if (result == SUCCESSFUL)  // don't switch if failed, since we'll be reversing directions
                    switchContext(direction, i);
            }
        }

        if (newDirection == direction) // we didn't actually process anything, probably due to empty list
            return true;  // no need to continue

        // 9.3.2.3 in all situations, we want to close as many handlers as
        // were invoked prior to completion or exception throwing
        if (expectResponse) {
            if (result == FAILED) {
                if (log.isDebugEnabled()) {
                    log.debug("Handler returned false...Start running the handlers in reverse");
                }
                // One of that handlers returned false, therefore the handler processing
                // is stoped and the transport outbound will be avoided.
                // This may be due to an exception or it may be due the customer intentionally
                // preventing a message from flowing outbound.
                
                // we should only use callGenericHandlers_avoidRecursion in this case
                // the message context is now an outbound message context,
                // and should be marked as such so the SOAPHeadersAdapter will
                // "install" with the correct property key.
                
                // Get the MessageContext and switch its direction
                MessageContext jaxwsMC = mepCtx.getMessageContext();
                jaxwsMC.setOutbound(newDirection == Direction.OUT);
                SOAPHeadersAdapter.install(jaxwsMC);                
                callGenericHandlers_avoidRecursion(newStart, newEnd, newDirection);
                
                // Now we need to place the Message (which is the one edited by the handler)
                // onto the Axis2 MC.  This is necessary because the Axis2 response MC
                // will be created from this MC and must have the correct message.
                this.placeMessageOnAxis2MessageContext(jaxwsMC);
                
                // Now close the handlers
                callCloseHandlers(newStart_inclusive, newEnd, newDirection);
                if (log.isDebugEnabled()) {
                    log.debug("Handler returned false...End running the handlers in reverse");
                }
            } else if (result == PROTOCOL_EXCEPTION) {
                try {
                    if (log.isDebugEnabled()) {
                        log.debug("Handler threw ProtocolException...Start running the handlers in reverse");
                    }
                    // the message context is now an outbound message context,
                    // and should be marked as such so the SOAPHeadersAdapter will
                    // "install" with the correct property key.
                    
                    // Get the MessageContext and switch its direction
                    MessageContext jaxwsMC = mepCtx.getMessageContext();
                    jaxwsMC.setOutbound(newDirection == Direction.OUT);
                    SOAPHeadersAdapter.install(jaxwsMC);
                    
                    // Call the handlerFault methods on the handlers and also close the handlers
                    callGenericHandleFault(newStart, newEnd, newDirection);
                    
                    // Now we need to place the Message (which is the one edited by the handler)
                    // onto the Axis2 MC.  This is necessary because the Axis2 response MC
                    // will be created from this MC and must have the correct message.
                    this.placeMessageOnAxis2MessageContext(jaxwsMC);
                    
                    // Now close the handlers
                    callCloseHandlers(newStart_inclusive, newEnd, newDirection);
                    if (log.isDebugEnabled()) {
                        log.debug("Handler threw ProtocolException...End running the handlers in reverse");
                    }
                } catch (RuntimeException re) {
                    callCloseHandlers(newStart_inclusive, newEnd, newDirection);
                    throw re;
                }
            } else if (result == OTHER_EXCEPTION) {
                if (log.isDebugEnabled()) {
                    log.debug("Handler threw unanticipated Exception...Start handler closure");
                }
                callCloseHandlers(newStart_inclusive, newEnd, newDirection);
                // savedException initialized in HandlerChainProcessor.handleMessage
                if (log.isDebugEnabled()) {
                    log.debug("Handler threw unanticipated Exception...End handler closure");
                }
                throw savedException;
            }
        } else { // everything was successful OR finished processing handlers
            /*
             * This is a little confusing. There are several cases we should be
             * aware of. An incoming request with false expectResponse is
             * equivalent to server inbound one-way, for example.
             * 
             * An outgoing response is server outbound, and is always marked
             * with a false expectResponse. The problem, however, is that the
             * direction for the call to closehandlers will be incorrect. In
             * this case, the handlers should be closed in the opposite order of
             * the ORIGINAL invocation.
             */
            if (mep.equals(MEP.REQUEST)) {
                // a request that requires no response is a one-way message
                // and we should only close whomever got invoked
                callCloseHandlers(newStart_inclusive, newEnd, newDirection);
                
                // As according to the Sun "experts", exceptions raised by
                // handlers in one way invocation are discarded. They
                // are NOT propagated to the user code.
                if (savedException != null) {
                    log.warn("Exception thrown by a handler in one way invocation",
                             savedException);
                    //But do return failure so that we know not to send to server
                    return false;
                }
            }
            else {
                // it's a response, so we can safely assume that 
                // ALL the handlers were invoked on the request,
                // so we need to close ALL of them
                if (direction.equals(Direction.IN)) {
                    callCloseHandlers(handlers.size() - 1, 0, direction);
                } else {
                    callCloseHandlers(0, handlers.size() - 1, direction);
                }
 
                if (savedException != null) {
                    // we have a saved exception, throw it (JAX-WS 9.3.2.1 "Throw 
                    // ProtocolException or any other runtime exception --> No 
                    // response" case.
                    throw savedException;
                }
            }
        }
        // If we've failed before this, we would have already thrown exception
        // or returned false, so just return true here ... don't need to check result again.
        return true;
    }

    /**
     * Called during reversal and exception processing to place the 
     * current Message (edited by the Handlers) onto the MessageContext
     * @param jaxwsMC
     */
    private void placeMessageOnAxis2MessageContext(MessageContext jaxwsMC) {
        if (log.isDebugEnabled()) {
            log.debug("start placeMessageOnAxis2MessageContext");
        }
        try {
            org.apache.axis2.context.MessageContext mc = jaxwsMC.getAxisMessageContext();
            if (mc != null) {
                Message message = jaxwsMC.getMessage();
                if (message != null) {
                    if (log.isDebugEnabled()) {
                        log.debug("Place the (perhaps new or edited) Message on the MessageContext");
                    }
                    MessageUtils.putMessageOnMessageContext(message, mc);
                } else {
                    if (log.isDebugEnabled()) {
                        log.debug("There is no Message.  Message is not copied to the Axis2 MessageContext.");
                    }
                }
            } else {
                if (log.isDebugEnabled()) {
                    log.debug("Axis2 MessageContext is not available.  Message is not copied");
                }
            }
        } catch (AxisFault e) {
            throw ExceptionFactory.makeWebServiceException(e);
        } 
        if (log.isDebugEnabled()) {
            log.debug("end placeMessageOnAxis2MessageContext");
        }
    }
    
    /*
      * callGenericHandlers_avoidRecursion should ONLY be called from one place.
      * TODO:  We cannot necessarily assume no false returns and no exceptions will be
      * thrown from here even though the handlers we will be calling have all already
      * succeeded in callGenericHandlers.
      */
    private void callGenericHandlers_avoidRecursion(int start,
                                                    int end, Direction direction) {
        int i = start;

        if (direction == Direction.OUT) {
            for (; i <= end; i++) {
                switchContext(direction, i);
                Handler handler = (Handler) handlers.get(i);
                
                if (log.isDebugEnabled()) {
                    log.debug("Invoking handleMessage on: " + handler.getClass().getName());
                }
                callHandleMessageWithTracker(handler);
            }
        } else { // IN case
            for (; i >= end; i--) {
                switchContext(direction, i);
                Handler handler = (Handler) handlers.get(i);
               
                if (log.isDebugEnabled()) {
                    log.debug("Invoking handleMessage on: " + handler.getClass().getName());
                }
                callHandleMessageWithTracker(handler);
            }
        }
    }


    /**
     * Calls handleMessage on the Handler. If an exception is thrown and a response is expected, the
     * MessageContext is updated with the handler information
     *
     * @returns SUCCESSFUL if successfully, UNSUCCESSFUL if false, EXCEPTION if exception thrown
     */
    private int handleMessage(Handler handler, Direction direction,
                              boolean expectResponse) throws RuntimeException {
        try {
            if (log.isDebugEnabled()) {
                log.debug("Invoking handleMessage on: " + handler.getClass().getName()); 
            }
            
            // The pre and post invokers will likely need more than just the handler message context.
            // They may need access to the axis service object or description objects.
            currentMC.put(Constants.MEP_CONTEXT, mepCtx);

            getPreInvoker().preInvoke(currentMC);
            boolean success = callHandleMessageWithTracker(handler);
            getPostInvoker().postInvoke(currentMC);
            if (success) {
                if (log.isDebugEnabled()) {
                    log.debug("handleMessage() returned true");
                }
                return SUCCESSFUL;
            }
            else {
                if (log.isDebugEnabled()) {
                    log.debug("handleMessage() returned false");
                }
                if (expectResponse)
                    currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
                                    (direction != Direction.OUT));
                return FAILED;
            }
        } 
        catch (RuntimeException re) { 
            // RuntimeException and ProtocolException
            if(log.isDebugEnabled()) {
               log.debug("An exception was thrown during the handleMessage() invocation");
               log.debug("Exception: ", re);
            }
            
            savedException = re;
            if (expectResponse)
                // mark it as reverse direction
                currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
                                (direction != Direction.OUT));
            if (ProtocolException.class.isAssignableFrom(re.getClass())) {
                convertToFaultMessage(mepCtx, re, proto, true);
                // just re-initialize the current handler message context since
                // that will pick up the now-changed message
                return PROTOCOL_EXCEPTION;
            }
            return OTHER_EXCEPTION;
        }

    }


    /*
      * start and end should be INclusive of the handlers that have already been
      * invoked on Handler.handleMessage or Handler.handleFault
      */
    private void callCloseHandlers(int start, int end,
                                   Direction direction) {
        int i = start;

        if (direction == Direction.OUT) {
            for (; i <= end; i++) {
                try {
                    switchContext(direction, i);
                    Handler handler = (Handler) handlers.get(i);
                    if (log.isDebugEnabled()) {
                        log.debug("Invoking close on: " + handler.getClass().getName());
                    }
                    callCloseWithTracker(handler);
                    
                    // TODO when we close, are we done with the handler instance, and thus
                    // may call the PreDestroy annotated method?  I don't think so, especially
                    // if we've cached the handler list somewhere.
                } catch (Exception e) {
                    if (log.isDebugEnabled()) {
                        log.debug("An Exception occurred while calling handler.close()");
                        log.debug("Exception: " + e.getClass().getName() + ":" + e.getMessage());
                    }
                }
            }
        } else { // IN case
            for (; i >= end; i--) {
                try {
                    switchContext(direction, i);
                    Handler handler = (Handler) handlers.get(i);
                    if (log.isDebugEnabled()) {
                        log.debug("Invoking close on: " + handler.getClass().getName());
                    }
                    callCloseWithTracker(handler);
                    
                    // TODO when we close, are we done with the handler instance, and thus
                    // may call the PreDestroy annotated method?  I don't think so, especially
                    // if we've cached the handler list somewhere.
                } catch (Exception e) {
                    if (log.isDebugEnabled()) {
                        log.debug("An Exception occurred while calling handler.close()");
                        log.debug("Exception: " + e.getClass().getName() + ":" + e.getMessage());
                    }
                }
            }
        }
    }

    /*
     * processFault is available for a server to use when the endpoint
      * throws an exception or a client when it gets a fault response message
      *
      * In both cases, all of the handlers have run successfully in the
      * opposite direction as this call to callHandleFault, and thus
      * should be closed.
      */
    public void processFault(MEPContext mepCtx, Direction direction) {

        // direction.IN = client
        // direction.OUT = server
        if (handlers.size() == 0)
            return;

        this.mepCtx = mepCtx;
		sortChain();
        initContext(direction);
		currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY, (direction == Direction.OUT));

        try {
            if (direction == Direction.OUT) {
                callGenericHandleFault(0, handlers.size() - 1, direction);
            } else { // IN case
                callGenericHandleFault(handlers.size() - 1, 0, direction);
            }
        } catch (RuntimeException re) {
            if (log.isDebugEnabled()) {
                log.debug("An exception occurred during handleFault chain processing", re);
            }
            throw re;
        } finally {
            // we can close all the Handlers in reverse order
            if (direction == Direction.OUT) {
                initContext(Direction.IN);
                callCloseHandlers(0, handlers.size() - 1, Direction.OUT);
            } else { // IN case
                initContext(Direction.IN);
                callCloseHandlers(handlers.size() - 1, 0, Direction.IN);
            }
        }
    }


    /*
      * The callGenericHandleFault caller is responsible for closing any invoked
      * Handlers.  We don't know how far the Handler.handleMessage calls got
      * before a failure may have occurred.
      *
      * Regardless of the Handler.handleFault result, the flow is the same (9.3.2.2)
      */
    private void callGenericHandleFault(int start, int end,
                                        Direction direction) throws RuntimeException {

        int i = start;
        
        // we may be starting in the middle of the list, and therefore may need to switch contexts
        switchContext(direction, i);

        if (direction == Direction.OUT) {
            for (; i <= end; i++) {
                Handler handler = (Handler) handlers.get(i);
                if (log.isDebugEnabled()) {
                    log.debug("Invoking handleFault on: " + handler.getClass().getName());
                }
                boolean success = callHandleFaultWithTracker(handler);

                if (!success)
                    break;
                switchContext(direction, i + 1);
            }
        } else { // IN case
            for (; i >= end; i--) {
                Handler handler = (Handler) handlers.get(i);
                if (log.isDebugEnabled()) {
                    log.debug("Invoking handleFault on: " + handler.getClass().getName());
                }
                boolean success = callHandleFaultWithTracker(handler);

                if (!success)
                    break;
                switchContext(direction, i - 1);
            }
        }
    }

    public static void convertToFaultMessage(MEPContext mepCtx, Exception e, Protocol protocol) {
        convertToFaultMessage(mepCtx, e, protocol, false);
    }
    
    /**
     * Converts the Exception into an XML Fault Message that is stored on the MEPContext.
     * Note that if the forceConversion flag is true, this conversion will always occur.
     * If the checkMsg flag is true, this conversion only occurs if the Message is not already
     * a Fault (per 9,3,2.1 of the JAX-WS specification)
     * 
     * @param mepCtx  MEPContext
     * @param e Exception
     * @param protocol Protocol
     * @param forceConversion  If true, the Exception is always converted to a Message
     */
    public static void convertToFaultMessage(MEPContext mepCtx, 
            Exception e, 
            Protocol protocol, 
            boolean checkMsg) {

        // need to check if message is already a fault message or not,
        // probably by way of a flag (isFault) in the MessageContext or Message
        if (log.isDebugEnabled()) {
            log.debug("start convertToFaultMessge with exception: " + e.getClass().getName());
            log.debug(" checkMsg is : " + checkMsg);
        }
           
        try {
            // According to the 9.3.2.1, The message is converted into a fault only if it is not already a Fault
            Message messageFromHandler = null; 
            if (checkMsg) {
                messageFromHandler = mepCtx.getMessageContext().getMessage();
            } 
            if (messageFromHandler != null && messageFromHandler.isFault()) {
                if (log.isDebugEnabled()) {
                    log.debug("The Message is already a SOAPFault.  The exception is not converted into a Message");
                }
            } else if (protocol == Protocol.soap11 || protocol == Protocol.soap12) {
                if (log.isDebugEnabled()) {
                    log.debug("Converting Exception into a Message");
                }
                String protocolNS = (protocol == Protocol.soap11) ?
                        SOAPConstants.URI_NS_SOAP_1_1_ENVELOPE :
                        SOAPConstants.URI_NS_SOAP_1_2_ENVELOPE;

                // The following set of instructions is used to avoid 
                // some unimplemented methods in the Axis2 SAAJ implementation
                XMLFault xmlFault = MethodMarshallerUtils.createXMLFaultFromSystemException(e);
                javax.xml.soap.MessageFactory mf = SAAJFactory.createMessageFactory(protocolNS);
                SOAPMessage message = mf.createMessage();
                SOAPBody body = message.getSOAPBody();
                SOAPFault soapFault = XMLFaultUtils.createSAAJFault(xmlFault, body);

                MessageFactory msgFactory = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class);
                Message msg = msgFactory.createFrom(message);
                mepCtx.setMessage(msg);

            } else {
                WebServiceException wse = ExceptionFactory.makeWebServiceException(Messages.getMessage("cFaultMsgErr"));
                if (log.isDebugEnabled()) {
                    log.debug("end convertToFaultMessge due to error ", wse);
                }
                throw wse;
            }

        } catch (Exception ex) {
            WebServiceException wse =ExceptionFactory.makeWebServiceException(ex);
            if (log.isDebugEnabled()) {
                log.debug("end convertToFaultMessge due to error ", wse);
            }
            throw wse;
        }

    }


    private void initContext(Direction direction) {
        soapMC = MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
        logicalMC = MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
        if (direction == Direction.OUT) {
            // logical context, then SOAP
            if ((logicalLength == 0) && (handlers.size() > 0)) // we only have soap handlers
                currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
            else
                currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
        } else {
            // SOAP context, then logical
            if ((logicalLength == handlers.size()) && (handlers.size() > 0)) // we only have logical handlers
                currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
            else
                currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
        }
    }

    private void switchContext(Direction direction, int index) {

        if ((logicalLength == handlers.size()) || (logicalLength == 0))
            return; // all handlers must be the same type, so no context switch

        if (((direction == Direction.OUT) && (index == logicalLength))
                || ((direction == Direction.IN) && (index == (logicalLength - 1)))) {
            //if (currentMC.getClass().isAssignableFrom(LogicalMessageContext.class))
            if (currentMC == logicalMC)  // object check, not .equals()
                currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
            else
                currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
        }
    }
    
    private HandlerPreInvoker getPreInvoker() {
    	if (handlerPreInvoker == null) {
    		HandlerPreInvokerFactory preInvokerFactory = (HandlerPreInvokerFactory)FactoryRegistry.getFactory(HandlerPreInvokerFactory.class);
    		handlerPreInvoker = (HandlerPreInvoker)preInvokerFactory.createHandlerPreInvoker();
    	}
    	return handlerPreInvoker;
    }
    
    private HandlerPostInvoker getPostInvoker() {
    	if (handlerPostInvoker == null) {
    		HandlerPostInvokerFactory postInvokerFactory = (HandlerPostInvokerFactory)FactoryRegistry.getFactory(HandlerPostInvokerFactory.class);
    		handlerPostInvoker = (HandlerPostInvoker)postInvokerFactory.createHandlerPostInvoker();
    	}
    	return handlerPostInvoker;
    }
    
    public static void trackInternalCall(org.apache.axis2.jaxws.core.MessageContext mc, TRACKER tracker) {
        switch (tracker) {
        case SAAJ_CALLED:
            saaj_called = true;
            break;
        case SOAP_HEADERS_ADAPTER_CALLED:
            soap_headers_adapter_called = true;
            break;
        }
        Object trackerProp = (mc == null ? null : mc.getProperty(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER));
        if ((trackerProp != null) && ((Boolean)trackerProp).booleanValue()) {
            if (saaj_called && soap_headers_adapter_called) {
                // this means both the SAAJ model and SOAPHeadersAdapter code has been called in such a
                // way as to cause data transformation.  We want customers to avoid doing this (calling both)
                // in a given handler method, so we throw an exception:
                if (log.isDebugEnabled()) {
                    String logString = "JAX-WS Handler implementations should not use the " + org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER 
                    + " property to retrieve SOAP headers and manipulate the SOAP message using the SAAJ API in the same method "
                    + "implementation.  The Handler implementation and method doing this is: "
                    + currentHandler.getClass().getName() + currentMethod;
                    log.debug(logString);
                }
            }
        }
    }
    
    private boolean callHandleMessageWithTracker(Handler handler) throws RuntimeException {
        currentHandler = handler;
        currentMethod = "handleMessage";
        // turn on the tracker property
        currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true);
        boolean success = false;
        RuntimeException savedEx = null;
        try {
            success = handler.handleMessage(currentMC);
        } catch (RuntimeException t) {
            savedEx = t;
        }
        // turn off the tracker property and reset the static tracker booleans
        currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false);
        saaj_called = false;
        soap_headers_adapter_called = false;
        
        // If the handler changed the SOAPPart or Attachments, then we need
        // that the Message gets updated
        if (currentMC instanceof SoapMessageContext){
            ((SoapMessageContext)currentMC).checkAndUpdate();
        }
        
        if (savedEx != null) {
            throw savedEx;
        }
        return success;
    }
    
    private boolean callHandleFaultWithTracker(Handler handler) {
        currentHandler = handler;
        currentMethod = "handleFault";
        // turn on the tracker property
        currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true);
        boolean success = false;
        RuntimeException savedEx = null;
        try {
            success = handler.handleFault(currentMC);
        } catch (RuntimeException t) {
            savedEx = t;
        }
        // turn off the tracker property and reset the static tracker booleans
        currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false);
        saaj_called = false;
        soap_headers_adapter_called = false;
        
        // If the handler changed the SOAPPart or Attachments, then we need
        // that the Message gets updated
        if (currentMC instanceof SoapMessageContext){
            ((SoapMessageContext)currentMC).checkAndUpdate();
        }
        
        if (savedEx != null) {
            throw savedEx;
        }
        return success;
    }
    
    private void callCloseWithTracker(Handler handler) {
        currentHandler = handler;
        currentMethod = "close";
        // turn on the tracker property
        currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true);
        RuntimeException savedEx = null;
        try {
            handler.close(currentMC);
        } catch (RuntimeException t) {
            savedEx = t;
        }
        // turn off the tracker property and reset the static tracker booleans
        currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false);
        saaj_called = false;
        soap_headers_adapter_called = false;
        if (savedEx != null) {
            throw savedEx;
        }
    }

}