/*
 * 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 "axiom_node_internal.h"
#include "axiom_element_internal.h"
#include "axiom_stax_builder_internal.h"
#include <axiom_text.h>
#include <axiom_data_source.h>
#include <axiom_comment.h>
#include <axiom_processing_instruction.h>
#include <axiom_doctype.h>
#include <axiom_document.h>
#include <axiom_stax_builder.h>

struct axiom_node
{
    /* stax builder */
    axiom_stax_builder_t *builder;

    /* whether current node is the owner of stax builder. If so, it has to free it */
    axis2_bool_t own_builder;

    /** parent node */
    axiom_node_t *parent;

    /** previous sibling */
    axiom_node_t *prev_sibling;

    /** next sibling */
    axiom_node_t *next_sibling;

    /** first child */
    axiom_node_t *first_child;

    /** last child */
    axiom_node_t *last_child;

    /** node type, indicates the type stored in data_element */
    axiom_types_t node_type;

    /** done true means that this node is completely built , false otherwise */
    int done;

    /** instances of an om struct, whose type is defined by node type */
    void *data_element;

};

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_create(
    const axutil_env_t * env)
{
    axiom_node_t *node = NULL;
    AXIS2_ENV_CHECK(env, NULL);

    node = (axiom_node_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_node_t));
    if(!node)
    {
        env->error->error_number = AXIS2_ERROR_NO_MEMORY;
        return NULL;
    }
    node->first_child = NULL;
    node->last_child = NULL;
    node->next_sibling = NULL;
    node->prev_sibling = NULL;
    node->parent = NULL;
    node->node_type = AXIOM_INVALID;
    node->done = AXIS2_FALSE;
    node->data_element = NULL;
    node->builder = NULL;
    node->own_builder = AXIS2_FALSE;
    return node;
}

AXIS2_EXTERN axiom_node_t* AXIS2_CALL
axiom_node_create_from_buffer(
    const axutil_env_t * env,
    axis2_char_t *buffer)
{
    axiom_xml_reader_t *reader = NULL;
    axiom_stax_builder_t *builder = NULL;
    axiom_document_t *document = NULL;
    axiom_node_t *om_node = NULL;

    reader = axiom_xml_reader_create_for_memory(env, buffer, axutil_strlen(buffer), "UTF-8",
        AXIS2_XML_PARSER_TYPE_BUFFER);

    if(!reader)
    {
        return NULL;
    }

    builder = axiom_stax_builder_create(env, reader);

    if(!builder)
    {
        return NULL;
    }
    document = axiom_stax_builder_get_document(builder, env);
    if(!document)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Document is null for deserialization");
        return NULL;
    }

    om_node = axiom_document_get_root_element(document, env);

    if(!om_node)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Root element of the document is not found");
        return NULL;
    }
    axiom_document_build_all(document, env);

    axiom_stax_builder_free_self(builder, env);

    return om_node;
}

static void
axiom_node_free_detached_subtree(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    /* Free any child nodes first */
    if(om_node->first_child)
    {
        axiom_node_t *child_node = om_node->first_child, *next_sibling;
        while(child_node)
        {
            next_sibling = child_node->next_sibling;
            axiom_node_free_detached_subtree(child_node, env);
            child_node = next_sibling;
        }
    }

    if(om_node->node_type == AXIOM_ELEMENT)
    {
        if(om_node->data_element)
        {
            axiom_element_free((axiom_element_t *)(om_node->data_element), env);
        }
    }
    else if(om_node->node_type == AXIOM_COMMENT)
    {
        if(om_node->data_element)
        {
            axiom_comment_free((axiom_comment_t *)(om_node->data_element), env);
        }
    }
    else if(om_node->node_type == AXIOM_DOCTYPE)
    {
        /*axiom_doctype_free((axiom_doctype_t*)(om_node->data_element), env); */
    }
    else if(om_node->node_type == AXIOM_PROCESSING_INSTRUCTION)
    {
        if(om_node->data_element)
        {
            axiom_processing_instruction_free(
                (axiom_processing_instruction_t *)(om_node->data_element), env);
        }
    }
    else if(om_node->node_type == AXIOM_TEXT)
    {
        if(om_node->data_element)
        {
            axiom_text_free((axiom_text_t *)(om_node->data_element), env);
        }
    }
    else if(om_node->node_type == AXIOM_DATA_SOURCE)
    {
        if(om_node->data_element)
        {
            axiom_data_source_free((axiom_data_source_t *)(om_node->data_element), env);
        }
    }

	/* if the owner of the builder, then free the builder */
    if(om_node->own_builder)
    {
        axiom_stax_builder_free_internal(om_node->builder, env);
    }

    AXIS2_FREE(env->allocator, om_node);
}

