/*
 * 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 <axis2_soap_fault.h>
 #include <axis2_soap.h>
 #include <axis2_soap_body.h>
 #include <axis2_om_node.h>
 #include <axis2_om_element.h>
 #include <axis2_soap_fault_code.h>
 #include <axis2_soap_fault_detail.h>
 #include <axis2_soap_fault_value.h>
 #include <axis2_soap_fault_text.h>
 #include <axis2_soap_fault_reason.h>
 #include <axis2_soap_fault_role.h>
 #include <axis2_soap_fault_node.h>
 #include <axis2_soap_utils.h>
 #include <axis2_soap_builder.h>
 
/**************** impl struct ************************************************/

typedef struct axis2_soap_fault_impl_t
{
    axis2_soap_fault_t soap_fault;
    /* om element node corresponding to soap fault */
    axis2_om_node_t *om_ele_node;
    
    /* soap fault code sub element */
    axis2_soap_fault_code_t *fcode;
    /* soap fault reason sub element */
    axis2_soap_fault_reason_t *freason;
    /* soap fault node sub element */
    axis2_soap_fault_node_t *fnode;
    /* soap fault role sub element */
    axis2_soap_fault_role_t *frole;
    /* soap fault detail sub element */
    axis2_soap_fault_detail_t *fdetail;
    
    axis2_char_t *exception;
    /* soap version */
    int soap_version;
    /* reference to soap builder */
    axis2_soap_builder_t *soap_builder;
    
}axis2_soap_fault_impl_t;

/************************* Macro **********************************************/

#define AXIS2_INTF_TO_IMPL(fault) ((axis2_soap_fault_impl_t*)fault)

/************************ function prototype **********************************/


axis2_status_t AXIS2_CALL 
axis2_soap_fault_free(axis2_soap_fault_t *fault,
                      axis2_env_t **env);

axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_code(axis2_soap_fault_t *fault,
                          axis2_env_t **env,
                          axis2_soap_fault_code_t *code);
                                        
axis2_soap_fault_code_t * AXIS2_CALL 
axis2_soap_fault_get_code(axis2_soap_fault_t *fault,
                          axis2_env_t **env);
                                    
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_reason(axis2_soap_fault_t *fault,
                            axis2_env_t **env,
                            axis2_soap_fault_reason_t *reason);
                                        
axis2_soap_fault_reason_t* AXIS2_CALL 
axis2_soap_fault_get_reason(axis2_soap_fault_t *fault,
                            axis2_env_t **env);
                                        
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_node(axis2_soap_fault_t *fault,
                          axis2_env_t **env,
                          axis2_soap_fault_node_t *node);
                                        
axis2_soap_fault_node_t* AXIS2_CALL 
axis2_soap_fault_get_node(axis2_soap_fault_t *fault,
                          axis2_env_t **env);
                                        
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_role(axis2_soap_fault_t *fault,
                          axis2_env_t **env,
                          axis2_soap_fault_role_t *role);
                                        
axis2_soap_fault_role_t* AXIS2_CALL 
axis2_soap_fault_get_role(axis2_soap_fault_t *fault,
                          axis2_env_t **env);

axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_detail(axis2_soap_fault_t *fault,
                            axis2_env_t **env,
                            axis2_soap_fault_detail_t *detail);
                                
axis2_soap_fault_detail_t* AXIS2_CALL 
axis2_soap_fault_get_detail(axis2_soap_fault_t *fault,
                            axis2_env_t **env);   

axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_base_node(axis2_soap_fault_t *fault,
                               axis2_env_t **env,
                               axis2_om_node_t *node);
                                        
axis2_om_node_t* AXIS2_CALL 
axis2_soap_fault_get_base_node(axis2_soap_fault_t *fault,
                               axis2_env_t **env);  
                                                
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_soap_version(axis2_soap_fault_t *fault,
                                  axis2_env_t **env,
                                  int soap_version);
                                    
int AXIS2_CALL 
axis2_soap_fault_get_soap_version(axis2_soap_fault_t *fault,
                                  axis2_env_t **env);    
                                  
