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

#include "osoa/sca/export.h"
#if defined(WIN32)  || defined (_WINDOWS)
#pragma warning(disable: 4091)
#endif

#include <axis2_client.h>

#include <axis2_error_default.h>
#include <axis2_log_default.h>
#include <axis2_defines.h>
#include <axiom_soap_const.h>
#include <platforms/axis2_platform_auto_sense.h>

#include <sdo_axiom.h>
#include "Axis2Client.h"


#include <osoa/sca/sca.h>
using namespace osoa::sca;
#include "tuscany/sca/core/SCARuntime.h"
#include "tuscany/sca/util/Logging.h"
#include "tuscany/sca/model/WSBinding.h"
#include "tuscany/sca/util/Utils.h"
#include "tuscany/sca/util/Exceptions.h"

using namespace tuscany::sca::ws;


using namespace commonj::sdo;
using namespace commonj::sdo_axiom;

Axis2Client::Axis2Client(ExternalService* extService)
    : externalService(extService)
{
}

Axis2Client::~Axis2Client()
{
}

void Axis2Client::invoke(tuscany::sca::Operation& operation)
{
    LOGENTRY(1, "Axis2Client::invoke");

    // From the external service ws-binding, get the namespace of the wsdl endpoint
    WSBinding* binding = (WSBinding *)externalService->getBinding();
    // TODO check 0 throw

    string portNamespace = binding->getWSDLNamespaceURL();

    // Lookup the wsdl model from the module, keyed on the namespace 
    // (the wsdl will have been loaded at startup, based on the information in the config file)
    Wsdl* wsdlDefinition = externalService->getContainingModule()->findWsdl(portNamespace);
    if (wsdlDefinition == 0)
    {
    	string msg = "WSDL not found for " + portNamespace;
      	throw SystemConfigurationException(msg.c_str());
    }
    
    const string& operationName = operation.getName();

    // Match the operation in Operation to the operation in the wsdl port type.
    const WsdlOperation& wsdlOperation =  wsdlDefinition->findOperation(
                                                       binding->getServiceName(),
                                                       binding->getPortName(),
                                                       operationName);  

    // Initialize Axis2 stuff
    axis2_allocator_t *allocator = axis2_allocator_init (NULL);
    axis2_log_t *log = axis2_log_create(allocator, NULL, "tuscany_client.log");
    axis2_error_t *error = axis2_error_create(allocator);
    axis2_env_t *env = axis2_env_create_with_error_log(allocator, error, log);
    env->log->level = AXIS2_LOG_LEVEL_TRACE;
    axis2_error_init();

    axis2_char_t* address = (axis2_char_t*)wsdlOperation.getEndpoint().c_str();
    axis2_char_t* opName = (axis2_char_t*)operationName.c_str();
    axis2_char_t* soap_action = (axis2_char_t*)wsdlOperation.getSoapAction().c_str();
    axis2_char_t* serviceName = (axis2_char_t*)binding->getServiceName().c_str();
    
    // create OM from Operation and wsdlOperation
    axiom_node_t* payload = createPayload(operation, wsdlOperation, env);

    /* Create EPR with given address */
    axis2_endpoint_ref_t* endpoint_ref = axis2_endpoint_ref_create(env, address);
    
    /* Setup options */
    axis2_options_t* options = axis2_options_create(env);
    AXIS2_OPTIONS_SET_TO(options, env, endpoint_ref);
    int soap_version = AXIOM_SOAP11;
    if (wsdlOperation.getSoapVersion() == WsdlOperation::SOAP12)
    {
    	soap_version = AXIOM_SOAP12;
    }
    
    AXIS2_OPTIONS_SET_SOAP_VERSION(options, env, soap_version);
    AXIS2_OPTIONS_SET_ACTION(options, env, soap_action);

    /* Create service client */
    
    axis2_char_t* client_home = AXIS2_GETENV("AXIS2C_HOME");
    if (!client_home)
    {
      	throw SystemConfigurationException("Environment error: AXIS2C_HOME not set");
    }
    axis2_svc_client_t* svc_client = axis2_svc_client_create(env, client_home);
    if (!svc_client)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "invoke FAILED: Error code:"
						" %d :: %s", env->error->error_number,
                        AXIS2_ERROR_GET_MESSAGE(env->error));
                        
        throw ServiceRuntimeException("Axis2Client: axis2_svc_client_create failed");
    }

    /* Set service client options */
    AXIS2_SVC_CLIENT_SET_OPTIONS(svc_client, env, options);    
    
    /* Send request */
    axiom_node_t* ret_node = AXIS2_SVC_CLIENT_SEND_RECEIVE(svc_client, env, payload);
    if(ret_node)
    {
    	setReturn(ret_node, operation, wsdlOperation, env);
    }
    else
    {
    	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoke failed: Error code:"
                        " %d :: %s", env->error->error_number,
                        AXIS2_ERROR_GET_MESSAGE(env->error));
        throw ServiceRuntimeException("Axis2Client: Invoke failed");
    }
    
    if (svc_client)
    {
        AXIS2_SVC_CLIENT_FREE(svc_client, env);
        svc_client = NULL;
    } 

    LOGEXIT(1, "Axis2Client::invoke");
}

