/*
 * Copyright (c) 2000, 2003, Oracle and/or its affiliates. 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.  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.corba.se.impl.interceptors;

import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.INTERNAL;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.portable.Delegate;
import org.omg.PortableInterceptor.LOCATION_FORWARD;
import org.omg.PortableInterceptor.SUCCESSFUL;
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
import org.omg.PortableInterceptor.TRANSPORT_RETRY;
import org.omg.PortableInterceptor.USER_EXCEPTION;
import org.omg.PortableInterceptor.ClientRequestInfo;
import org.omg.PortableInterceptor.ClientRequestInterceptor;
import org.omg.PortableInterceptor.ForwardRequest;
import org.omg.PortableInterceptor.IORInterceptor;
import org.omg.PortableInterceptor.IORInterceptor_3_0;
import org.omg.PortableInterceptor.ServerRequestInfo;
import org.omg.PortableInterceptor.ServerRequestInterceptor;
import org.omg.PortableInterceptor.ObjectReferenceTemplate;

import com.sun.corba.se.spi.ior.IOR;
import com.sun.corba.se.spi.oa.ObjectAdapter;
import com.sun.corba.se.spi.orb.ORB;
import com.sun.corba.se.impl.orbutil.ORBUtility;

/**
 * Handles invocation of interceptors.  Has specific knowledge of how to
 * invoke IOR, ClientRequest, and ServerRequest interceptors.
 * Makes use of the InterceptorList to retrieve the list of interceptors to
 * be invoked.  Most methods in this class are package scope so that they
 * may only be called from the PIHandlerImpl.
 */
public class InterceptorInvoker {

    // The ORB
    private ORB orb;

    // The list of interceptors to be invoked
    private InterceptorList interceptorList;

    // True if interceptors are to be invoked, or false if not
    // Note: This is a global enable/disable flag, whereas the enable flag
    // in the RequestInfoStack in PIHandlerImpl is only for a particular Thread.
    private boolean enabled = false;

    // PICurrent variable.
    private PICurrent current;

    // NOTE: Be careful about adding additional attributes to this class.
    // Multiple threads may be calling methods on this invoker at the same
    // time.

    /**
     * Creates a new Interceptor Invoker.  Constructor is package scope so
     * only the ORB can create it.  The invoker is initially disabled, and
     * must be explicitly enabled using setEnabled().
     */
    InterceptorInvoker( ORB orb, InterceptorList interceptorList,
                        PICurrent piCurrent )
    {
        this.orb = orb;
        this.interceptorList = interceptorList;
        this.enabled = false;
        this.current = piCurrent;
    }

    /**
     * Enables or disables the interceptor invoker
     */
    void setEnabled( boolean enabled ) {
        this.enabled = enabled;
    }

    /*
     **********************************************************************
     * IOR Interceptor invocation
     **********************************************************************/