axis2_char_t * AXIS2_CALL 
axis2_soap_fault_get_exception(axis2_soap_fault_t *fault,
                               axis2_env_t **env);
                                        
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_exception(axis2_soap_fault_t *fault,
                               axis2_env_t **env,
                               axis2_char_t *exception);                                                                                                                                                                                                                                                                                         

axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_builder(axis2_soap_fault_t *fault,
                               axis2_env_t **env,
                              axis2_soap_builder_t *builder);
                              
/***************** function implementations ***********************************/

AXIS2_DECLARE(axis2_soap_fault_t *)
axis2_soap_fault_create(axis2_env_t **env)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    AXIS2_ENV_CHECK(env, NULL);
    fault_impl = (axis2_soap_fault_impl_t*)AXIS2_MALLOC(
                    (*env)->allocator,
                    sizeof(axis2_soap_fault_impl_t));
    if(!fault_impl)
    {
        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
    fault_impl->exception = NULL;
    fault_impl->fcode = NULL;
    fault_impl->fdetail = NULL;
    fault_impl->fnode = NULL;
    fault_impl->freason = NULL;
    fault_impl->frole = NULL;
    fault_impl->om_ele_node = NULL;
    fault_impl->soap_fault.ops = NULL;
    fault_impl->soap_version = AXIS2_SOAP_VERSION_NOT_SET;

    fault_impl->soap_fault.ops = (axis2_soap_fault_ops_t*)AXIS2_MALLOC(
                                 (*env)->allocator,
                                 sizeof(axis2_soap_fault_ops_t));

    if(!(fault_impl->soap_fault.ops))
    {
        AXIS2_FREE((*env)->allocator, fault_impl);
        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;    
    }

    fault_impl->soap_fault.ops->get_soap_version =
        axis2_soap_fault_get_soap_version;
    fault_impl->soap_fault.ops->set_soap_version =
        axis2_soap_fault_set_soap_version;
    fault_impl->soap_fault.ops->free_fn =
        axis2_soap_fault_free;
    fault_impl->soap_fault.ops->get_base_node =
        axis2_soap_fault_get_base_node;
    fault_impl->soap_fault.ops->set_base_node =
        axis2_soap_fault_set_base_node;
    fault_impl->soap_fault.ops->set_code =
        axis2_soap_fault_set_code;
    fault_impl->soap_fault.ops->get_code =
        axis2_soap_fault_get_code;
    fault_impl->soap_fault.ops->set_reason =
        axis2_soap_fault_set_reason;
    fault_impl->soap_fault.ops->get_reason =
        axis2_soap_fault_get_reason;        
    fault_impl->soap_fault.ops->set_role =
        axis2_soap_fault_set_role;
    fault_impl->soap_fault.ops->get_role =
        axis2_soap_fault_get_role;
    fault_impl->soap_fault.ops->get_node =
        axis2_soap_fault_get_node;
    fault_impl->soap_fault.ops->set_node =
        axis2_soap_fault_set_node;
    fault_impl->soap_fault.ops->get_detail =
        axis2_soap_fault_get_detail;
    fault_impl->soap_fault.ops->set_detail =
        axis2_soap_fault_set_detail; 
    fault_impl->soap_fault.ops->get_exception =
        axis2_soap_fault_get_exception;
    fault_impl->soap_fault.ops->set_exception =
        axis2_soap_fault_set_exception;
    fault_impl->soap_fault.ops->set_builder =
        axis2_soap_fault_set_builder;                            
                                                                                               
    return &(fault_impl->soap_fault);
}


AXIS2_DECLARE(axis2_soap_fault_t *)
axis2_soap_fault_create_with_parent(axis2_env_t **env,
                                    axis2_soap_body_t *body)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    axis2_soap_fault_t *fault = NULL;
    axis2_om_element_t *this_ele = NULL;
    axis2_om_node_t *this_node = NULL;
    axis2_om_node_t *parent_node = NULL;
    axis2_om_element_t *parent_ele = NULL;
    axis2_om_namespace_t *parent_ns = NULL;
    
    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK((*env)->error, body, NULL);
    
    fault = axis2_soap_fault_create(env);
    if(!fault)
        return NULL;
        
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    parent_node = AXIS2_SOAP_BODY_GET_BASE_NODE(body, env);
    parent_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
                        parent_node, env);
    parent_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(parent_ele, env);
    this_ele = axis2_om_element_create(env, 
                                       parent_node,                             
                                       AXIS2_SOAP_FAULT_LOCAL_NAME,
                                       parent_ns,
                                       &this_node);
    fault_impl->om_ele_node = this_node;
    AXIS2_SOAP_BODY_SET_FAULT(body, env, fault);    
    return  &(fault_impl->soap_fault);  
}