axiom_node_t* Axis2Client::createPayload(Operation& operation, 
                                            const WsdlOperation& wsdlOp,
                                            axis2_env_t* env)
{	
    LOGENTRY(1, "Axis2Client::createPayload");
    axiom_node_t* requestOM = NULL;
    
    // map the operation request to the wsdl
    if (wsdlOp.isDocumentStyle())
    {
    	// Document style 
    	// only support single part messages - WS-I compliant
    	
    	// Build up the payload as an SDO

        // Get the data factory for the module (it will already have the typecreates loaded for the xsds)
      	DataFactoryPtr dataFactory = externalService->getContainingModule()->getDataFactory();
    	DataObjectPtr requestDO = dataFactory->create(wsdlOp.getInputTypeUri().c_str(), 
    	                                              wsdlOp.getInputTypeName().c_str());
    	
    	// Each parameter in the operation should be a property on the request dataobject
    	for (int i=0; i<operation.getNParms(); i++)
    	{
    		Operation::Parameter& parm = operation.getParameter(i);
    		switch(parm.getType())
    		{
    			case Operation::BOOL: 
    			{
    				requestDO->setBoolean(i, *(bool*)parm.getValue());
    				break;
    			}
    			case Operation::SHORT: 
    			{
    				requestDO->setShort(i, *(short*)parm.getValue());
    				break;
    			}
    			case Operation::LONG: 
    			{
    				requestDO->setLong(i, *(long*)parm.getValue());
    				break;
    			}
    			case Operation::USHORT: 
    			{
    				requestDO->setInteger(i, *(unsigned short*)parm.getValue());
    				break;
    			}
    			case Operation::ULONG: 
    			{
    				requestDO->setInteger(i, *(unsigned long*)parm.getValue());
    				break;
    			}
    			case Operation::FLOAT: 
    			{
    				requestDO->setFloat(i, *(float*)parm.getValue());
    				break;
    			}
    			case Operation::DOUBLE: 
    			{
    				requestDO->setDouble(i, *(double*)parm.getValue());
    				break;
    			}
    			case Operation::LONGDOUBLE: 
    			{
    				requestDO->setDouble(i, *(long double*)parm.getValue());
    				break;
    			}
    			case Operation::CHARS: 
    			{
    				requestDO->setCString(i, *(char**)parm.getValue());
    				break;
    			}
    			case Operation::STRING: 
    			{
    				requestDO->setCString(i, (*(string*)parm.getValue()).c_str());
    				break;
    			}
    			case Operation::DATAOBJECT: 
    			{
    				requestDO->setDataObject(i, *(DataObjectPtr*)parm.getValue());
    				break;
    			}
    			default: throw "unsupported parameter type";
    		}
    	}
    	
    	// Create the Axiom object from the request dataobject
    	AxiomHelper myHelper;
    	requestOM = myHelper.toAxiomNode(requestDO);
    }
    else
    {
    	// RPC
    }
    
    // Logging start
    axiom_xml_writer_t* xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE, AXIS2_XML_PARSER_TYPE_BUFFER);
    axiom_output_t* om_output = axiom_output_create( env, xml_writer);
    
    AXIOM_NODE_SERIALIZE(requestOM, env, om_output);
    axis2_char_t* buffer = (axis2_char_t*)AXIOM_XML_WRITER_GET_XML(xml_writer, env);         
    LOGINFO_1(3, "Sending this OM node in XML : %s \n",  buffer); 
    AXIOM_OUTPUT_FREE(om_output, env);
    AXIS2_FREE((env)->allocator, buffer);
    // Logging end

    return requestOM;
    
    LOGEXIT(1, "Axis2Client::createPayload");
}