/**
 *  This free function will free an om_element and all the children contained in it
 *  If the node is still attached to the tree, it will be detached first
 */
AXIS2_EXTERN void AXIS2_CALL
axiom_node_free_tree(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    AXIS2_ENV_CHECK(env, void);
    if(!om_node)
    {
        return;
    }

    /* Detach this node before freeing it and its subtree. */
    axiom_node_detach_without_namespaces(om_node, env);

    /* Free this node and its subtree */
    axiom_node_free_detached_subtree(om_node, env);
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_node_add_child(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_node_t * child)
{
    AXIS2_PARAM_CHECK(env->error, child, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, om_node, AXIS2_FAILURE);

    if(child->parent)
    {
        child = axiom_node_detach(child, env);
    }

    if(!om_node->first_child)
    {
        om_node->first_child = child;
    }
    else
    {
        axiom_node_t *last_sib = om_node->last_child;
        last_sib->next_sibling = child;
        child->prev_sibling = last_sib;
    }

    child->parent = om_node;
    om_node->last_child = child;
    return AXIS2_SUCCESS;
}

/**
 * Detaches given node from the parent and reset the links. will not adjust the namespace as
 * in the case of axiom_node_detach.
 * @param om_node node to be detached, cannot be NULL.
 * @param env Environment. MUST NOT be NULL, .
 * @return a pointer to detached node,returns NULL on error
 */
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_detach_without_namespaces(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    axiom_node_t *parent = NULL;

    parent = om_node->parent;
    if(!parent)
    {
        /* Node is already detached */
        return om_node;
    }

    if(!om_node->prev_sibling)
    {
        parent->first_child = om_node->next_sibling;
    }
    else
    {
        axiom_node_t *prev_sib = NULL;
        prev_sib = om_node->prev_sibling;
        if(prev_sib)
        {
            prev_sib->next_sibling = om_node->next_sibling;
        }
    }

    if(om_node->next_sibling)
    {
        axiom_node_t *next_sibling = NULL;
        next_sibling = om_node->next_sibling;
        if(next_sibling)
        {
            next_sibling->prev_sibling = om_node->prev_sibling;
        }
    }

    if(parent->last_child && (parent->last_child == om_node))
    {
        parent->last_child = om_node->prev_sibling;
    }

    /* if the STAX builder's last node is what we are detaching, then we should adjust the
     * last node if previous sibling is available, set that as the builder's last node. Else set the
     * parent as the last node*/
    if(om_node->builder && (axiom_stax_builder_get_lastnode(om_node->builder, env) == om_node))
    {
        axiom_node_t *lastnode = parent;
        if(om_node->prev_sibling)
        {
            lastnode = om_node->prev_sibling;
        }
        axiom_stax_builder_set_lastnode(om_node->builder, env, lastnode);
    }

    /* If the node is the owner of the builder, keep a reference to the builder
     * the builder will be freed when this node is destroyed*/
    if(!om_node->own_builder)
        om_node->builder = NULL;

    om_node->parent = NULL;
    om_node->prev_sibling = NULL;
    om_node->next_sibling = NULL;
    return om_node;
}

/**
 * Detaches given node from the parent and reset the links. Will recreate "namespace defined in
 * the parent and used in detached node" within detached node itself
 * @param om_node node to be detached, cannot be NULL.
 * @param env Environment. MUST NOT be NULL, .
 * @return a pointer to detached node,returns NULL on error
 */
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_detach(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    axutil_hash_t *namespaces = NULL;
    axiom_element_t *om_element = NULL;

    if(!om_node)
    {
        return NULL;
    }

    /* If this is an element node, determine which namespaces are available to it
     from its parent nodes. */
    if((om_node->node_type == AXIOM_ELEMENT) && (om_element = om_node->data_element))
    {
        namespaces = axiom_element_gather_parent_namespaces(om_element, env, om_node);
    }

    /* Detach this node from its parent. */
    om_node = axiom_node_detach_without_namespaces(om_node, env);

    /* If this is an element node, ensure that any namespaces available to it or its
     children remain available after the detach. */
    if(om_node && namespaces)
    {
        axiom_element_redeclare_parent_namespaces(om_element, env, om_node, namespaces);
    }

    if(namespaces)
    {
        axutil_hash_free(namespaces, env);
    }

    return om_node;
}

/**
 Internal function , only used in om and soap
 not to be used by users
 */
axis2_status_t AXIS2_CALL
axiom_node_set_parent(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_node_t * parent)
{

    if(parent == om_node->parent)
    { /* same parent already exist */
        return AXIS2_SUCCESS;
    }

    /* if a new parent is assigned in  place of existing one first the node should  be detached
     */
    if(om_node->parent)
    {
        om_node = axiom_node_detach(om_node, env);
    }

    om_node->parent = parent;

    return AXIS2_SUCCESS;
}

/**
 * This will insert a sibling just after the current information item
 * @param node the node in consideration
 * @param nodeto_insert the node that will be inserted
 */

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_node_insert_sibling_after(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_node_t * node_to_insert)
{
    axiom_node_t *next_sib = NULL;

    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

    AXIS2_PARAM_CHECK(env->error, node_to_insert, AXIS2_FAILURE);

    if(!om_node->parent)
    {
        /* We shouldn't add a sibling because this node doesn't has a parent. 
         * This can be the root node of the tree*/
        return AXIS2_FAILURE;
    }

    node_to_insert->parent = om_node->parent;

    node_to_insert->prev_sibling = om_node;

    next_sib = om_node->next_sibling;

    if(next_sib)
    {
        next_sib->prev_sibling = node_to_insert;
    }

    node_to_insert->next_sibling = om_node->next_sibling;

    om_node->next_sibling = node_to_insert;
    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_node_insert_sibling_before(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_node_t * node_to_insert)
{
    axiom_node_t *prev_sibling = NULL;

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

    if(!om_node->parent)
    {
        /* We shouldn't add a sibling because this node doesn't has a parent. 
         * This can be the root node of the tree*/
        return AXIS2_FAILURE;
    }

    node_to_insert->parent = om_node->parent;

    node_to_insert->prev_sibling = om_node->prev_sibling;

    node_to_insert->next_sibling = om_node;

    prev_sibling = om_node->prev_sibling;

    if(!prev_sibling)
    {
        axiom_node_t *parent = om_node->parent;
        parent->first_child = node_to_insert;
    }
    else
    {
        axiom_node_t *prev_sibling = om_node->prev_sibling;
        if(prev_sibling)
        {
            prev_sibling->next_sibling = node_to_insert;
        }
    }
    om_node->prev_sibling = node_to_insert;
    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_node_serialize(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_output_t * om_output)
{

    int status = AXIS2_SUCCESS;
    axiom_node_t *temp_node = NULL;
    axiom_node_t *nodes[256];
    int count = 0;

    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

    if(!om_node)
    {
        return AXIS2_SUCCESS;
    }

    nodes[count++] = om_node;

    AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);

    do
    {

        if(om_node->node_type == AXIOM_ELEMENT)
        {
            if(om_node->data_element)
            {
                status = axiom_element_serialize_start_part(
                    (axiom_element_t *)(om_node-> data_element), env, om_output, om_node);
            }
            if(status != AXIS2_SUCCESS)
            {
                return status;
            }
        }
        else if(om_node->node_type == AXIOM_DATA_SOURCE)
        {
            if(om_node->data_element)
            {
                status = axiom_data_source_serialize(
                    (axiom_data_source_t *)(om_node->data_element), env, om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                return status;
            }
        }
        else if(om_node->node_type == AXIOM_TEXT)
        {
            if(om_node->data_element)
            {
                status = axiom_text_serialize((axiom_text_t *)(om_node-> data_element), env,
                    om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                return status;
            }
        }
        else if(om_node->node_type == AXIOM_COMMENT)
        {
            if(om_node->data_element)
            {
                status = axiom_comment_serialize((axiom_comment_t *)(om_node-> data_element), env,
                    om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                return status;
            }
        }
        else if(om_node->node_type == AXIOM_DOCTYPE)
        {
            if(om_node->data_element)
            {
                status = axiom_doctype_serialize((axiom_doctype_t *)(om_node-> data_element), env,
                    om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                return status;
            }
        }
        else if(om_node->node_type == AXIOM_PROCESSING_INSTRUCTION)
        {
            if(om_node->data_element)
            {
                status = axiom_processing_instruction_serialize(
                    (axiom_processing_instruction_t *)(om_node->data_element), env, om_output);
            }

            if(status != AXIS2_SUCCESS)
            {
                return status;
            }
        }

        temp_node = axiom_node_get_first_child(om_node, env);
        /* serialize children of this node */
        if(temp_node)
        {
            om_node = temp_node;
            nodes[count++] = om_node;
        }
        else
        {
            if(om_node->node_type == AXIOM_ELEMENT)
            {
                if(om_node->data_element)
                {
                    status = axiom_element_serialize_end_part(
                        (axiom_element_t *)(om_node-> data_element), env, om_output);
                }
                if(status != AXIS2_SUCCESS)
                {
                    return status;
                }
            }

            temp_node = axiom_node_get_next_sibling(om_node, env);
            if(temp_node)
            {
                om_node = temp_node;
                nodes[count - 1] = om_node;
            }
            else
            {
                while(count > 1 && !temp_node)
                {
                    count--;
                    om_node = nodes[count - 1];
                    if(om_node->node_type == AXIOM_ELEMENT)
                    {
                        if(om_node->data_element)
                        {
                            status = axiom_element_serialize_end_part(
                                (axiom_element_t *)(om_node->data_element), env, om_output);
                        }
                        if(status != AXIS2_SUCCESS)
                        {
                            return status;
                        }
                    }

                    temp_node = axiom_node_get_next_sibling(om_node, env);
                }

                if(temp_node && count > 1)
                {
                    om_node = temp_node;
                    nodes[count - 1] = om_node;
                }
                else
                {
                    count--;
                }
            }

        }
    }
    while(count > 0);

    return status;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_node_serialize_sub_tree(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_output_t * om_output)
{

    int status = AXIS2_SUCCESS;
    axiom_node_t *temp_node = NULL;
    axiom_node_t *nodes[256];
    int count = 0;
    axutil_hash_t *namespaces = NULL;
    axutil_hash_t *namespaces_from_parents = NULL;

    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

    if(!om_node)
    {
        return AXIS2_SUCCESS;
    }

    namespaces = axutil_hash_make(env);
    if(!namespaces)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "hash for namespaces creation failed");
        return AXIS2_FAILURE;
    }

    namespaces_from_parents = axutil_hash_make(env);
    if(!namespaces_from_parents)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "hash for namespaces_from_parents creation failed");
        return AXIS2_FAILURE;
    }

    nodes[count++] = om_node;

    AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);

    do
    {

        if(om_node->node_type == AXIOM_ELEMENT)
        {
            if(om_node->data_element)
            {
                axutil_hash_t *temp_namespaces = NULL;
                axutil_hash_t *temp_attributes = NULL;
                axiom_namespace_t *namespace = NULL;
                status = axiom_element_serialize_start_part(
                    (axiom_element_t *)(om_node-> data_element), env, om_output, om_node);
                temp_namespaces = axiom_element_get_namespaces(
                    (axiom_element_t *)(om_node-> data_element), env);
                if(temp_namespaces)
                {
                    axutil_hash_t *new_hash = NULL;
                    new_hash = axutil_hash_overlay(temp_namespaces, env, namespaces);
                    if(namespaces)
                        axutil_hash_free(namespaces, env);
                    namespaces = new_hash;
                }
                namespace = axiom_element_get_namespace(
                    (axiom_element_t *)(om_node-> data_element), env, om_node);
                if(namespace)
                {
                    axiom_namespace_t *ns = NULL;
                    axis2_char_t *prefix = NULL;
                    prefix = axiom_namespace_get_prefix(namespace, env);
                    if(prefix)
                    {
                        ns = axutil_hash_get(namespaces, prefix, AXIS2_HASH_KEY_STRING);
                        if(!ns)
                        {
                            ns = axutil_hash_get(namespaces_from_parents, prefix,
                                AXIS2_HASH_KEY_STRING);
                            if(!ns)
                            {
                                axiom_namespace_serialize(namespace, env, om_output);
                                axutil_hash_set(namespaces_from_parents, prefix,
                                    AXIS2_HASH_KEY_STRING, namespace);
                            }
                        }
                    }
                }

                temp_attributes = axiom_element_get_all_attributes(
                    (axiom_element_t *)(om_node->data_element), env);
                if(temp_attributes)
                {
                    axutil_hash_index_t *hi;
                    void *val;
                    for(hi = axutil_hash_first(temp_attributes, env); hi; hi = axutil_hash_next(
                        env, hi))
                    {
                        axutil_hash_this(hi, NULL, NULL, &val);

                        if(val)
                        {
                            axiom_namespace_t *ns = NULL;
                            axis2_char_t *prefix = NULL;

                            namespace
                                = axiom_attribute_get_namespace((axiom_attribute_t *)val, env);

                            if(namespace)
                            {
                                prefix = axiom_namespace_get_prefix(namespace, env);
                                if(prefix)
                                {
                                    ns = axutil_hash_get(namespaces, prefix, AXIS2_HASH_KEY_STRING);
                                    if(!ns)
                                    {
                                        ns = axutil_hash_get(namespaces_from_parents, prefix,
                                            AXIS2_HASH_KEY_STRING);
                                        if(!ns)
                                        {
                                            axiom_namespace_serialize(namespace, env, om_output);
                                            axutil_hash_set(namespaces_from_parents, prefix,
                                                AXIS2_HASH_KEY_STRING, namespace);
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            status = AXIS2_FAILURE;
                        }
                    }
                }
            }
            if(status != AXIS2_SUCCESS)
            {
                break;
            }
        }
        else if(om_node->node_type == AXIOM_DATA_SOURCE)
        {
            if(om_node->data_element)
            {
                status = axiom_data_source_serialize(
                    (axiom_data_source_t *)(om_node->data_element), env, om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                break;
            }
        }
        else if(om_node->node_type == AXIOM_TEXT)
        {
            if(om_node->data_element)
            {
                status = axiom_text_serialize((axiom_text_t *)(om_node-> data_element), env,
                    om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                break;
            }
        }
        else if(om_node->node_type == AXIOM_COMMENT)
        {
            if(om_node->data_element)
            {
                status = axiom_comment_serialize((axiom_comment_t *)(om_node-> data_element), env,
                    om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                break;
            }
        }
        else if(om_node->node_type == AXIOM_DOCTYPE)
        {
            if(om_node->data_element)
            {
                status = axiom_doctype_serialize((axiom_doctype_t *)(om_node-> data_element), env,
                    om_output);
            }
            if(status != AXIS2_SUCCESS)
            {
                break;
            }
        }
        else if(om_node->node_type == AXIOM_PROCESSING_INSTRUCTION)
        {
            if(om_node->data_element)
            {
                status = axiom_processing_instruction_serialize(
                    (axiom_processing_instruction_t *)(om_node->data_element), env, om_output);
            }

            if(status != AXIS2_SUCCESS)
            {
                break;
            }
        }

        temp_node = axiom_node_get_first_child(om_node, env);
        /* serialize children of this node */
        if(temp_node)
        {
            om_node = temp_node;
            nodes[count++] = om_node;
        }
        else
        {
            if(om_node->node_type == AXIOM_ELEMENT)
            {
                if(om_node->data_element)
                {

                    axutil_hash_t *temp_attributes = NULL;
                    axiom_namespace_t *namespace = NULL;
                    /* at the writing of end part all the namespaces declared
                     specially to that element should be cancelled */

                    /* first checking the element namespace */
                    namespace = axiom_element_get_namespace(
                        (axiom_element_t *)(om_node-> data_element), env, om_node);
                    if(namespace)
                    {
                        axiom_namespace_t *ns = NULL;
                        axis2_char_t *prefix = NULL;
                        prefix = axiom_namespace_get_prefix(namespace, env);
                        if(prefix)
                        {
                            ns = axutil_hash_get(namespaces_from_parents, prefix,
                                AXIS2_HASH_KEY_STRING);
                            if(ns)
                            {
                                axutil_hash_set(namespaces_from_parents, prefix,
                                    AXIS2_HASH_KEY_STRING, NULL);
                            }
                        }
                    }

                    /* then checking the attribute namespaces */

                    temp_attributes = axiom_element_get_all_attributes(
                        (axiom_element_t *)(om_node->data_element), env);
                    if(temp_attributes)
                    {
                        axutil_hash_index_t *hi;
                        void *val;
                        for(hi = axutil_hash_first(temp_attributes, env); hi; hi
                            = axutil_hash_next(env, hi))
                        {
                            axutil_hash_this(hi, NULL, NULL, &val);

                            if(val)
                            {
                                axiom_namespace_t *ns = NULL;
                                axis2_char_t *prefix = NULL;

                                namespace = axiom_attribute_get_namespace((axiom_attribute_t *)val,
                                    env);

                                if(namespace)
                                {
                                    prefix = axiom_namespace_get_prefix(namespace, env);
                                    if(prefix)
                                    {
                                        ns = axutil_hash_get(namespaces_from_parents, prefix,
                                            AXIS2_HASH_KEY_STRING);
                                        if(ns)
                                        {
                                            axutil_hash_set(namespaces_from_parents, prefix,
                                                AXIS2_HASH_KEY_STRING, NULL);
                                        }
                                    }
                                }
                            }
                        }
                    }

                    status = axiom_element_serialize_end_part(
                        (axiom_element_t *)(om_node-> data_element), env, om_output);
                }
                if(status != AXIS2_SUCCESS)
                {
                    break;
                }
            }
            /* We need to make make sure that om_node is not the root when we take the next sibling */
            if(count > 1)
            {
                temp_node = axiom_node_get_next_sibling(om_node, env);
            }
            if(temp_node)
            {
                om_node = temp_node;
                nodes[count - 1] = om_node;
            }
            else
            {
                while(count > 1 && !temp_node)
                {
                    count--;
                    om_node = nodes[count - 1];
                    if(om_node->node_type == AXIOM_ELEMENT)
                    {
                        if(om_node->data_element)
                        {
                            axutil_hash_t *temp_attributes = NULL;
                            axiom_namespace_t *namespace = NULL;

                            /* similar to the earlier time, whenever the ending is happened
                             * namespaces declared specially to that element should be cancelled */

                            /* first checking the element namespace */
                            namespace = axiom_element_get_namespace(
                                (axiom_element_t *)(om_node-> data_element), env, om_node);
                            if(namespace)
                            {
                                axiom_namespace_t *ns = NULL;
                                axis2_char_t *prefix = NULL;
                                prefix = axiom_namespace_get_prefix(namespace, env);
                                if(prefix)
                                {
                                    ns = axutil_hash_get(namespaces_from_parents, prefix,
                                        AXIS2_HASH_KEY_STRING);
                                    if(ns)
                                    {
                                        axutil_hash_set(namespaces_from_parents, prefix,
                                            AXIS2_HASH_KEY_STRING, NULL);
                                    }
                                }
                            }

                            /* then checking the attribute namespaces */

                            temp_attributes = axiom_element_get_all_attributes(
                                (axiom_element_t *)(om_node->data_element), env);
                            if(temp_attributes)
                            {
                                axutil_hash_index_t *hi;
                                void *val;
                                for(hi = axutil_hash_first(temp_attributes, env); hi; hi
                                    = axutil_hash_next(env, hi))
                                {
                                    axutil_hash_this(hi, NULL, NULL, &val);

                                    if(val)
                                    {
                                        axiom_namespace_t *ns = NULL;
                                        axis2_char_t *prefix = NULL;

                                        namespace = axiom_attribute_get_namespace(
                                            (axiom_attribute_t *)val, env);

                                        if(namespace)
                                        {
                                            prefix = axiom_namespace_get_prefix(namespace, env);
                                            if(prefix)
                                            {
                                                ns = axutil_hash_get(namespaces_from_parents,
                                                    prefix, AXIS2_HASH_KEY_STRING);
                                                if(ns)
                                                {
                                                    axutil_hash_set(namespaces_from_parents,
                                                        prefix, AXIS2_HASH_KEY_STRING, NULL);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            status = axiom_element_serialize_end_part(
                                (axiom_element_t *)(om_node->data_element), env, om_output);
                        }
                        if(status != AXIS2_SUCCESS)
                        {
                            break;
                        }
                    }

                    temp_node = axiom_node_get_next_sibling(om_node, env);
                }

                if(temp_node && count > 1)
                {
                    om_node = temp_node;
                    nodes[count - 1] = om_node;
                }
                else
                {
                    count--;
                }
            }
        }
    }
    while(count > 0);

    axutil_hash_free(namespaces_from_parents, env);
    axutil_hash_free(namespaces, env);

    return status;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_parent(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    return om_node->parent;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_first_child(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    int token = 0;
    if(!om_node)
    {
        return NULL;
    }

    /**********************************************************/
    while(!(om_node->first_child) && !(om_node->done) && om_node->builder)
    {
        token = axiom_stax_builder_next_with_token(om_node->builder, env);
        if(token == -1)
        {
            return NULL;
        }
    }

    /**********************************************************/
    return om_node->first_child;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_first_element(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    int token = 0;
    axiom_node_t *first_element;
    if(!om_node)
    {
        return NULL;
    }

    /**********************************************************/
    while(!(om_node->first_child) && !(om_node->done) && om_node->builder)
    {
        token = axiom_stax_builder_next_with_token(om_node->builder, env);
        if(token == -1)
        {
            return NULL;
        }
    }

    /**********************************************************/
    first_element = om_node->first_child;

    while(first_element && (axiom_node_get_node_type(first_element, env) != AXIOM_ELEMENT))
    {
        first_element = axiom_node_get_next_sibling(first_element, env);
    }

    return first_element;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_last_child(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    return om_node->last_child;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_previous_sibling(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    return om_node->prev_sibling;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_previous_sibling_element(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    axiom_node_t * result = axiom_node_get_previous_sibling( om_node, env );
    while ( result && axiom_node_get_node_type(result, env) != AXIOM_ELEMENT )
        result = axiom_node_get_previous_sibling( result, env );
    return result;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_next_sibling(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    int token = 0;
    if(!om_node)
    {
        return NULL;
    }

    /* we have to build the tree using stax builder if
     * (1) om_node's next_sibling is not given (if available, we can just return that)
     * (2) om_node is having a parent (otherwise, no concept of sibling)
     * (3) om_node is having a stax builder (otherwise, it is a programatically built node)
     * (4) parent is having a stax builder (otherwise, om_node is the only child,
     *          or sibling is programatically created)
     * (5) parent is not yet fully built
     */
    while((!om_node->next_sibling) && om_node->parent && om_node->parent->builder
        && om_node->builder && (!axiom_node_is_complete(om_node->parent, env)))
    {
        token = axiom_stax_builder_next_with_token(om_node->builder, env);
        if(token == -1)
        {
            return NULL;
        }
    }

    return om_node->next_sibling;
}

AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_node_get_next_sibling_element(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    axiom_node_t * result = axiom_node_get_next_sibling( om_node, env );
    while ( result && axiom_node_get_node_type(result, env) != AXIOM_ELEMENT )
        result = axiom_node_get_next_sibling( result, env );
    return result;
}


AXIS2_EXTERN axiom_types_t AXIS2_CALL
axiom_node_get_node_type(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    return om_node->node_type;
}

AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axiom_node_is_complete(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    return om_node->done;

}

AXIS2_EXTERN struct axiom_document *AXIS2_CALL
axiom_node_get_document(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    if(om_node->builder)
    {
        return axiom_stax_builder_get_document(om_node->builder, env);
    }

    return NULL;
}

AXIS2_EXTERN void *AXIS2_CALL
axiom_node_get_data_element(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    return om_node->data_element;
}

/**
 internal function , not to be used by users
 only sets the first_child link because this is needed by builder
 */
void AXIS2_CALL
axiom_node_set_first_child(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_node_t * first_child)
{
    /** set the parent */
    axiom_node_set_parent(first_child, env, om_node);
    om_node->first_child = first_child;
}

/**
 internal function not to be used by users
 only sets the previous sibling link as it is needed by builders

 */
void AXIS2_CALL
axiom_node_set_previous_sibling(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_node_t * prev_sibling)
{
    om_node->prev_sibling = prev_sibling;
}

/**
 internal function, not to be used by users
 only sets the next sibling link;
 */
void AXIS2_CALL
axiom_node_set_next_sibling(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_node_t * next_sibling)
{
    om_node->next_sibling = next_sibling;
}

/**
 internal function not to be used by users
 sets the node type only used in soap and om
 */

axis2_status_t AXIS2_CALL
axiom_node_set_node_type(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_types_t type)
{
    om_node->node_type = type;
    return AXIS2_SUCCESS;
}

/**
 internal function , not to be used by users
 only used in om and soap
 */
void AXIS2_CALL
axiom_node_set_data_element(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    void *data_element)
{
    om_node->data_element = data_element;
}

/**
 internal function not to be used by users
 only sets the build status

 */
void AXIS2_CALL
axiom_node_set_complete(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axis2_bool_t done)
{
    om_node->done = done;
}

/**
 internal function only sets the builder reference ,
 should not be used by user
 */
void AXIS2_CALL
axiom_node_set_builder(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    axiom_stax_builder_t * builder)
{
    /* builder == NULL is a valid case */
    om_node->builder = builder;
}

void AXIS2_CALL
axiom_node_assume_builder_ownership(
    axiom_node_t *om_node,
    const axutil_env_t * env)
{
    om_node->own_builder = AXIS2_TRUE;
}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_node_to_string(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    int status = AXIS2_SUCCESS;
    axiom_output_t *om_output = NULL;
    axiom_xml_writer_t *xml_writer = NULL;
    axis2_char_t *xml = NULL;
    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, om_node, NULL);

    xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
        AXIS2_XML_PARSER_TYPE_BUFFER);
    if(!xml_writer)
    {
        return NULL;
    }

    om_output = axiom_output_create(env, xml_writer);
    if(!om_output)
    {
        axiom_xml_writer_free(xml_writer, env);
        return NULL;
    }
    status = axiom_node_serialize(om_node, env, om_output);
    if(status == AXIS2_SUCCESS)
    {
        xml = axutil_strdup(env, (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env));
    }
    axiom_output_free(om_output, env);
    return xml;
}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_node_sub_tree_to_string(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    int status = AXIS2_SUCCESS;
    axiom_output_t *om_output = NULL;
    axiom_xml_writer_t *xml_writer = NULL;
    axis2_char_t *xml = NULL;
    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, om_node, NULL);

    xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
        AXIS2_XML_PARSER_TYPE_BUFFER);
    if(!xml_writer)
    {
        return NULL;
    }

    om_output = axiom_output_create(env, xml_writer);
    if(!om_output)
    {
        axiom_xml_writer_free(xml_writer, env);
        return NULL;
    }
    status = axiom_node_serialize_sub_tree(om_node, env, om_output);
    if(status == AXIS2_SUCCESS)
    {
        xml = axutil_strdup(env, (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env));
    }
    axiom_output_free(om_output, env);
    return xml;
}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_node_to_string_non_optimized(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    int status = AXIS2_SUCCESS;
    axiom_output_t *om_output = NULL;
    axiom_xml_writer_t *xml_writer = NULL;
    axis2_char_t *xml = NULL;
    AXIS2_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, om_node, NULL);

    xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
        AXIS2_XML_PARSER_TYPE_BUFFER);
    if(!xml_writer)
    {
        return NULL;
    }

    om_output = axiom_output_create(env, xml_writer);
    if(!om_output)
    {
        axiom_xml_writer_free(xml_writer, env);
        return NULL;
    }
    /*This is where we set the output to be non-optimized*/
    axiom_output_set_do_optimize(om_output, env, AXIS2_FALSE);
    status = axiom_node_serialize(om_node, env, om_output);
    if(status == AXIS2_SUCCESS)
    {
        xml = axutil_strdup(env, (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env));
    }
    axiom_output_free(om_output, env);
    return xml;
}

AXIS2_EXTERN axiom_node_t * AXIS2_CALL
axiom_node_add_sibling(
	const axutil_env_t *env,
	axiom_node_t *nodeElem,
	axiom_node_t *nodeElemSibling)
{
	assert(env != NULL);

	AXIS2_ENV_CHECK(env, NULL);
	AXIS2_PARAM_CHECK(env->error, nodeElem, NULL);
	AXIS2_PARAM_CHECK(env->error, nodeElemSibling, NULL);

	axiom_node_t *next_sib = NULL;
	nodeElemSibling->parent = nodeElem->parent;
	nodeElemSibling->prev_sibling = nodeElem;
	next_sib = nodeElem->next_sibling;
	if (next_sib)
	{
		next_sib->prev_sibling = nodeElemSibling;
	}
	nodeElemSibling->next_sibling = nodeElem->next_sibling;
	nodeElem->next_sibling = nodeElemSibling;

	return nodeElem;
}
  
#if 0

/**
 internal function not to be used by users
 only used by om builder
 */
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_node_set_document(
    axiom_node_t * om_node,
    const axutil_env_t * env,
    struct axiom_document * om_doc)
{
    /* om_doc == NULL is a valid case */
    om_node->om_doc = om_doc;
    return AXIS2_SUCCESS;
}

/**
 * This is an internal function
 */
AXIS2_EXTERN axiom_stax_builder_t *AXIS2_CALL
axiom_node_get_builder(
    axiom_node_t * om_node,
    const axutil_env_t * env)
{
    if(!om_node)
    {
        return NULL;
    }
    return om_node->builder;
}

#endif