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

#include <axis2_desc_builder.h>
#include <axutil_string.h>
#include <axutil_class_loader.h>
#include <axutil_utils.h>
#include <axutil_generic_obj.h>
#include <axis2_raw_xml_in_out_msg_recv.h>

struct axis2_desc_builder
{
    /**
     * Store the full path to configuration file.
     */
    axis2_char_t *file_name;
    axiom_stax_builder_t *builder;
    struct axis2_dep_engine *engine;
};

static axis2_status_t
set_attrs_and_value(axutil_param_t *param,
    const axutil_env_t *env,
    axiom_element_t *param_element,
    axiom_node_t *param_node);

AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL
axis2_desc_builder_create(const axutil_env_t *env)
{
    axis2_desc_builder_t *desc_builder = NULL;

    AXIS2_ENV_CHECK(env, NULL);

    desc_builder = (axis2_desc_builder_t *) AXIS2_MALLOC(env->
            allocator, sizeof(axis2_desc_builder_t));


    if (! desc_builder)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
    desc_builder->file_name = NULL;
    desc_builder->engine = NULL;
    desc_builder->builder = NULL;

    return desc_builder;
}

AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL
axis2_desc_builder_create_with_file_and_dep_engine(const axutil_env_t *env,
    axis2_char_t *file_name,
    axis2_dep_engine_t *engine)
{
    axis2_desc_builder_t *desc_builder = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, file_name, NULL);
    AXIS2_PARAM_CHECK(env->error, engine, NULL);

    desc_builder = (axis2_desc_builder_t *)
        axis2_desc_builder_create(env);
    if (! desc_builder)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }

    desc_builder->file_name = axutil_strdup(env, file_name);
    if (!desc_builder->file_name)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
    desc_builder->engine = engine;

    return desc_builder;
}

AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL
axis2_desc_builder_create_with_dep_engine(const axutil_env_t *env,
    struct axis2_dep_engine *engine)
{
    axis2_desc_builder_t *desc_builder = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, engine, NULL);

    desc_builder = (axis2_desc_builder_t *)
        axis2_desc_builder_create(env);
    if (! desc_builder)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }

    desc_builder->engine = engine;

    return desc_builder;
}

AXIS2_EXTERN void AXIS2_CALL
axis2_desc_builder_free(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env)
{
    AXIS2_ENV_CHECK(env, void);

    if (desc_builder->file_name)
    {
        AXIS2_FREE(env->allocator, desc_builder->file_name);
    }

    if (desc_builder->builder)
    {
        axiom_stax_builder_free(desc_builder->builder, env);
    }

    /* we cannot free deployment engine here */
    desc_builder->engine = NULL;

    if (desc_builder)
    {
        AXIS2_FREE(env->allocator, desc_builder);
    }
    return;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axis2_desc_builder_build_om(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env)
{
    axiom_xml_reader_t *reader = NULL;
    axiom_document_t *document = NULL;
    axiom_node_t *root = NULL;

    AXIS2_ENV_CHECK(env, NULL);

    if (!desc_builder->file_name)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_DESC_BUILDER,
            AXIS2_FAILURE);
        return NULL;
    }
    /** create pull parser using the file path to configuration file */
    reader = axiom_xml_reader_create_for_file(env, desc_builder->file_name,
        NULL);

    if (!reader)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
            AXIS2_FAILURE)
        return NULL;
    }

    /** create axiom_stax_builder by parsing pull_parser struct */
    desc_builder->builder = axiom_stax_builder_create(env, reader);

    if (!(desc_builder->builder))
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
            AXIS2_FAILURE)
        return NULL;
    }
    /**
        get the om document form builder 
        document is the container of om model created using builder
    */
    document = axiom_stax_builder_get_document(desc_builder->builder, env);

    /**
     * In description building we don't want defferred building. So build
     * the whole tree at once
     */
    axiom_document_build_all(document, env);
    /**
        get root element , building starts hear 
     */
    root = axiom_document_get_root_element(document, env);
    return root;
}

AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_desc_builder_process_flow(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axiom_element_t *flow_element,
    axutil_param_container_t *parent,
    axiom_node_t *flow_node)
{
    axis2_flow_t *flow = NULL;
    axiom_children_qname_iterator_t *handlers = NULL;
    axutil_qname_t *qchild = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, parent, NULL);
    AXIS2_PARAM_CHECK(env->error, flow_node, NULL);

    flow = axis2_flow_create(env);
    if (!flow)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }

    if (!flow_element)
    {
        return NULL;
    }

    qchild = axutil_qname_create(env, AXIS2_HANDLERST, NULL, NULL);
    handlers = axiom_element_get_children_with_qname(flow_element, env,
        qchild, flow_node);
    if (qchild)
    {
        axutil_qname_free(qchild, env);
    }

    while (AXIS2_TRUE == axiom_children_qname_iterator_has_next(handlers , env))
    {
        axiom_node_t *handler_node = NULL;
        axis2_handler_desc_t *handler_desc = NULL;
        axis2_status_t status = AXIS2_FAILURE;

        handler_node = (axiom_node_t *)
            axiom_children_qname_iterator_next(handlers, env);

        handler_desc = axis2_desc_builder_process_handler(desc_builder, env,
            handler_node, parent);
        status = axis2_flow_add_handler(flow, env, handler_desc);
        if (AXIS2_SUCCESS != status)
        {
            axis2_flow_free(flow, env);
            return NULL;
        }
    }

    return flow;
}