void Axis2Client::setReturn(axiom_node_t* ret_node,
                            Operation& operation, 
                            const WsdlOperation& wsdlOp,
                            axis2_env_t* env)
{	
    LOGENTRY(1, "Axis2Client::setReturn");
    /* Get the response value from the SOAP message */
    
    // logging start
    axiom_xml_writer_t* writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER);
    axiom_output_t* om_output = axiom_output_create (env, writer);
    AXIOM_NODE_SERIALIZE (ret_node, env, om_output);
    axis2_char_t* buffer = (axis2_char_t*)AXIOM_XML_WRITER_GET_XML(writer, env);
    LOGINFO_1(3,"Received OM node in XML : %s\n", buffer);
    AXIOM_OUTPUT_FREE(om_output, env);
    AXIS2_FREE((env)->allocator, buffer);
    // Logging end
    
    
    if (wsdlOp.isDocumentStyle())
    {
        // Document style 
        
        DataFactoryPtr dataFactory = externalService->getContainingModule()->getDataFactory();
        AxiomHelper myHelper;
        DataObjectPtr returnDO = myHelper.toSdo(ret_node, dataFactory);
        
        unsigned int index = 0;
        switch(operation.getReturnType())
        {
        case Operation::BOOL: 
            {
                *(bool*)operation.getReturnValue() = returnDO->getBoolean(index);
                break;
            }
        case Operation::SHORT: 
            {
                *(short*)operation.getReturnValue() = returnDO->getShort(index);
                break;
            }
        case Operation::LONG: 
            {
                *(long*)operation.getReturnValue() = returnDO->getLong(index);
                break;
            }
        case Operation::USHORT: 
            {
                *(unsigned short*)operation.getReturnValue() = (unsigned short)returnDO->getInteger(index);
                break;
            }
        case Operation::ULONG: 
            {
                *(unsigned long*)operation.getReturnValue() = (unsigned long)returnDO->getInteger(index);
                break;
            }
        case Operation::FLOAT: 
            {
                *(float*)operation.getReturnValue() = returnDO->getFloat(index);
                break;
            }
        case Operation::DOUBLE: 
            {
                *(double*)operation.getReturnValue() = returnDO->getDouble(index);
                break;
            }
        case Operation::LONGDOUBLE: 
            {
                *(long double*)operation.getReturnValue() = returnDO->getDouble(index);
                break;
            }
        case Operation::CHARS: 
            {
                *(char**)operation.getReturnValue() = strdup(returnDO->getCString(index));
                break;
            }
        case Operation::STRING: 
            {
                *(string*)operation.getReturnValue() = returnDO->getCString(index);
                break;
            }
        case Operation::DATAOBJECT: 
            {
                *(DataObjectPtr*)operation.getReturnValue() = returnDO->getDataObject(index);
                break;
            }
        default:;
        }
    }
    else
    {
        // RPC
    }
    LOGEXIT(1, "Axis2Client::setReturn");
}