/*
 * Copyright 2004,2005 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef AXIS2_CALL_H
#define AXIS2_CALL_H


/**
  * @file axis2_call.h
  * @brief axis2 Message Context interface
  */

#include <axis2_defines.h>
#include <axis2_env.h>
#include <axis2_mep_client.h>
#include <axis2_callback.h>
#include <axis2_soap_envelope.h>


#ifdef __cplusplus
extern "C"
{
#endif

/** @defgroup axis2_call Message Context 
 * @ingroup axis2_core_context
 * @{
 */
    
typedef struct axis2_call_ops axis2_call_ops_t;
typedef struct axis2_call axis2_call_t; 
struct axis2_conf;
    
/** 
 * @brief Message Context ops struct
 * Encapsulator struct for ops of axis2_call
 */  
struct axis2_call_ops
{
    axis2_mep_client_t* (AXIS2_CALL *get_base)(struct axis2_call *call,
                                    axis2_env_t **env);
    /**
     * This accepts a ServiceContext, and the axis2_svc_ctx_t *should have all the parents set in to it right
     * Ideall this should be generated from a WSDL, we do not have it yet.
     * <p/>
     * Follwoing code works for the time been
     * <code>
     * ConfigurationContextFactory efac = new ConfigurationContextFactory();
     * ConfigurationContext sysContext = efac.buildClientConfigurationContext(null);
     * // above line "null" may be a file name if you know the client repssitory
     * <p/>
     * //create new service
     * QName assumedServiceName = new QName("Your Service");
     * AxisService axisService = new AxisService(assumedServiceName);
     * sysContext.getEngineConfig().addService(axisService);
     * axis2_svc_ctx_t *service = sysContext.createServiceContext(assumedServiceName);
     * return service;
     * <p/>
     * </code>
     *
     * @param svc_ctx
     */
    
    /**
     * @param to
     */
    axis2_status_t (AXIS2_CALL *set_to)(struct axis2_call *call, 
        axis2_env_t **env,
        axis2_endpoint_ref_t *to);
    /**
     * Set transport information to the the Call, for find how the each parameter 
     * acts see the commant at the instance variables. The senarios supoorted 
     * are as follows.
     * [sender_transport, listener_transport, use_separate_listener]
     * http, http, true
     * http, http, false
     * http,smtp,true
     * smtp,http,true
     * smtp,smtp,true
     *
     * @param sender_transport
     * @param listener_transport
     * @param use_separate_listener
     * @throws AxisFault
     */
    axis2_status_t (AXIS2_CALL *set_transport_info)(struct axis2_call *call, 
                                axis2_env_t **env,
                                axis2_char_t *sender_transport,
                                 axis2_char_t *listener_transport,
                                 axis2_bool_t use_separate_listener);
    /**
     * Check has the transports are identified correctly
     *
     * @param msg_ctx
     * @throws AxisFault
     */
    axis2_status_t (AXIS2_CALL *check_transport)(struct axis2_call *call, 
        axis2_env_t **env,
        axis2_msg_ctx_t *msg_ctx);
    /**
     * Closing the Call, this will stop the started Transport Listeners. If there are multiple
     * request to send the Call should be kept open closing only when done
     */
    axis2_status_t (AXIS2_CALL *close)(struct axis2_call *call, 
        axis2_env_t **env);
    /**
     * This will be used in invoke blocking scenario. Client will wait the amount of time specified here
     * and if there is no response, call will timeout. This should be given in multiples of 100 and defaults to 2000.
     * @param time_out_ms
     */
    axis2_status_t (AXIS2_CALL *set_time)(struct axis2_call *call, 
        axis2_env_t **env,
        long time_out_ms);
    /**
     * This invocation done via this method blocks till the result arrives, 
     * using this method does not indicate
     * anyhting about the transport used or the nature of the transport.
     * e.g. invocation done with this method might
     * <ol>
     * <li>send request via http and recevie the response via the return path of the same http connection</li>
     * <li>send request via http and recevie the response different http connection</li>
     * <li>send request via an email smtp and recevie the response via an email</li>
     * </ol>
     */
    
    axis2_msg_ctx_t* (AXIS2_CALL *invoke_blocking)(struct axis2_call *call, 
                                        axis2_env_t **env,
                                        axis2_op_t *op,
                                        axis2_msg_ctx_t *msg_ctx);
    /**
     * This invocation done via this method blocks till the result arrives, using this method does not indicate
     * anyhting about the transport used or the nature of the transport.
     */
    axis2_status_t (AXIS2_CALL *invoke_non_blocking)(struct axis2_call *call, 
                                        axis2_env_t **env,
                                        axis2_op_t *op,
                                        axis2_msg_ctx_t *msg_ctx,
                                        axis2_callback_t *callback);
    /**
     * Invoke the blocking/Synchronous call
     *
     * @param op - this will be used to identify the operation in the client side, without dispatching
     * @param toSend - This should be OM Element (payload)
     * @return
     * @throws AxisFault
     */
    axis2_om_node_t* (AXIS2_CALL *invoke_blocking_with_om)(struct axis2_call *call, 
        axis2_env_t **env,
        axis2_char_t *op_name, axis2_om_node_t *om_node_to_send);
    /**
     * Invoke the blocking/Synchronous call
     *
     * @param op_name - this will be used to identify the operation in the client side, without dispatching
     * @param envelope - This should be SOAPEnvelope
     * @return
     * @throws AxisFault
     */
    axis2_soap_envelope_t* (AXIS2_CALL *invoke_blocking_with_soap)(struct axis2_call *call, 
        axis2_env_t **env,
        axis2_char_t *op_name, axis2_soap_envelope_t *envelope);
    /**
     * Invoke the nonblocking/Asynchronous call
     *
     * @param op_name
     * @param om_node_to_send   -  This should be OM Element (payload)
     *                 invocation behaves accordingly
     * @param callback
     * @throws org.apache.axis2.AxisFault
     */
    axis2_status_t (AXIS2_CALL *invoke_non_blocking_with_om)(struct axis2_call *call, 
        axis2_env_t **env,
        axis2_char_t *op_name,
        axis2_om_node_t *om_node_to_send,
        axis2_callback_t *callback);
    /**
     * Invoke the nonblocking/Asynchronous call
     *
     * @param op_name
     * @param envelope   -  This should be a SOAP Envelope
     *                 invocation behaves accordingly
     * @param callback
     * @throws org.apache.axis2.AxisFault
     */
    
    axis2_status_t (AXIS2_CALL *invoke_non_blocking_with_soap)(struct axis2_call *call, 
        axis2_env_t **env,
        axis2_char_t *op_name,
        axis2_soap_envelope_t *envelope,
        axis2_callback_t * callback);
    /**
     * This method create a operation desc if it null and copy the flows from the template operation
     * @param op
     * @param axisOp
     */
    axis2_op_t* (AXIS2_CALL *create_op_fill_flow)(struct axis2_call *call, 
        axis2_env_t **env,
        axis2_char_t *op_name);
    /**
     * @return
     */
    axis2_msg_ctx_t* (AXIS2_CALL *get_last_res_msg_ctx)(struct axis2_call *call, 
        axis2_env_t **env);
    
    /**
     * @param key
     * @param value
     */
    axis2_status_t (AXIS2_CALL *
    set)(axis2_call_t *call,
                    axis2_env_t **env,
                    axis2_char_t *key,
                    void *value);
    
    axis2_status_t (AXIS2_CALL *free)(struct axis2_call *call, 
                                       axis2_env_t **env);
};

/** 
 * @brief Message Context struct
  *	Axis2 Message Context
 */
struct axis2_call
{
    axis2_call_ops_t *ops;    
};

AXIS2_DECLARE(axis2_call_t*) axis2_call_create(axis2_env_t **env, 
    axis2_svc_ctx_t *svc_ctx, 
    axis2_char_t *client_home);

/************************** Start of function macros **************************/

#define AXIS2_CALL_GET_BASE(call, env) ((call)->ops->get_base(call, env))
#define AXIS2_CALL_INVOKE_BLOCKING(call, env, op, msg_ctx) ((call)->ops->invoke_blocking(call, env, op, msg_ctx))
#define AXIS2_CALL_INVOKE_NON_BLOCKING(call, env, op, msg_ctx, callback) ((call)->ops->invoke_non_blocking(call, env, op, msg_ctx, callback))
#define AXIS2_CALL_SET_TO(call, env, to) ((call)->ops->set_to(call, env, to))
#define AXIS2_CALL_SET_TRANSPORT_INFO(call, env, sender_transport, listener_transport, use_separate_listener) ((call)->ops->set_transport_info(call, env, sender_transport, listener_transport, use_separate_listener))
#define AXIS2_CALL_CHECK_TRANSPORT(call, env, msg_ctx) ((call)->ops->check_transport(call, env, msg_ctx))
#define AXIS2_CALL_CLOSE(call, env) ((call)->ops->close(call, env))
#define AXIS2_CALL_SET_TIME(call, env, time_out_ms) ((call)->ops->set_time(call, env, time_out_ms))
#define AXIS2_CALL_INVOKE_BLOCKING_WITH_OM(call, env, op_name, om_node_to_send) ((call)->ops->invoke_blocking_with_om(call, env, op_name, om_node_to_send))
#define AXIS2_CALL_INVOKE_BLOCKING_WITH_SOAP(call, env, op_name, envelope) ((call)->ops->invoke_blocking_with_soap(call, env, op_name, envelope))
#define AXIS2_CALL_INVOKE_NON_BLOCKING_WITH_OM(call, env, op_name, om_node_to_send, callback) ((call)->ops->invoke_non_blocking_with_om(call, env, op_name, om_node_to_send, callback))
#define AXIS2_CALL_INVOKE_NON_BLOCKING_WITH_SOAP(call, env, op_name, envelope, callback) ((call)->ops->invoke_non_blocking_with_soap(call, env, op_name, envelope, callback))
#define AXIS2_CALL_CREATE_OP_FILL_FLOW(call, env, op_name) ((call)->ops->create_op_fill_flow(call, env, op_name))
#define AXIS2_CALL_GET_LAST_RES_MSG_CTX(call, env) ((call)->ops->get_last_res_msg_ctx(call, env))
#define AXIS2_CALL_SET(call, env, key, value) \
        ((call)->ops->set(call, env, key, value))
#define AXIS2_CALL_FREE(call, env) ((call)->ops->free(call, env))

/************************** End of function macros ****************************/    

/** @} */
#ifdef __cplusplus
}
#endif

#endif                          /* AXIS2_CALL_H */