AXIS2_DECLARE(axis2_soap_fault_t *)
axis2_soap_fault_create_with_exception(axis2_env_t **env,
                                        axis2_soap_body_t *body,  
                                        axis2_char_t* exception)
{
    axis2_soap_fault_t *fault = NULL;
    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK((*env)->error, body, NULL);
    AXIS2_PARAM_CHECK((*env)->error, exception, NULL);
    fault = axis2_soap_fault_create_with_parent(env, body);
    if(!fault)
        return NULL;
    axis2_soap_fault_set_exception(fault, env, exception);
    return fault;
}


axis2_status_t AXIS2_CALL 
axis2_soap_fault_free(axis2_soap_fault_t *fault,
                      axis2_env_t **env)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    
    if(fault_impl->fcode)
    {
        AXIS2_SOAP_FAULT_CODE_FREE(fault_impl->fcode, env);
        fault_impl->fcode = NULL;
    }
    if(fault_impl->fdetail)
    {
        AXIS2_SOAP_FAULT_DETAIL_FREE(fault_impl->fdetail, env);
        fault_impl->fdetail = NULL;
    }
    if(fault_impl->fnode)
    {
        AXIS2_SOAP_FAULT_NODE_FREE(fault_impl->fnode, env);
        fault_impl->fnode = NULL;
    }    
    if(fault_impl->freason)
    {
        AXIS2_SOAP_FAULT_REASON_FREE(fault_impl->freason, env);
        fault_impl->freason = NULL;
    }
    if(fault_impl->frole)
    {
        AXIS2_SOAP_FAULT_ROLE_FREE(fault_impl->frole, env);
        fault_impl->frole = NULL;
    }
    if(fault->ops)
    {
        AXIS2_FREE((*env)->allocator, fault->ops);
        fault->ops = NULL;
    }
    AXIS2_FREE((*env)->allocator, fault_impl);
    fault_impl = NULL;
    return AXIS2_SUCCESS;
}

axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_code(axis2_soap_fault_t *fault,
                          axis2_env_t **env,
                          axis2_soap_fault_code_t *code)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, code, AXIS2_FAILURE);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    /* axis2_soap_fault_get_code(fault_code, env); 
    if(fault_impl->fcode)
    {
        my_node = AXIS2_SOAP_FAULT_CODE_GET_BASE_NODE(
                            fault_impl->fcode, env);
        AXIS2_SOAP_FAULT_CODE_FREE(fault_impl->fcode, env);
        fault_impl->fcode = NULL;
    }
    code_node = AXIS2_SOAP_FAULT_CODE_GET_BASE_NODE(
                            code, env);
    axis2_soap_utils_set_new_node(env, 
                    fault_impl->om_ele_node,
                    &my_node, 
                    code_node);
    */                    
    fault_impl->fcode = code;
    return AXIS2_SUCCESS;  
}
                                        