struct axis2_handler_desc *AXIS2_CALL
axis2_desc_builder_process_handler(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axiom_node_t *handler_node,
    struct axutil_param_container *parent)
{
    axis2_handler_desc_t *handler_desc = NULL;
    axiom_attribute_t *name_attrib = NULL;
    axutil_qname_t *attr_qname = NULL;
    axiom_attribute_t *class_attrib = NULL;
    axutil_qname_t *class_qname = NULL;
    axis2_status_t status = AXIS2_FAILURE;
    axis2_char_t *attrib_value = NULL;
    axiom_element_t *handler_element = NULL;
    axiom_node_t *order_node = NULL;
    axiom_element_t *order_element = NULL;
    axutil_qname_t *order_qname = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, handler_node, NULL);
    AXIS2_PARAM_CHECK(env->error, parent, NULL);

    handler_desc = axis2_handler_desc_create(env, NULL);
    if (!handler_desc)
    {
        return NULL;
    }
    /* Setting Handler name */
    attr_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
    handler_element = axiom_node_get_data_element(handler_node, env);
    name_attrib = axiom_element_get_attribute(handler_element, env,
        attr_qname);
    if (attr_qname)
    {
        axutil_qname_free(attr_qname, env);
    }

    if (!name_attrib)
    {
        axis2_handler_desc_free(handler_desc, env);
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
            AXIS2_FAILURE);
        return NULL;
    }
    else
    {
        axutil_string_t *handler_name = NULL;
        axis2_char_t *value = NULL;

        value = axiom_attribute_get_value(name_attrib, env);
        handler_name = axutil_string_create(env, value);
        status = axis2_handler_desc_set_name(handler_desc, env, handler_name);
        if (handler_name)
        {
            axutil_string_free(handler_name, env);
        }

        if (AXIS2_SUCCESS != status)
        {
            axis2_handler_desc_free(handler_desc, env);
            return NULL;
        }
    }

    /*Setting Handler Class name */
    class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
    class_attrib = axiom_element_get_attribute(handler_element, env,
        class_qname);
    if (class_qname)
    {
        axutil_qname_free(class_qname, env);
    }

    if (! class_attrib)
    {
        axis2_handler_desc_free(handler_desc, env);
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
            AXIS2_FAILURE);
        return NULL;
    }
    else
    {
        attrib_value = axiom_attribute_get_value(class_attrib, env);
        status = axis2_handler_desc_set_class_name(handler_desc, env, attrib_value);
    }

    /*processing phase Rules (order) */

    order_qname = axutil_qname_create(env, AXIS2_ORDER, NULL, NULL);
    order_element = axiom_element_get_first_child_with_qname(handler_element,
        env, order_qname, handler_node, &order_node);
    if (order_qname)
    {
        axutil_qname_free(order_qname, env);
    }

    if (! order_element || ! order_node)
    {
        axis2_handler_desc_free(handler_desc, env);
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
            AXIS2_FAILURE);
        return NULL;
    }
    else
    {
        axutil_hash_t *order_itr = NULL;
        axiom_children_qname_iterator_t *params = NULL;
        axutil_qname_t *param_qname = NULL;
        axutil_hash_index_t *index_i = NULL;

        order_itr = axiom_element_get_all_attributes(order_element, env);
        if (!order_itr)
        {
            axis2_handler_desc_free(handler_desc, env);
            return NULL;
        }

        index_i = axutil_hash_first(order_itr, env);

        while (index_i)
        {
            axiom_attribute_t *order_attrib = NULL;
            axutil_qname_t *qname = NULL;
            axis2_char_t *name = NULL;
            axis2_char_t *value = NULL;
            void *v = NULL;

            axutil_hash_this(index_i, NULL, NULL, &v);
            order_attrib = (axiom_attribute_t *) v;
            qname = axiom_attribute_get_qname(order_attrib, env);
            name = axutil_qname_get_localpart(qname, env);

            value = axiom_attribute_get_value(order_attrib, env);
            if (0 == axutil_strcmp(AXIS2_AFTER, name))
            {
                struct axis2_phase_rule *phase_rule = NULL;

                phase_rule = axis2_handler_desc_get_rules(handler_desc, env);
                status = axis2_phase_rule_set_after(phase_rule, env, value);
                if (AXIS2_SUCCESS != status)
                {
                    axis2_handler_desc_free(handler_desc, env);
                    return NULL;
                }
            }
            if (0 == axutil_strcmp(AXIS2_BEFORE, name))
            {
                struct axis2_phase_rule *phase_rule = NULL;
                phase_rule = axis2_handler_desc_get_rules(handler_desc, env);
                status = axis2_phase_rule_set_before(phase_rule, env, value);
                if (AXIS2_SUCCESS != status)
                {
                    axis2_handler_desc_free(handler_desc, env);
                    return NULL;
                }
            }
            if (0 == axutil_strcmp(AXIS2_PHASE, name))
            {
                struct axis2_phase_rule *phase_rule = NULL;
                phase_rule = axis2_handler_desc_get_rules(handler_desc, env);
                status = axis2_phase_rule_set_name(phase_rule, env, value);
                if (AXIS2_SUCCESS != status)
                {
                    axis2_handler_desc_free(handler_desc, env);
                    return NULL;
                }
            }
            if (0 == axutil_strcmp(AXIS2_PHASEFIRST, name))
            {
                axis2_char_t *bool_val = NULL;

                bool_val = axis2_desc_builder_get_value(desc_builder, env,
                    value);
                if (0 == axutil_strcmp(bool_val, "true"))
                {
                    struct axis2_phase_rule *phase_rule = NULL;
                    phase_rule = axis2_handler_desc_get_rules(handler_desc, env);
                    status = axis2_phase_rule_set_first(phase_rule, env,
                        AXIS2_TRUE);
                    if (AXIS2_SUCCESS != status)
                    {
                        axis2_handler_desc_free(handler_desc, env);
                        AXIS2_FREE(env->allocator, bool_val);
                        return NULL;
                    }
                }
                else if (0 == axutil_strcmp(bool_val, "false"))
                {
                    struct axis2_phase_rule *phase_rule = NULL;
                    phase_rule = axis2_handler_desc_get_rules(handler_desc, env);
                    status = axis2_phase_rule_set_first(phase_rule, env,
                        AXIS2_FALSE);
                    if (AXIS2_SUCCESS != status)
                    {
                        axis2_handler_desc_free(handler_desc, env);
                        AXIS2_FREE(env->allocator, bool_val);
                        return NULL;
                    }
                }
                AXIS2_FREE(env->allocator, bool_val);
            }
            index_i = axutil_hash_next(env, index_i);
        }

        param_qname = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
        params = axiom_element_get_children_with_qname(handler_element,
            env, param_qname, handler_node);
        axutil_qname_free(param_qname, env);
        status = axis2_desc_builder_process_params(desc_builder, env, params,
            axis2_handler_desc_get_param_container(handler_desc, env), parent);
        if (AXIS2_SUCCESS != status)
        {
            axis2_handler_desc_free(handler_desc, env);
            return NULL;
        }
    }

    status = axis2_handler_desc_set_parent(handler_desc, env, parent);
    if (AXIS2_SUCCESS != status)
    {
        axis2_handler_desc_free(handler_desc, env);
        return NULL;
    }

    return handler_desc;
}

