/*
 *  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.yoko.orb.PortableInterceptor;

import org.apache.yoko.util.cmsf.CmsfThreadLocal;
import org.apache.yoko.util.cmsf.CmsfThreadLocal.CmsfOverride;
import org.apache.yoko.util.yasf.YasfThreadLocal;
import org.apache.yoko.util.yasf.YasfThreadLocal.YasfOverride;

final public class ServerRequestInfo_impl extends RequestInfo_impl implements
        ServerRequestInfoExt {
    //
    // Sequence of ServerRequestInterceptors to call on reply
    //
    java.util.Vector interceptors_ = new java.util.Vector();

    //
    // The adapter ID
    //
    private byte[] adapterId_;

    //
    // The object-id
    //
    private byte[] objectId_;

    //
    // The servant
    //
    private org.omg.PortableServer.Servant servant_;

    //
    // The POA
    //
    private org.omg.PortableServer.POA poa_;

    //
    // The adapter ORT
    //
    private org.omg.PortableInterceptor.ObjectReferenceTemplate adapterTemplate_;

    //
    // The adapter name
    //
    private String[] adapterName_;

    //
    // The information about the transport servicing this request
    //
    private org.apache.yoko.orb.OCI.TransportInfo transportInfo_;

    // ------------------------------------------------------------------
    // Standard IDL to Java mapping
    // ------------------------------------------------------------------

    //
    // Return the raised exception.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: no
    // send_reply: no send_exception: yes send_other: no
    //
    public org.omg.CORBA.Any sending_exception() {
        //
        // If status is not SYSTEM_EXCEPTION or USER_EXCEPTION then this
        // is a BAD_INV_ORDER exception
        //
        if (status_ != org.omg.PortableInterceptor.SYSTEM_EXCEPTION.value
                && status_ != org.omg.PortableInterceptor.USER_EXCEPTION.value)
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);

        //
        // If the application code hasn't provided the exception
        // then we insert an UNKNOWN
        //
        // (Java only)
        //
        if (receivedException_ == null) {
            org.omg.CORBA.Any any = orb_.create_any();
            org.apache.yoko.orb.OB.Util
                    .insertException(
                            any,
                            new org.omg.CORBA.UNKNOWN(
                                    org.apache.yoko.orb.OB.MinorCodes
                                            .describeUnknown(org.apache.yoko.orb.OB.MinorCodes.MinorUnknownUserException)
                                            + ": exception unavailable",
                                    org.apache.yoko.orb.OB.MinorCodes.MinorUnknownUserException,
                                    org.omg.CORBA.CompletionStatus.COMPLETED_YES));
            return any;
        }

        //
        // UnknownUserException? Extract the contained UserException.
        //
        org.omg.CORBA.UnknownUserException unk = null;
        try {
            unk = (org.omg.CORBA.UnknownUserException) receivedException_;
        } catch (ClassCastException ex) {
        }
        if (unk != null)
            return unk.except;

        org.omg.CORBA.Any any = orb_.create_any();
        org.apache.yoko.orb.OB.Util.insertException(any, receivedException_);

        return any;
    }

    //
    // Return the object-id of the destination of this request.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public byte[] object_id() {
        if (status_ == NO_REPLY_SC)
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);

        byte[] data = new byte[objectId_.length];
        System.arraycopy(objectId_, 0, data, 0, objectId_.length);

        return data;
    }

    //
    // Return the adapter_id of the destination of this request.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public byte[] adapter_id() {
        if (status_ == NO_REPLY_SC)
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);

        byte[] result = new byte[adapterId_.length];
        System.arraycopy(adapterId_, 0, result, 0, adapterId_.length);
        return result;
    }

    //
    // Return the adapter_id of the destination of this request.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: yes
    // send_reply: no send_exception: no send_other: no
    //
    public String target_most_derived_interface() {
        if (status_ == NO_REPLY_SC || servant_ == null)
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);

        org.apache.yoko.orb.OB.Assert._OB_assert(poa_ != null);
        return servant_._all_interfaces(poa_, objectId_)[0];
    }

    //
    // Return the server_id of the destination of this request.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public String server_id() {
        if (status_ == NO_REPLY_SC)
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);

        return adapterTemplate_.server_id();
    }

    //
    // Return the orb_id of the destination of this request.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public String orb_id() {
        if (status_ == NO_REPLY_SC)
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);

        return adapterTemplate_.orb_id();
    }

    //
    // Return the adapter_name of the destination of this request.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public String[] adapter_name() {
        if (status_ == NO_REPLY_SC)
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);

        return adapterTemplate_.adapter_name();
    }

    //
    // Retrieve the policy with the provided type in effect for this
    // object-adapter.
    //
    // Server side:
    //
    // receive_request_service_contexts: yes receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public org.omg.CORBA.Policy get_server_policy(int type) {
        for (int i = 0; i < policies_.length; i++) {
            if (policies_[i].policy_type() == type) {
                return policies_[i];
            }
        }

        // if the target policy was not in the current policy list, check to see
        // if the type has even been registered.  If it is valid, return null
        // to indicate we ain't got one.
        if (orbInstance_.getPolicyFactoryManager().isPolicyRegistered(type)) {
            return null;
        }

        throw new org.omg.CORBA.INV_POLICY(
                org.apache.yoko.orb.OB.MinorCodes
                        .describeInvPolicy(org.apache.yoko.orb.OB.MinorCodes.MinorNoPolicyFactory)
                        + ": " + type,
                org.apache.yoko.orb.OB.MinorCodes.MinorNoPolicyFactory,
                org.omg.CORBA.CompletionStatus.COMPLETED_NO);
    }

    //
    // Set the slot in the slot table for the request thread-level data.
    //
    // Server side:
    //
    // receive_request_service_contexts: yes receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public void set_slot(int id, org.omg.CORBA.Any data)
            throws org.omg.PortableInterceptor.InvalidSlot {
        if (id >= slots_.length) {
            throw new org.omg.PortableInterceptor.InvalidSlot();
        }
        logger.fine("setting slot " + id + " for operation " + op_); 
        slots_[id] = new org.apache.yoko.orb.CORBA.Any(data);
    }

    //
    // Determine if the servant has the given repository id.
    //
    // Server side:
    //
    // receive_request_service_contexts: no receive_request: yes
    // send_reply: no send_exception: no send_other: no
    //
    public boolean target_is_a(String id) {
        if (status_ == NO_REPLY_SC || servant_ == null) {
            throw new org.omg.CORBA.BAD_INV_ORDER(
                    org.apache.yoko.orb.OB.MinorCodes
                            .describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall),
                    org.apache.yoko.orb.OB.MinorCodes.MinorInvalidPICall,
                    org.omg.CORBA.CompletionStatus.COMPLETED_NO);
        }

        return servant_._is_a(id);
    }

    //
    // Add a service context for the reply.
    //
    // Server side:
    //
    // receive_request_service_contexts: yes receive_request: yes
    // send_reply: yes send_exception: yes send_other: yes
    //
    public void add_reply_service_context(org.omg.IOP.ServiceContext sc,
            boolean addReplace) {
        addServiceContext(replySCL_, sc, addReplace);
    }

    // ------------------------------------------------------------------
    // Yoko internal functions
    // Application programs must not use these functions directly
    // ------------------------------------------------------------------

    public ServerRequestInfo_impl(
            org.omg.CORBA.ORB orb,
            int id,
            String op,
            boolean responseExpected,
            org.omg.CORBA.Policy[] policies,
            byte[] adapterId,
            byte[] objectId,
            org.omg.PortableInterceptor.ObjectReferenceTemplate adapterTemplate,
            java.util.Vector request, java.util.Vector reply,
            org.apache.yoko.orb.OB.ORBInstance orbInstance, Current_impl current,
            org.apache.yoko.orb.OCI.TransportInfo transportInfo) {
        super(orb, id, op, responseExpected, request, reply, orbInstance,
                policies, current);

        adapterId_ = adapterId;
        objectId_ = objectId;
        adapterTemplate_ = adapterTemplate;
        servant_ = null;
        poa_ = null;
        transportInfo_ = transportInfo;

        //
        // TODO: Dump NO_REPLY_SC
        //
        status_ = NO_REPLY_SC;

        //
        // Start of with a Null strategy. It's not necessary to deal with
        // arguments() and exceptions() being called during
        // receive_request_service_contexts since this cannot occur.
        //
        argStrategy_ = new ArgumentStrategyNull(orb_);

        //
        // On the server side the slots_ are initialized with the
        // correct number of entries
        //
        slots_ = current_._OB_newSlotTable();
    }

    public void _OB_requestServiceContext(java.util.Vector interceptors)
            throws org.apache.yoko.orb.OB.LocationForward {
        //
        // Arguments, result and exceptions not available
        //
        argStrategy_.setResultAvail(false);
        argStrategy_.setArgsAvail(false);
        argStrategy_.setExceptAvail(false);

        try (CmsfOverride cmsfo = CmsfThreadLocal.override();
             YasfOverride yasfo = YasfThreadLocal.override()) {
            java.util.Enumeration e = interceptors.elements();
            while (e.hasMoreElements()) {
                org.omg.PortableInterceptor.ServerRequestInterceptor i = (org.omg.PortableInterceptor.ServerRequestInterceptor) e
                        .nextElement();

                i.receive_request_service_contexts(this);
                interceptors_.addElement(i);
            }

            popCurrent_ = true;
            current_._OB_pushSlotData(slots_);
        } catch (org.omg.PortableInterceptor.ForwardRequest ex) {
            org.apache.yoko.orb.CORBA.Delegate p = (org.apache.yoko.orb.CORBA.Delegate) (((org.omg.CORBA.portable.ObjectImpl) ex.forward)
                    ._get_delegate());
            throw new org.apache.yoko.orb.OB.LocationForward(p._OB_IOR(), false);
        }
    }

    public void _OB_request() throws org.apache.yoko.orb.OB.LocationForward {
        //
        // Arguments, exceptions are now available. Result isn't.
        //
        argStrategy_.setArgsAvail(true);
        argStrategy_.setExceptAvail(true);

        status_ = NO_REPLY;

        try (CmsfOverride cmsfo = CmsfThreadLocal.override();
             YasfOverride yasfo = YasfThreadLocal.override()) {
            java.util.Enumeration e = interceptors_.elements();
            while (e.hasMoreElements()) {
                ((org.omg.PortableInterceptor.ServerRequestInterceptor) (e
                        .nextElement())).receive_request(this);
            }
        } catch (org.omg.PortableInterceptor.ForwardRequest ex) {
            org.apache.yoko.orb.CORBA.Delegate p = (org.apache.yoko.orb.CORBA.Delegate) (((org.omg.CORBA.portable.ObjectImpl) ex.forward)
                    ._get_delegate());
            throw new org.apache.yoko.orb.OB.LocationForward(p._OB_IOR(), false);
        }
    }

    public void _OB_sendReply() {
        org.apache.yoko.orb.OB.Assert
                ._OB_assert(status_ == org.omg.PortableInterceptor.SUCCESSFUL.value);
        //
        // The result is available
        //
        argStrategy_.setResultAvail(true);

        //
        // The servant is no longer available
        //
        servant_ = null;

        try (CmsfOverride cmsfo = CmsfThreadLocal.override();
             YasfOverride yasfo = YasfThreadLocal.override()) {
            int curr = interceptors_.size() - 1;
            while (!interceptors_.isEmpty()) {
                org.omg.PortableInterceptor.ServerRequestInterceptor i = (org.omg.PortableInterceptor.ServerRequestInterceptor) interceptors_
                        .elementAt(curr);
                interceptors_.removeElementAt(curr);
                --curr;

                i.send_reply(this);
            }
        }

        //
        // If a set of slots was provided to the Current implementation
        // then the slots have to be popped
        //
        if (popCurrent_) {
            popCurrent_ = false;
            current_._OB_popSlotData();
        }
    }

    public void _OB_sendException()
            throws org.apache.yoko.orb.OB.LocationForward {
        //
        // Arguments, result not available
        //
        argStrategy_.setResultAvail(false);
        argStrategy_.setArgsAvail(false);

        //
        // The servant is no longer available
        //
        servant_ = null;

        try (CmsfOverride cmsfo = CmsfThreadLocal.override();
             YasfOverride yasfo = YasfThreadLocal.override()) {
            org.apache.yoko.orb.OB.Assert
                    ._OB_assert(status_ == org.omg.PortableInterceptor.SYSTEM_EXCEPTION.value
                            || status_ == org.omg.PortableInterceptor.USER_EXCEPTION.value);

            int curr = interceptors_.size() - 1;
            while (!interceptors_.isEmpty()) {
                org.omg.PortableInterceptor.ServerRequestInterceptor i = (org.omg.PortableInterceptor.ServerRequestInterceptor) interceptors_
                        .elementAt(curr);
                interceptors_.removeElementAt(curr);
                --curr;

                i.send_exception(this);
            }

            //
            // If a set of slots was provided to the Current implementation
            // then the slots have to be popped
            //
            if (popCurrent_) {
                popCurrent_ = false;
                current_._OB_popSlotData();
            }
        } catch (org.omg.PortableInterceptor.ForwardRequest ex) {
            org.apache.yoko.orb.CORBA.Delegate p = (org.apache.yoko.orb.CORBA.Delegate) (((org.omg.CORBA.portable.ObjectImpl) ex.forward)
                    ._get_delegate());
            throw new org.apache.yoko.orb.OB.LocationForward(p._OB_IOR(), false);
        }
    }

    public void _OB_sendOther() throws org.apache.yoko.orb.OB.LocationForward {
        //
        // Arguments, result not available
        //
        argStrategy_.setResultAvail(false);
        argStrategy_.setArgsAvail(false);

        //
        // The servant is no longer available
        //
        servant_ = null;

        try (CmsfOverride cmsfo = CmsfThreadLocal.override();
             YasfOverride yasfo = YasfThreadLocal.override()) {
            org.apache.yoko.orb.OB.Assert
                    ._OB_assert(status_ == org.omg.PortableInterceptor.LOCATION_FORWARD.value
                            || status_ == org.omg.PortableInterceptor.TRANSPORT_RETRY.value);

            int curr = interceptors_.size() - 1;
            while (!interceptors_.isEmpty()) {
                org.omg.PortableInterceptor.ServerRequestInterceptor i = (org.omg.PortableInterceptor.ServerRequestInterceptor) interceptors_
                        .elementAt(curr);
                interceptors_.removeElementAt(curr);
                --curr;

                i.send_other(this);
            }

            //
            // If a set of slots was provided to the Current implementation
            // then the slots have to be popped
            //
            if (popCurrent_) {
                popCurrent_ = false;
                current_._OB_popSlotData();
            }
        } catch (org.omg.PortableInterceptor.ForwardRequest ex) {
            org.apache.yoko.orb.CORBA.Delegate p = (org.apache.yoko.orb.CORBA.Delegate) (((org.omg.CORBA.portable.ObjectImpl) ex.forward)
                    ._get_delegate());
            throw new org.apache.yoko.orb.OB.LocationForward(p._OB_IOR(), false);
        }
    }

    public void _OB_servant(org.omg.PortableServer.Servant servant,
            org.omg.PortableServer.POA poa) {
        servant_ = servant;
        poa_ = poa;
    }

    //
    // Called when we are entering or leaving a thread, to allow
    // the Current to be managed properly
    //
    public void _OB_contextSwitch() {
        if (popCurrent_) {
            logger.fine("Popping the PICurrent because of a context switch"); 
            popCurrent_ = false;
            current_._OB_popSlotData();
        } else {
            logger.fine("Pushing the PICurrent because of a context switch"); 
            popCurrent_ = true;
            current_._OB_pushSlotData(slots_);
        }
    }

    public void _OB_parameterDesc(
            org.apache.yoko.orb.OB.ParameterDesc[] argDesc,
            org.apache.yoko.orb.OB.ParameterDesc retDesc,
            org.omg.CORBA.TypeCode[] exceptionTC) {
        //
        // Update the argument strategy
        //
        argStrategy_ = new ArgumentStrategySII(orb_, argDesc, retDesc,
                exceptionTC);
    }

    public void _OB_arguments(org.omg.CORBA.NVList args) {
        //
        // Update the argument strategy
        //
        argStrategy_ = new ArgumentStrategyDII(orb_, args);

        //
        // Exceptions are never available
        //
        argStrategy_.setExceptNeverAvail();
    }

    public void _OB_result(org.omg.CORBA.Any value) {
        //
        // Result is now available. Update the argument strategy.
        //
        org.apache.yoko.orb.OB.Assert._OB_assert(argStrategy_ != null);
        argStrategy_.setResult(value);
    }


    /**
     * Retrieve the TransportInfo object associated with this server
     * request.  The TransportInfo object contains information about
     * the connection used for the request.
     *
     * @return The TransportInfo object created by the OCI layer.
     */
    public org.apache.yoko.orb.OCI.TransportInfo getTransportInfo() {
        return transportInfo_;
    }
}