axis2_soap_fault_code_t * AXIS2_CALL 
axis2_soap_fault_get_code(axis2_soap_fault_t *fault,
                          axis2_env_t **env)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    int status = AXIS2_SUCCESS;
    AXIS2_ENV_CHECK(env, NULL);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    if(fault_impl->fcode)
    {
        return fault_impl->fcode;
    } 
    else if(fault_impl->soap_builder)
    {
        while(!(fault_impl->fcode) && !(AXIS2_OM_NODE_GET_BUILD_STATUS(fault_impl->om_ele_node, env)))
        {
            status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
            if(status == AXIS2_FAILURE)
                break;
        }            
    }
    /*
    axis2_om_node_t *code_node = NULL;
    axis2_om_node_t *this_node = NULL;
    axis2_soap_fault_code_t* code = NULL;
    this_node = fault_impl->om_ele_node;
    if(!(fault_impl->fcode))
    {
        code_node = axis2_soap_utils_get_child_with_name(env, 
                                            this_node, 
                                            AXIS2_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME);
        code = axis2_soap_fault_code_create(env);
        AXIS2_SOAP_FAULT_CODE_SET_BASE_NODE(code , env, code_node);
        fault_impl->fcode = code;
    }
    */
    return fault_impl->fcode; 
}
                                    
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_reason(axis2_soap_fault_t *fault,
                            axis2_env_t **env,
                            axis2_soap_fault_reason_t *reason)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, reason, AXIS2_FAILURE);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
   /*
    axis2_om_node_t *reason_node = NULL;
    axis2_om_node_t *my_node = NULL;
    axis2_soap_fault_get_reason(fault_reason, env); 
    if(fault_impl->freason)
    {
        my_node = AXIS2_SOAP_FAULT_REASON_GET_BASE_NODE(
                            fault_impl->freason, env);
        AXIS2_SOAP_FAULT_REASON_FREE(fault_impl->freason, env);
        fault_impl->freason = NULL;
    }
    reason_node = AXIS2_SOAP_FAULT_REASON_GET_BASE_NODE(
                            reason, env);
    axis2_soap_utils_set_new_node(env, 
                    fault_impl->om_ele_node,
                    &my_node, 
                    reason_node);
    */                    
    fault_impl->freason = reason;
    return AXIS2_SUCCESS;  
}
                                        
axis2_soap_fault_reason_t* AXIS2_CALL 
axis2_soap_fault_get_reason(axis2_soap_fault_t *fault,
                            axis2_env_t **env)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    int status = AXIS2_SUCCESS;
    AXIS2_ENV_CHECK(env, NULL);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    if(fault_impl->freason)
    {
        return fault_impl->freason;
    } 
    else if(fault_impl->soap_builder)
    {
        while(!(fault_impl->freason) && !(AXIS2_OM_NODE_GET_BUILD_STATUS(fault_impl->om_ele_node, env)))
        {
            status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
            if(status == AXIS2_FAILURE)
                break;
        }            
    }
    /*
    axis2_om_node_t *reason_node = NULL;
    axis2_om_node_t *this_node = NULL;
    axis2_soap_fault_reason_t* reason = NULL;
    this_node = fault_impl->om_ele_node;
    if(!(fault_impl->freason))
    {
        reason_node = axis2_soap_utils_get_child_with_name(env, 
                                            this_node, 
                                            AXIS2_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME);
        reason = axis2_soap_fault_reason_create(env);
        AXIS2_SOAP_FAULT_REASON_SET_BASE_NODE(reason , env, reason_node);
        fault_impl->freason = reason;
    }
    */
    return fault_impl->freason; 
}
                                        
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_node(axis2_soap_fault_t *fault,
                          axis2_env_t **env,
                          axis2_soap_fault_node_t *node)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, node, AXIS2_FAILURE);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
   /* 
    axis2_om_node_t *node_node = NULL;
    axis2_om_node_t *my_node = NULL;
    axis2_soap_fault_get_node(fault_node, env); 
    if(fault_impl->fnode)
    {
        my_node = AXIS2_SOAP_FAULT_NODE_GET_BASE_NODE(
                            fault_impl->fnode, env);
        AXIS2_SOAP_FAULT_NODE_FREE(fault_impl->fnode, env);
        fault_impl->fnode = NULL;
    }
    node_node = AXIS2_SOAP_FAULT_NODE_GET_BASE_NODE(
                            node, env);
    axis2_soap_utils_set_new_node(env, 
                    fault_impl->om_ele_node,
                    &my_node, 
                    node_node);
    */                    
    fault_impl->fnode = node;
    return AXIS2_SUCCESS;
}
                                        