static axis2_status_t
set_attrs_and_value(axutil_param_t *param,
    const axutil_env_t *env,
    axiom_element_t *param_element,
    axiom_node_t *param_node)
{
    axis2_status_t status = AXIS2_FAILURE;
    axutil_hash_t *attrs = NULL;
    axiom_child_element_iterator_t *childs = NULL;

    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, param_element, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, param_node, AXIS2_FAILURE);

    /* Setting attributes */
    attrs = axiom_element_extract_attributes(param_element, env, param_node);
    if (attrs)
    {
        axutil_hash_index_t *i = NULL;

        for (i = axutil_hash_first(attrs, env); i; i =
            axutil_hash_next(env, i))
        {
            void *v = NULL;
            axiom_attribute_t *value = NULL;
            axutil_generic_obj_t *obj = NULL;
            axutil_qname_t *attr_qname = NULL;
            axis2_char_t *attr_name = NULL;

            axutil_hash_this(i, NULL, NULL, &v);
            if (!v)
            {
                axutil_param_free(param, env);
                return AXIS2_FAILURE;
            }
            obj = axutil_generic_obj_create(env);
            if (!obj)
            {
                axutil_param_free(param, env);
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY,
                    AXIS2_FAILURE);
                return AXIS2_FAILURE;
            }
            value = (axiom_attribute_t *) v;
             axutil_generic_obj_set_value(obj, env, value);
            axutil_generic_obj_set_free_func(obj, env,
                axiom_attribute_free_void_arg);
            attr_qname = axiom_attribute_get_qname(value, env);
            attr_name = axutil_qname_to_string(attr_qname, env);
            axutil_hash_set(attrs, attr_name, AXIS2_HASH_KEY_STRING, obj);
        }
        axutil_param_set_attributes(param, env, attrs);
    }

    childs = axiom_element_get_child_elements(param_element, env, param_node);
    if (childs)
    {
        axutil_array_list_t *value_list = NULL;

        value_list = axutil_array_list_create(env, 0);
        axutil_param_set_value_list(param, env, value_list);

        while (AXIS2_TRUE == AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(childs, env))
        {
            axiom_node_t *node = NULL;
            axiom_element_t *element = NULL;
            axutil_param_t *param = NULL;
            axis2_char_t *pname = NULL;

            node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(childs, env);
            element = axiom_node_get_data_element(node, env);
            param = axutil_param_create(env, NULL, NULL);
            pname = axiom_element_get_localname(element, env);
            status = axutil_param_set_name(param, env, pname);
            if (AXIS2_SUCCESS != status)
            {
                axutil_param_free(param, env);
                return status;
            }
            axutil_param_set_param_type(param, env, AXIS2_DOM_PARAM);
            set_attrs_and_value(param, env, element, node);
            axutil_array_list_add(value_list, env, param);
        }
    }
    else
    {
        axis2_char_t *para_test_value = NULL;
        axis2_char_t *temp = NULL;

        temp = axiom_element_get_text(
            param_element, env, param_node);
        para_test_value = axutil_strdup(env, temp);
        status = axutil_param_set_value(param, env, para_test_value);
        if (AXIS2_SUCCESS != status)
        {
            axutil_param_free(param, env);
            AXIS2_FREE(env->allocator, para_test_value);
            return status;
        }
        axutil_param_set_param_type(param, env, AXIS2_TEXT_PARAM);
    }
    return AXIS2_SUCCESS;
}