    /**
     * Called when a new POA is created.
     *
     * @param oa The Object Adapter associated with the IOR interceptor.
     */
    void objectAdapterCreated( ObjectAdapter oa ) {
        // If invocation is not yet enabled, don't do anything.
        if( enabled ) {
            // Create IORInfo object to pass to IORInterceptors:
            IORInfoImpl info = new IORInfoImpl( oa );

            // Call each IORInterceptor:
            IORInterceptor[] iorInterceptors =
                (IORInterceptor[])interceptorList.getInterceptors(
                InterceptorList.INTERCEPTOR_TYPE_IOR );
            int size = iorInterceptors.length;

            // Implementation note:
            // This loop counts backwards for greater efficiency.
            // Benchmarks have shown that counting down is more efficient
            // than counting up in Java for loops, as a compare to zero is
            // faster than a subtract and compare to zero.  In this case,
            // it doesn't really matter much, but it's simply a force of habit.

            for( int i = (size - 1); i >= 0; i-- ) {
                IORInterceptor interceptor = iorInterceptors[i];
                try {
                    interceptor.establish_components( info );
                }
                catch( Exception e ) {
                    // as per PI spec (orbos/99-12-02 sec 7.2.1), if
                    // establish_components throws an exception, ignore it.
                }
            }

            // Change the state so that only template operations are valid
            info.makeStateEstablished() ;

            for( int i = (size - 1); i >= 0; i-- ) {
                IORInterceptor interceptor = iorInterceptors[i];
                if (interceptor instanceof IORInterceptor_3_0) {
                    IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0)interceptor ;
                    // Note that exceptions here are NOT ignored, as per the
                    // ORT spec (orbos/01-01-04)
                    interceptor30.components_established( info );
                }
            }

            // Change the state so that no operations are valid,
            // in case a reference to info escapes this scope.
            // This also completes the actions associated with the
            // template interceptors on this POA.
            info.makeStateDone() ;
        }
    }

    void adapterManagerStateChanged( int managerId, short newState )
    {
        if (enabled) {
            IORInterceptor[] interceptors =
                (IORInterceptor[])interceptorList.getInterceptors(
                InterceptorList.INTERCEPTOR_TYPE_IOR );
            int size = interceptors.length;

            for( int i = (size - 1); i >= 0; i-- ) {
                try {
                    IORInterceptor interceptor = interceptors[i];
                    if (interceptor instanceof IORInterceptor_3_0) {
                        IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0)interceptor ;
                        interceptor30.adapter_manager_state_changed( managerId,
                            newState );
                    }
                } catch (Exception exc) {
                    // No-op: ignore exception in this case
                }
            }
        }
    }

    void adapterStateChanged( ObjectReferenceTemplate[] templates,
        short newState )
    {
        if (enabled) {
            IORInterceptor[] interceptors =
                (IORInterceptor[])interceptorList.getInterceptors(
                InterceptorList.INTERCEPTOR_TYPE_IOR );
            int size = interceptors.length;

            for( int i = (size - 1); i >= 0; i-- ) {
                try {
                    IORInterceptor interceptor = interceptors[i];
                    if (interceptor instanceof IORInterceptor_3_0) {
                        IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0)interceptor ;
                        interceptor30.adapter_state_changed( templates, newState );
                    }
                } catch (Exception exc) {
                    // No-op: ignore exception in this case
                }
            }
        }
    }

    /*
     **********************************************************************
     * Client Interceptor invocation
     **********************************************************************/

    /**
     * Invokes either send_request, or send_poll, depending on the value
     * of info.getStartingPointCall()
     */
    void invokeClientInterceptorStartingPoint( ClientRequestInfoImpl info ) {
        // If invocation is not yet enabled, don't do anything.
        if( enabled ) {
            try {
                // Make a a fresh slot table available to TSC in case
                // interceptors need to make out calls.
                // Client's TSC is now RSC via RequestInfo.
                current.pushSlotTable( );
                info.setPICurrentPushed( true );
                info.setCurrentExecutionPoint( info.EXECUTION_POINT_STARTING );

                // Get all ClientRequestInterceptors:
                ClientRequestInterceptor[] clientInterceptors =
                    (ClientRequestInterceptor[])interceptorList.
                    getInterceptors( InterceptorList.INTERCEPTOR_TYPE_CLIENT );
                int size = clientInterceptors.length;

                // We will assume that all interceptors returned successfully,
                // and adjust the flowStackIndex to the appropriate value if
                // we later discover otherwise.
                int flowStackIndex = size;
                boolean continueProcessing = true;

                // Determine whether we are calling send_request or send_poll:
                // (This is currently commented out because our ORB does not
                // yet support the Messaging specification, so send_poll will
                // never occur.  Once we have implemented messaging, this may
                // be uncommented.)
                // int startingPointCall = info.getStartingPointCall();
                for( int i = 0; continueProcessing && (i < size); i++ ) {
                    try {
                        clientInterceptors[i].send_request( info );

                        // Again, it is not necessary for a switch here, since
                        // there is only one starting point call type (see
                        // above comment).

                        //switch( startingPointCall ) {
                        //case ClientRequestInfoImpl.CALL_SEND_REQUEST:
                            //clientInterceptors[i].send_request( info );
                            //break;
                        //case ClientRequestInfoImpl.CALL_SEND_POLL:
                            //clientInterceptors[i].send_poll( info );
                            //break;
                        //}

                    }
                    catch( ForwardRequest e ) {
                        // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
                        // interception point throws a ForwardRequest,
                        // no other Interceptors' send_request operations are
                        // called.
                        flowStackIndex = i;
                        info.setForwardRequest( e );
                        info.setEndingPointCall(
                            ClientRequestInfoImpl.CALL_RECEIVE_OTHER );
                        info.setReplyStatus( LOCATION_FORWARD.value );

                        updateClientRequestDispatcherForward( info );

                        // For some reason, using break here causes the VM on
                        // NT to lose track of the value of flowStackIndex
                        // after exiting the for loop.  I changed this to
                        // check a boolean value instead and it seems to work
                        // fine.
                        continueProcessing = false;
                    }
                    catch( SystemException e ) {
                        // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
                        // interception point throws a SystemException,
                        // no other Interceptors' send_request operations are
                        // called.
                        flowStackIndex = i;
                        info.setEndingPointCall(
                            ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION );
                        info.setReplyStatus( SYSTEM_EXCEPTION.value );
                        info.setException( e );

                        // For some reason, using break here causes the VM on
                        // NT to lose track of the value of flowStackIndex
                        // after exiting the for loop.  I changed this to
                        // check a boolean value instead and it seems to
                        // work fine.
                        continueProcessing = false;
                    }
                }

                // Remember where we left off in the flow stack:
                info.setFlowStackIndex( flowStackIndex );
            }
            finally {
                // Make the SlotTable fresh for the next interception point.
                current.resetSlotTable( );
            }
        } // end enabled check
    }

    /**
     * Invokes either receive_reply, receive_exception, or receive_other,
     * depending on the value of info.getEndingPointCall()
     */
    void invokeClientInterceptorEndingPoint( ClientRequestInfoImpl info ) {
        // If invocation is not yet enabled, don't do anything.
        if( enabled ) {
            try {
                // NOTE: It is assumed someplace else prepared a
                // fresh TSC slot table.

                info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );

                // Get all ClientRequestInterceptors:
                ClientRequestInterceptor[] clientInterceptors =
                    (ClientRequestInterceptor[])interceptorList.
                    getInterceptors( InterceptorList.INTERCEPTOR_TYPE_CLIENT );
                int flowStackIndex = info.getFlowStackIndex();

                // Determine whether we are calling receive_reply,
                // receive_exception, or receive_other:
                int endingPointCall = info.getEndingPointCall();

                // If we would be calling RECEIVE_REPLY, but this is a
                // one-way call, override this and call receive_other:
                if( ( endingPointCall ==
                      ClientRequestInfoImpl.CALL_RECEIVE_REPLY ) &&
                    info.getIsOneWay() )
                {
                    endingPointCall = ClientRequestInfoImpl.CALL_RECEIVE_OTHER;
                    info.setEndingPointCall( endingPointCall );
                }

                // Only step through the interceptors whose starting points
                // have successfully returned.
                // Unlike the previous loop, this one counts backwards for a
                // reason - we must execute these in the reverse order of the
                // starting points.
                for( int i = (flowStackIndex - 1); i >= 0; i-- ) {

                    try {
                        switch( endingPointCall ) {
                        case ClientRequestInfoImpl.CALL_RECEIVE_REPLY:
                            clientInterceptors[i].receive_reply( info );
                            break;
                        case ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION:
                            clientInterceptors[i].receive_exception( info );
                            break;
                        case ClientRequestInfoImpl.CALL_RECEIVE_OTHER:
                            clientInterceptors[i].receive_other( info );
                            break;
                        }
                    }
                    catch( ForwardRequest e ) {

                        // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
                        // interception point throws a ForwardException,
                        // ending point call changes to receive_other.
                        endingPointCall =
                            ClientRequestInfoImpl.CALL_RECEIVE_OTHER;
                        info.setEndingPointCall( endingPointCall );
                        info.setReplyStatus( LOCATION_FORWARD.value );
                        info.setForwardRequest( e );
                        updateClientRequestDispatcherForward( info );
                    }
                    catch( SystemException e ) {

                        // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
                        // interception point throws a SystemException,
                        // ending point call changes to receive_exception.
                        endingPointCall =
                            ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION;
                        info.setEndingPointCall( endingPointCall );
                        info.setReplyStatus( SYSTEM_EXCEPTION.value );
                        info.setException( e );
                    }
                }
            }
            finally {
                // See doc for setPICurrentPushed as to why this is necessary.
                // Check info for null in case errors happen before initiate.
                if (info != null && info.isPICurrentPushed()) {
                    current.popSlotTable( );
                    // After the pop, original client's TSC slot table
                    // remains avaiable via PICurrent.
                }
            }
        } // end enabled check
    }

    /*
     **********************************************************************
     * Server Interceptor invocation
     **********************************************************************/

    /**
     * Invokes receive_request_service_context interception points.
     */
    void invokeServerInterceptorStartingPoint( ServerRequestInfoImpl info ) {
        // If invocation is not yet enabled, don't do anything.
        if( enabled ) {
            try {
                // Make a fresh slot table for RSC.
                current.pushSlotTable();
                info.setSlotTable(current.getSlotTable());

                // Make a fresh slot table for TSC in case
                // interceptors need to make out calls.
                current.pushSlotTable( );

                info.setCurrentExecutionPoint( info.EXECUTION_POINT_STARTING );

                // Get all ServerRequestInterceptors:
                ServerRequestInterceptor[] serverInterceptors =
                    (ServerRequestInterceptor[])interceptorList.
                    getInterceptors( InterceptorList.INTERCEPTOR_TYPE_SERVER );
                int size = serverInterceptors.length;

                // We will assume that all interceptors returned successfully,
                // and adjust the flowStackIndex to the appropriate value if
                // we later discover otherwise.
                int flowStackIndex = size;
                boolean continueProcessing = true;

                // Currently, there is only one server-side starting point
                // interceptor called receive_request_service_contexts.
                for( int i = 0; continueProcessing && (i < size); i++ ) {

                    try {
                        serverInterceptors[i].
                            receive_request_service_contexts( info );
                    }
                    catch( ForwardRequest e ) {
                        // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
                        // interception point throws a ForwardRequest,
                        // no other Interceptors' starting points are
                        // called and send_other is called.
                        flowStackIndex = i;
                        info.setForwardRequest( e );
                        info.setIntermediatePointCall(
                            ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE );
                        info.setEndingPointCall(
                            ServerRequestInfoImpl.CALL_SEND_OTHER );
                        info.setReplyStatus( LOCATION_FORWARD.value );

                        // For some reason, using break here causes the VM on
                        // NT to lose track of the value of flowStackIndex
                        // after exiting the for loop.  I changed this to
                        // check a boolean value instead and it seems to work
                        // fine.
                        continueProcessing = false;
                    }
                    catch( SystemException e ) {

                        // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
                        // interception point throws a SystemException,
                        // no other Interceptors' starting points are
                        // called.
                        flowStackIndex = i;
                        info.setException( e );
                        info.setIntermediatePointCall(
                            ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE );
                        info.setEndingPointCall(
                            ServerRequestInfoImpl.CALL_SEND_EXCEPTION );
                        info.setReplyStatus( SYSTEM_EXCEPTION.value );

                        // For some reason, using break here causes the VM on
                        // NT to lose track of the value of flowStackIndex
                        // after exiting the for loop.  I changed this to
                        // check a boolean value instead and it seems to
                        // work fine.
                        continueProcessing = false;
                    }

                }

                // Remember where we left off in the flow stack:
                info.setFlowStackIndex( flowStackIndex );
            }
            finally {
                // The remaining points, ServantManager and Servant
                // all run in the same logical thread.
                current.popSlotTable( );
                // Now TSC and RSC are equivalent.
            }
        } // end enabled check
    }

    /**
     * Invokes receive_request interception points
     */
    void invokeServerInterceptorIntermediatePoint(
        ServerRequestInfoImpl info )
    {
        int intermediatePointCall = info.getIntermediatePointCall();
        // If invocation is not yet enabled, don't do anything.
        if( enabled && ( intermediatePointCall !=
                         ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE ) )
        {
            // NOTE: do not touch the slotStack.  The RSC and TSC are
            // equivalent at this point.

            info.setCurrentExecutionPoint( info.EXECUTION_POINT_INTERMEDIATE );

            // Get all ServerRequestInterceptors:
            ServerRequestInterceptor[] serverInterceptors =
                (ServerRequestInterceptor[])
                interceptorList.getInterceptors(
                InterceptorList.INTERCEPTOR_TYPE_SERVER );
            int size = serverInterceptors.length;

            // Currently, there is only one server-side intermediate point
            // interceptor called receive_request.
            for( int i = 0; i < size; i++ ) {

                try {
                    serverInterceptors[i].receive_request( info );
                }
                catch( ForwardRequest e ) {

                    // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
                    // interception point throws a ForwardRequest,
                    // no other Interceptors' intermediate points are
                    // called and send_other is called.
                    info.setForwardRequest( e );
                    info.setEndingPointCall(
                        ServerRequestInfoImpl.CALL_SEND_OTHER );
                    info.setReplyStatus( LOCATION_FORWARD.value );
                    break;
                }
                catch( SystemException e ) {

                    // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
                    // interception point throws a SystemException,
                    // no other Interceptors' starting points are
                    // called.
                    info.setException( e );
                    info.setEndingPointCall(
                        ServerRequestInfoImpl.CALL_SEND_EXCEPTION );
                    info.setReplyStatus( SYSTEM_EXCEPTION.value );
                    break;
                }
            }
        } // end enabled check
    }

    /**
     * Invokes either send_reply, send_exception, or send_other,
     * depending on the value of info.getEndingPointCall()
     */
    void invokeServerInterceptorEndingPoint( ServerRequestInfoImpl info ) {
        // If invocation is not yet enabled, don't do anything.
        if( enabled ) {
            try {
                // NOTE: do not touch the slotStack.  The RSC and TSC are
                // equivalent at this point.

                // REVISIT: This is moved out to PIHandlerImpl until dispatch
                // path is rearchitected.  It must be there so that
                // it always gets executed so if an interceptor raises
                // an exception any service contexts added in earlier points
                // this point get put in the exception reply (via the SC Q).
                //info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );

                // Get all ServerRequestInterceptors:
                ServerRequestInterceptor[] serverInterceptors =
                    (ServerRequestInterceptor[])interceptorList.
                    getInterceptors( InterceptorList.INTERCEPTOR_TYPE_SERVER );
                int flowStackIndex = info.getFlowStackIndex();

                // Determine whether we are calling
                // send_exception, or send_other:
                int endingPointCall = info.getEndingPointCall();

                // Only step through the interceptors whose starting points
                // have successfully returned.
                for( int i = (flowStackIndex - 1); i >= 0; i-- ) {
                    try {
                        switch( endingPointCall ) {
                        case ServerRequestInfoImpl.CALL_SEND_REPLY:
                            serverInterceptors[i].send_reply( info );
                            break;
                        case ServerRequestInfoImpl.CALL_SEND_EXCEPTION:
                            serverInterceptors[i].send_exception( info );
                            break;
                        case ServerRequestInfoImpl.CALL_SEND_OTHER:
                            serverInterceptors[i].send_other( info );
                            break;
                        }
                    }
                    catch( ForwardRequest e ) {
                        // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
                        // interception point throws a ForwardException,
                        // ending point call changes to receive_other.
                        endingPointCall =
                            ServerRequestInfoImpl.CALL_SEND_OTHER;
                        info.setEndingPointCall( endingPointCall );
                        info.setForwardRequest( e );
                        info.setReplyStatus( LOCATION_FORWARD.value );
                        info.setForwardRequestRaisedInEnding();
                    }
                    catch( SystemException e ) {
                        // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
                        // interception point throws a SystemException,
                        // ending point call changes to send_exception.
                        endingPointCall =
                            ServerRequestInfoImpl.CALL_SEND_EXCEPTION;
                        info.setEndingPointCall( endingPointCall );
                        info.setException( e );
                        info.setReplyStatus( SYSTEM_EXCEPTION.value );
                    }
                }

                // Remember that all interceptors' starting and ending points
                // have already been executed so we need not do anything.
                info.setAlreadyExecuted( true );
            }
            finally {
                // Get rid of the Server side RSC.
                current.popSlotTable();
            }
        } // end enabled check
    }

    /*
     **********************************************************************
     * Private utility methods
     **********************************************************************/

    /**
     * Update the client delegate in the event of a ForwardRequest, given the
     * information in the passed-in info object.
     */
    private void updateClientRequestDispatcherForward(
        ClientRequestInfoImpl info )
    {
        ForwardRequest forwardRequest = info.getForwardRequestException();

        // ForwardRequest may be null if the forwarded IOR is set internal
        // to the ClientRequestDispatcher rather than explicitly through Portable
        // Interceptors.  In this case, we need not update the client
        // delegate ForwardRequest object.
        if( forwardRequest != null ) {
            org.omg.CORBA.Object object = forwardRequest.forward;

            // Convert the forward object into an IOR:
            IOR ior = ORBUtility.getIOR( object ) ;
            info.setLocatedIOR( ior );
        }
    }

}