axis2_soap_fault_node_t* AXIS2_CALL 
axis2_soap_fault_get_node(axis2_soap_fault_t *fault,
                          axis2_env_t **env)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    int status = AXIS2_SUCCESS;
    AXIS2_ENV_CHECK(env, NULL);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    
    if(fault_impl->fnode)
    {
        return fault_impl->fnode;
    } 
    else if(fault_impl->soap_builder)
    {
        while(!(fault_impl->fnode) && !(AXIS2_OM_NODE_GET_BUILD_STATUS(fault_impl->om_ele_node, env)))
        {
            status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
            if(status == AXIS2_FAILURE)
                break;
        }            
    }
    /*
    axis2_om_node_t *node_node = NULL;
    axis2_om_node_t *this_node = NULL;
    axis2_soap_fault_node_t* node = NULL;
    this_node = fault_impl->om_ele_node;
    if(!(fault_impl->fnode))
    {
        node_node = axis2_soap_utils_get_child_with_name(env, 
                                            this_node, 
                                            AXIS2_SOAP12_SOAP_FAULT_NODE_LOCAL_NAME);
        node = axis2_soap_fault_node_create(env);
        AXIS2_SOAP_FAULT_NODE_SET_BASE_NODE(node , env, node_node);
        fault_impl->fnode = node;
    }
    */
    return fault_impl->fnode; 
}
                                        
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_role(axis2_soap_fault_t *fault,
                          axis2_env_t **env,
                          axis2_soap_fault_role_t *role)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
   
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, role, AXIS2_FAILURE);
    
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
   /* 
    axis2_om_node_t *role_node = NULL;
    axis2_om_node_t *my_node = NULL;
    axis2_soap_fault_get_role(fault_role, env); 
    if(fault_impl->frole)
    {
        my_node = AXIS2_SOAP_FAULT_ROLE_GET_BASE_NODE(
                            fault_impl->frole, env);
        AXIS2_SOAP_FAULT_ROLE_FREE(fault_impl->frole, env);
        fault_impl->frole = NULL;
    }
    role_node = AXIS2_SOAP_FAULT_ROLE_GET_BASE_NODE(
                            role, env);
    axis2_soap_utils_set_new_node(env, 
                    fault_impl->om_ele_node,
                    &my_node, 
                    role_node);
    */                    
    fault_impl->frole = role;
    return AXIS2_SUCCESS;  

}
                                        
axis2_soap_fault_role_t* AXIS2_CALL 
axis2_soap_fault_get_role(axis2_soap_fault_t *fault,
                          axis2_env_t **env)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    int status = AXIS2_SUCCESS;
    AXIS2_ENV_CHECK(env, NULL);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    if(fault_impl->frole)
    {
        return fault_impl->frole;
    } 
    else if(fault_impl->soap_builder)
    {
        while(!(fault_impl->frole) && !(AXIS2_OM_NODE_GET_BUILD_STATUS(fault_impl->om_ele_node, env)))
        {
            status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
            if(status == AXIS2_FAILURE)
                break;
        }            
    }
    /*
    axis2_om_node_t *role_node = NULL;
    axis2_om_node_t *this_node = NULL;
    axis2_soap_fault_role_t* role = NULL;
    this_node = fault_impl->om_ele_node;
    if(!(fault_impl->frole))
    {
        role_node = axis2_soap_utils_get_child_with_name(env, 
                                            this_node, 
                                            AXIS2_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME);
                                                    
        role = axis2_soap_fault_role_create(env);
        AXIS2_SOAP_FAULT_ROLE_SET_BASE_NODE(role , env, role_node);
        fault_impl->frole = role;
    }
    */
    return fault_impl->frole; 
}

axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_detail(axis2_soap_fault_t *fault,
                            axis2_env_t **env,
                            axis2_soap_fault_detail_t *detail)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, detail, AXIS2_FAILURE);
    
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
   /* 
    axis2_om_node_t *detail_node = NULL;
    axis2_om_node_t *my_node = NULL;
    axis2_soap_fault_get_detail(fault_detail, env); 
    if(fault_impl->fdetail)
    {
        my_node = AXIS2_SOAP_FAULT_DETAIL_GET_BASE_NODE(
                            fault_impl->fdetail, env);
        AXIS2_SOAP_FAULT_DETAIL_FREE(fault_impl->fdetail, env);
        fault_impl->fdetail = NULL;
    }
    
    detail_node = AXIS2_SOAP_FAULT_DETAIL_GET_BASE_NODE(
                            detail, env);
    
    axis2_soap_utils_set_new_node(env, 
                    fault_impl->om_ele_node,
                    &my_node, 
                    detail_node);
    */                    
    fault_impl->fdetail = detail;
    return AXIS2_SUCCESS;  


}
                                