/**
 * Populate the Axis2 Operation with details from the actionMapping,
 * outputActionMapping and faultActionMapping elements from the operation
 * element.
 *
 * @param operation
 * @param op_desc
 */
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_desc_builder_process_action_mappings(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axiom_node_t *op_node,
    axis2_op_t *op_desc)
{
    axiom_element_t *op_element = NULL;
    axutil_qname_t *qname = NULL;
    axiom_children_qname_iterator_t *action_mappings = NULL;
    axutil_array_list_t *mapping_list = axutil_array_list_create(env, 0);
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE);

    op_element = axiom_node_get_data_element(op_node, env);
    qname = axutil_qname_create(env, AXIS2_ACTION_MAPPING, NULL, NULL);
    if(op_element)
    {
        action_mappings = axiom_element_get_children_with_qname(op_element, env, 
            qname,op_node);
    }

    axutil_qname_free(qname, env);
    qname = NULL;
    if(!action_mappings)
    {
        if (mapping_list)
        {
            axutil_array_list_free(mapping_list, env);
            mapping_list = NULL;
        }
        return AXIS2_SUCCESS;
    }
    while (axiom_children_qname_iterator_has_next(action_mappings, env))
    {
        axiom_element_t *mapping_element = NULL;
        axiom_node_t *mapping_node = NULL;
        axis2_char_t *input_action_string = NULL;
        axis2_char_t *temp_str = NULL;

        /* This is to check whether some one has locked the parmter at the top
         * level
         */
        mapping_node = (axiom_node_t *)
            axiom_children_qname_iterator_next(action_mappings, env);
        mapping_element = axiom_node_get_data_element(mapping_node, env);
        temp_str = axiom_element_get_text(mapping_element, env, 
            mapping_node);
        input_action_string = axutil_strtrim(env, temp_str, NULL);
        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Input action mapping found %s", 
            input_action_string);
        if(0 != axutil_strcmp("", input_action_string))
        {
            axutil_array_list_add(mapping_list, env, input_action_string);
        }
        else
        {
            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Zero length " \
                "input_action_string found. Not added to the mapping list");
        }
    }
    axis2_op_set_wsamapping_list(op_desc, env, mapping_list); 
    return AXIS2_SUCCESS;
}


AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_desc_builder_process_params(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axiom_children_qname_iterator_t *params,
    axutil_param_container_t *param_container,
    axutil_param_container_t *parent)
{
    axis2_status_t status = AXIS2_FAILURE;

    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, params, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, param_container, AXIS2_FAILURE);

    while (AXIS2_FALSE != axiom_children_qname_iterator_has_next(params, env))
    {
        axiom_element_t *param_element = NULL;
        axiom_node_t *param_node = NULL;
        axutil_param_t *param = NULL;
        axutil_param_t *parent_para = NULL;
        axiom_attribute_t *para_name = NULL;
        axiom_attribute_t *para_locked = NULL;
        axutil_qname_t *att_locked = NULL;
        axutil_qname_t *att_qname = NULL;
        axis2_char_t *pname = NULL;

        /* This is to check whether some one has locked the parmter at the top
         * level
         */
        param_node = (axiom_node_t *)
            axiom_children_qname_iterator_next(params, env);
        param_element = axiom_node_get_data_element(param_node, env);
        param = axutil_param_create(env, NULL, NULL);

        /* Setting paramter name */
        att_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
        para_name = axiom_element_get_attribute(param_element, env,
            att_qname);
        axutil_qname_free(att_qname, env);
        if (!para_name)
        {
            axutil_param_free(param, env);
            return AXIS2_FAILURE;
        }
        pname = axiom_attribute_get_value(para_name, env);
        status = axutil_param_set_name(param, env, pname);
        if (AXIS2_SUCCESS != status)
        {
            axutil_param_free(param, env);
            return status;
        }

        /* Setting paramter Value (the chiled elemnt of the paramter) */
        set_attrs_and_value(param, env, param_element, param_node);

        /* Setting locking attrib */
        att_locked = axutil_qname_create(env, AXIS2_ATTLOCKED, NULL, NULL);
        para_locked = axiom_element_get_attribute(param_element, env,
            att_locked);
        axutil_qname_free(att_locked, env);
        if (parent)
        {
            axis2_char_t *param_name = NULL;

            param_name = axutil_param_get_name(param, env);
            parent_para = axutil_param_container_get_param(parent, env,
                param_name);
        }
        if (para_locked)
        {
            axis2_char_t *locked_value = NULL;
            locked_value = axiom_attribute_get_value(para_locked, env);
            if (0 == axutil_strcmp("true", locked_value))
            {
                axis2_char_t *param_name = NULL;
                axis2_bool_t is_param_locked = AXIS2_FALSE;
                /*if the parameter is locked at some level parameter value replace
                 * by that   
                 */
                param_name = axutil_param_get_name(param, env);
                is_param_locked = axutil_param_container_is_param_locked(parent,
                    env, param_name);
                if (parent && AXIS2_TRUE == is_param_locked)
                {
                    axutil_param_free(param, env);
                    AXIS2_ERROR_SET(env->error,
                        AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE);
                    return AXIS2_FAILURE;
                }
                else
                {
                    axutil_param_set_locked(param, env, AXIS2_TRUE);
                }
            }
            else
            {
                axutil_param_set_locked(param, env, AXIS2_FALSE);
            }
        }


        if (parent)
        {
            axis2_char_t *name = NULL;
            axis2_bool_t bvalue = AXIS2_FALSE;

            name = axutil_param_get_name(param, env);
            bvalue = axutil_param_container_is_param_locked(parent, env, name);
            if (parent_para || AXIS2_FALSE == bvalue)
            {
                status = axutil_param_container_add_param(param_container, env,
                    param);
                if (AXIS2_SUCCESS != status)
                {
                    axutil_param_free(param, env);
                    return status;
                }
            }
        }
        else
        {
            status = axutil_param_container_add_param(param_container, env,
                param);
            if (AXIS2_SUCCESS != status)
            {
                axutil_param_free(param, env);
                return status;
            }
        }
    }
    return AXIS2_SUCCESS;
}


AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_desc_builder_process_op_module_refs(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axiom_children_qname_iterator_t *module_refs,
    axis2_op_t *op)
{
    axiom_element_t *moduleref = NULL;
    axiom_attribute_t *module_ref_attrib = NULL;
    axutil_qname_t *qref = NULL;
    axis2_status_t status = AXIS2_FAILURE;

    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);

    while (module_refs && AXIS2_TRUE == axiom_children_qname_iterator_has_next(module_refs,
        env))
    {
        moduleref = (axiom_element_t *)
            axiom_children_qname_iterator_next(module_refs, env);
        qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL);
        module_ref_attrib = axiom_element_get_attribute(moduleref, env, qref);
        axutil_qname_free(qref, env);
        if (module_ref_attrib)
        {
            axis2_char_t *ref_name = NULL;
            axutil_qname_t *ref_qname = NULL;
            axis2_module_desc_t *module_desc = NULL;

            ref_name = axiom_attribute_get_value(module_ref_attrib, env);
            ref_qname = axutil_qname_create(env, ref_name, NULL, NULL);
            module_desc = axis2_dep_engine_get_module(desc_builder->engine, env,
                ref_qname);
            if (! module_desc)
            {
                axutil_qname_free(ref_qname, env);
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND,
                    AXIS2_FAILURE);
                return AXIS2_FAILURE;
            }
            else
            {
                status = axis2_op_add_module_qname(op, env, ref_qname);
                axutil_qname_free(ref_qname, env);
                if (AXIS2_SUCCESS != status)
                {
                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND,
                        AXIS2_FAILURE);
                    return AXIS2_FAILURE;
                }
            }
        }
    }
    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL
axis2_desc_builder_load_msg_recv(axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    struct axiom_element *recv_element)
{
    axiom_attribute_t *recv_name = NULL;
    axis2_char_t *class_name = NULL;
    axis2_msg_recv_t *msg_recv = NULL;
    axutil_qname_t *class_qname = NULL;
    axutil_param_t *impl_info_param = NULL;
    axutil_dll_desc_t *dll_desc = NULL;
    axis2_char_t *repos_name = NULL;
    axis2_char_t *dll_name = NULL;
    axis2_char_t *temp_path = NULL;
    axis2_char_t *temp_path2 = NULL;
    axis2_char_t *temp_path3 = NULL;
    axis2_conf_t *conf = NULL;
    axis2_char_t *msg_recv_dll_name = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, recv_element, NULL);

    class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
    recv_name = axiom_element_get_attribute(recv_element, env, class_qname);
    axutil_qname_free(class_qname, env);
    class_name = axiom_attribute_get_value(recv_name, env);

    conf = axis2_dep_engine_get_axis_conf(desc_builder->engine, env);
    if (!conf)
    {
        return NULL;
    }
    impl_info_param =  axis2_conf_get_param(conf, env, class_name);

    if (!impl_info_param)
    {
        dll_desc = axutil_dll_desc_create(env);
        msg_recv_dll_name =
             axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env,
                 class_name);
        repos_name = axis2_dep_engine_get_repos_path(desc_builder->engine, env);
        temp_path = axutil_stracat(env, repos_name, AXIS2_PATH_SEP_STR);
        temp_path2 = axutil_stracat(env, temp_path, AXIS2_LIB_FOLDER);
        temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR);
        dll_name = axutil_stracat(env, temp_path3, msg_recv_dll_name);
        AXIS2_FREE(env->allocator, temp_path);
        AXIS2_FREE(env->allocator, temp_path2);
        AXIS2_FREE(env->allocator, temp_path3);
         axutil_dll_desc_set_name(dll_desc, env, dll_name);
        AXIS2_FREE(env->allocator, dll_name);
         axutil_dll_desc_set_type(dll_desc, env, AXIS2_MSG_RECV_DLL);
        impl_info_param = axutil_param_create(env, class_name, NULL);
        axutil_param_set_value(impl_info_param, env, dll_desc);
        axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg);
        /* set the impl_info_param(which contain dll_desc as value) so that
         * loaded msg_recv loader lib can be re-used in future
         */
         axis2_conf_add_param(conf, env, impl_info_param);
    }

    axutil_class_loader_init(env);
    msg_recv = (axis2_msg_recv_t *) axutil_class_loader_create_dll(env,
        impl_info_param);
    return msg_recv;
}

AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL
axis2_desc_builder_load_default_msg_recv(const axutil_env_t *env)
{
    axis2_msg_recv_t *msg_recv = NULL;

    msg_recv = axis2_raw_xml_in_out_msg_recv_create(env);
    return msg_recv;
}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axis2_desc_builder_get_short_file_name(const axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axis2_char_t *file_name)
{
    const axis2_char_t *separator = NULL;
    axis2_char_t *value = NULL;
    axis2_char_t *file_name_l = NULL;
    axis2_char_t *short_name = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, file_name, NULL);

    file_name_l = axutil_strdup(env, file_name);
    if (!file_name_l)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
    separator = ".";

    value = axutil_strstr(file_name_l, separator);

    value[0] = AXIS2_EOLN;
    short_name = file_name_l;

    return short_name;
}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axis2_desc_builder_get_file_name_without_prefix(const axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axis2_char_t *short_file_name)
{
    axis2_char_t *file_name_l = NULL;
    axis2_char_t *short_name = NULL;
    int len = 0;
    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, short_file_name, NULL);
    file_name_l = axutil_strdup(env, short_file_name);
    if (!file_name_l)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
    len = axutil_strlen(AXIS2_LIB_PREFIX);
    short_name = &file_name_l[len];
    return short_name;

}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axis2_desc_builder_get_value(const axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env,
    axis2_char_t *in)
{
    const axis2_char_t *separator = ":";
    axis2_char_t *value = NULL;
    axis2_char_t *in_l = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, in, NULL);

    in_l = axutil_strdup(env, in);
    if (!in_l)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
    value = axutil_strstr(in_l, separator);
    value = value + 1;

    return value;
}

AXIS2_EXTERN struct axis2_dep_engine *AXIS2_CALL
axis2_desc_builder_get_dep_engine(const axis2_desc_builder_t *desc_builder,
    const axutil_env_t *env)
{
    return desc_builder->engine;
}