axis2_soap_fault_detail_t* AXIS2_CALL 
axis2_soap_fault_get_detail(axis2_soap_fault_t *fault,
                            axis2_env_t **env)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    int status = AXIS2_SUCCESS;
    AXIS2_ENV_CHECK(env, NULL);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    if(fault_impl->fdetail)
    {
        return fault_impl->fdetail;
    } 
    else if(fault_impl->soap_builder)
    {
        while(!(fault_impl->fdetail) && !(AXIS2_OM_NODE_GET_BUILD_STATUS(fault_impl->om_ele_node, env)))
        {
            status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
            if(status == AXIS2_FAILURE)
                break;
        }            
    }
    /*
    axis2_om_node_t *detail_node = NULL;
    axis2_om_node_t *this_node = NULL;
    axis2_soap_fault_detail_t* detail = NULL;
    this_node = fault_impl->om_ele_node;
    
    if(!(fault_impl->fdetail))
    {
        detail_node = axis2_soap_utils_get_child_with_name(env, 
                                            this_node, 
                                            AXIS2_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME);
                                                    
        detail = axis2_soap_fault_detail_create(env);
        AXIS2_SOAP_FAULT_DETAIL_SET_BASE_NODE(detail , env, detail_node);
        fault_impl->fdetail = detail;
    }
    */
    return fault_impl->fdetail; 
}   

axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_base_node(axis2_soap_fault_t *fault,
                               axis2_env_t **env,
                               axis2_om_node_t *node)
{
   axis2_soap_fault_impl_t *fault_impl = NULL;
   AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
   AXIS2_PARAM_CHECK((*env)->error, node, AXIS2_FAILURE);
   fault_impl = AXIS2_INTF_TO_IMPL(fault);

    if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
   {
        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
        return AXIS2_FAILURE;
   }
   fault_impl->om_ele_node = node;
   return AXIS2_SUCCESS;

}
                                        
axis2_om_node_t* AXIS2_CALL 
axis2_soap_fault_get_base_node(axis2_soap_fault_t *fault,
                               axis2_env_t **env)
{
    AXIS2_ENV_CHECK(env, NULL);
    return AXIS2_INTF_TO_IMPL(fault)->om_ele_node;
}  
                                                
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_soap_version(axis2_soap_fault_t *fault,
                                  axis2_env_t **env,
                                  int soap_version)
{
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, soap_version, AXIS2_FAILURE);
    AXIS2_INTF_TO_IMPL(fault)->soap_version = soap_version;
    return AXIS2_SUCCESS;

}
                                    
int AXIS2_CALL 
axis2_soap_fault_get_soap_version(axis2_soap_fault_t *fault,
                                  axis2_env_t **env)
{
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    return AXIS2_INTF_TO_IMPL(fault)->soap_version;
}
                                  
axis2_char_t * AXIS2_CALL 
axis2_soap_fault_get_exception(axis2_soap_fault_t *fault,
                               axis2_env_t **env)
{
    axis2_soap_fault_detail_t *detail = NULL;
    axis2_om_node_t *detail_node = NULL;
    axis2_om_element_t *detail_ele = NULL;
    axis2_om_node_t *exception_node = NULL;
    axis2_om_element_t *exception_ele = NULL;
    axis2_qname_t *qn = NULL;
    axis2_char_t *excep = NULL;
    
    AXIS2_ENV_CHECK(env, NULL);
    detail = axis2_soap_fault_get_detail(fault, env);
    if(!detail)
        return NULL;
    detail_node = AXIS2_SOAP_FAULT_DETAIL_GET_BASE_NODE(detail, env);
    detail_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
                    detail_node, env);
    qn = axis2_qname_create(env,
             AXIS2_SOAP_FAULT_DETAIL_EXCEPTION_ENTRY, NULL, NULL);
    
    exception_ele = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                        detail_ele, env,
                        qn, detail_node, &exception_node);
    AXIS2_QNAME_FREE(qn, env);                        
    if(exception_ele && 
           (excep = AXIS2_OM_ELEMENT_GET_TEXT(exception_ele, env, exception_node)))
    {
        return excep;
    }
        return NULL;
}
                                        
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_exception(axis2_soap_fault_t *fault,
                               axis2_env_t **env,
                               axis2_char_t *exception)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    axis2_soap_fault_detail_t *detail = NULL;
    axis2_om_node_t *fault_detail_entry_node = NULL;
    axis2_om_element_t *fault_detail_ele = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, exception, AXIS2_FAILURE);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    detail = axis2_soap_fault_get_detail(fault, env);
    if(!detail)
    {
        if(fault_impl->soap_version == AXIS2_SOAP11)
            detail = axis2_soap11_fault_detail_create(env, fault);
        if(fault_impl->soap_version == AXIS2_SOAP12)
            detail = axis2_soap12_fault_detail_create(env, fault);
    }
    axis2_soap_fault_set_detail(fault, env, detail);

    fault_detail_ele = axis2_om_element_create(env, NULL, 
                            AXIS2_SOAP_FAULT_DETAIL_EXCEPTION_ENTRY,
                            NULL, &fault_detail_entry_node);

    AXIS2_OM_ELEMENT_SET_TEXT(fault_detail_ele,
         env, exception, fault_detail_entry_node);

    AXIS2_SOAP_FAULT_DETAIL_ADD_DETAIL_ENTRY(detail, env, fault_detail_entry_node);             
    return AXIS2_SUCCESS;
}                                                                                                                                                                                                                                                                                        
                                  
axis2_status_t AXIS2_CALL 
axis2_soap_fault_set_builder(axis2_soap_fault_t *fault,
                               axis2_env_t **env,
                              axis2_soap_builder_t *builder)
{
    axis2_soap_fault_impl_t *fault_impl = NULL;
    AXIS2_PARAM_CHECK((*env)->error, builder, AXIS2_FAILURE);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
    fault_impl->soap_builder = builder;
    return AXIS2_SUCCESS;
}

AXIS2_DECLARE(axis2_soap_fault_t *)
axis2_soap_fault_create_default_fault(axis2_env_t **env,
                                      struct axis2_soap_body *parent,
                                      axis2_char_t *code_value,
                                      axis2_char_t *reason_text,
                                      int soap_version)
{
    axis2_soap_fault_t *soap_fault = NULL;
    
    axis2_soap_fault_code_t *soap_fault_code = NULL;
    axis2_soap_fault_value_t *soap_fault_value = NULL;
    axis2_soap_fault_reason_t *soap_fault_reason = NULL;
    axis2_soap_fault_text_t *soap_fault_text = NULL;
    axis2_om_node_t *value_node  = NULL;
    axis2_om_element_t *value_ele = NULL;
    
    axis2_om_node_t *text_node = NULL;
    axis2_om_element_t *text_ele = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, code_value, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK((*env)->error, reason_text, AXIS2_FAILURE);

    soap_fault = axis2_soap_fault_create_with_parent(env, parent);
    if(soap_fault)
    {
        AXIS2_SOAP_FAULT_SET_SOAP_VERSION(soap_fault, env, soap_version);
        if(soap_version == AXIS2_SOAP11)
        {
            soap_fault_code = axis2_soap11_fault_code_create_with_parent(env, soap_fault);
            soap_fault_reason = axis2_soap11_fault_reason_create_with_parent(env, soap_fault);
        }
        else if(soap_version == AXIS2_SOAP12)
        {
            soap_fault_code = axis2_soap12_fault_code_create_with_parent(env, soap_fault);
            soap_fault_reason = axis2_soap12_fault_reason_create_with_parent(env, soap_fault);    
        }
        
        soap_fault_value = axis2_soap_fault_value_create_with_code( env,soap_fault_code);
        value_node = AXIS2_SOAP_FAULT_VALUE_GET_BASE_NODE(soap_fault_value, env);
        value_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(value_node, env);
        AXIS2_OM_ELEMENT_SET_TEXT(value_ele, env, code_value, value_node);
    
        soap_fault_text = axis2_soap_fault_text_create_with_parent( env, soap_fault_reason);
        text_node = AXIS2_SOAP_FAULT_TEXT_GET_BASE_NODE(soap_fault_text, env);
        text_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(text_node, env);
        AXIS2_OM_ELEMENT_SET_TEXT(text_ele, env, reason_text, text_node);
    }
    return soap_fault;
}