/*
 * $Id$
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *  Jabber
 *  Copyright (C) 1998-1999 The Jabber Team http://jabber.org/
 */
/*! \file
 * \ingroup xmpp
 */


#include "xode.h"

static int _xode_strcmp(const char *a, const char *b)
{
    if(a == NULL || b == NULL) return -1;

    return strcmp(a,b);
}

/*! \brief Internal routines */
static xode _xode_new(xode_pool p, const char* name, unsigned int type)
{
    xode result = NULL;
    if (type > XODE_TYPE_LAST)
        return NULL;

    if (type != XODE_TYPE_CDATA && name == NULL)
        return NULL;

    if (p == NULL)
    {
        p = xode_pool_heap(1*1024);
    }

    /* Allocate & zero memory */
    result = (xode)xode_pool_malloc(p, sizeof(_xode));
    memset(result, '\0', sizeof(_xode));

    /* Initialize fields */
    if (type != XODE_TYPE_CDATA)
        result->name = xode_pool_strdup(p,name);
    result->type = type;
    result->p = p;
    return result;
}

static xode _xode_appendsibling(xode lastsibling, const char* name, unsigned int type)
{
    xode result;

    result = _xode_new(xode_get_pool(lastsibling), name, type);
    if (result != NULL)
    {
        /* Setup sibling pointers */
        result->prev = lastsibling;
        lastsibling->next = result;
    }
    return result;
}

static xode _xode_insert(xode parent, const char* name, unsigned int type)
{
    xode result;

    if(parent == NULL || name == NULL) return NULL;

    /* If parent->firstchild is NULL, simply create a new node for the first child */
    if (parent->firstchild == NULL)
    {
        result = _xode_new(parent->p, name, type);
        parent->firstchild = result;
    }
    /* Otherwise, append this to the lastchild */
    else
    {
        result= _xode_appendsibling(parent->lastchild, name, type);
    }
    result->parent = parent;
    parent->lastchild = result;
    return result;

}

static xode _xode_search(xode firstsibling, const char* name, unsigned int type)
{
    xode current;

    /* Walk the sibling list, looking for a XODE_TYPE_TAG xode with
    the specified name */
    current = firstsibling;
    while (current != NULL)
    {
        if (name != NULL && (current->type == type) && (_xode_strcmp(current->name, name) == 0))
            return current;
        else
            current = current->next;
    }
    return NULL;
}

static char* _xode_merge(xode_pool p, char* dest, unsigned int destsize, const char* src, unsigned int srcsize)
{
    char* result;
    result = (char*)xode_pool_malloc(p, destsize + srcsize + 1);
    memcpy(result, dest, destsize);
    memcpy(result+destsize, src, srcsize);
    result[destsize + srcsize] = '\0';

    /* WARNING: major ugly hack: since we're throwing the old data away, let's jump in the xode_pool and subtract it from the size, this is for xmlstream's big-node checking */
    p->size -= destsize;

    return result;
}

static void _xode_hidesibling(xode child)
{
    if(child == NULL)
        return;

    if(child->prev != NULL)
        child->prev->next = child->next;
    if(child->next != NULL)
        child->next->prev = child->prev;
}

static void _xode_tag2str(xode_spool s, xode node, int flag)
{
    xode tmp;

    if(flag==0 || flag==1)
    {
	    xode_spooler(s,"<",xode_get_name(node),s);
	    tmp = xode_get_firstattrib(node);
	    while(tmp) {
	        xode_spooler(s," ",xode_get_name(tmp),"='",xode_strescape(xode_get_pool(node),xode_get_data(tmp)),"'",s);
	        tmp = xode_get_nextsibling(tmp);
	    }
	    if(flag==0)
	        xode_spool_add(s,"/>");
	    else
	        xode_spool_add(s,">");
    }
    else
    {
	    xode_spooler(s,"</",xode_get_name(node),">",s);
    }
}

static xode_spool _xode_tospool(xode node)
{
    xode_spool s;
    int level=0,dir=0;
    xode tmp;

    if(!node || xode_get_type(node) != XODE_TYPE_TAG)
	return NULL;

    s = xode_spool_newfrompool(xode_get_pool(node));
    if(!s) return(NULL);

    while(1)
    {
        if(dir==0)
        {
    	    if(xode_get_type(node) == XODE_TYPE_TAG)
            {
		        if(xode_has_children(node))
                {
		            _xode_tag2str(s,node,1);
        		    node = xode_get_firstchild(node);
		            level++;
		            continue;
        		}
                else
                {
		            _xode_tag2str(s,node,0);
		        }
	        }
            else
            {
		        xode_spool_add(s,xode_strescape(xode_get_pool(node),xode_get_data(node)));
	        }
	    }

    	tmp = xode_get_nextsibling(node);
	    if(!tmp)
        {
	        node = xode_get_parent(node);
	        level--;
	        if(level>=0) _xode_tag2str(s,node,2);
	        if(level<1) break;
	        dir = 1;
	    }
        else
        {
	        node = tmp;
	        dir = 0;
	    }
    }

    return s;
}


/* External routines */


/*
 *  xode_new_tag -- create a tag node
 *  Automatically creates a memory xode_pool for the node.
 *
 *  parameters
 *      name -- name of the tag
 *
 *  returns
 *      a pointer to the tag node
 *      or NULL if it was unsuccessful
 */
xode xode_new(const char* name)
{
    return _xode_new(NULL, name, XODE_TYPE_TAG);
}

/*
 * alias for 'xode_new'
 */
xode xode_new_tag(const char* name)
{
    return _xode_new(NULL, name, XODE_TYPE_TAG);
}

/*
 *  xode_new_tag_pool -- create a tag node within given pool
 *
 *  parameters
 *      p -- previously created memory pool
 *      name -- name of the tag
 *
 *  returns
 *      a pointer to the tag node
 *      or NULL if it was unsuccessful
 */
xode xode_new_frompool(xode_pool p, const char* name)
{
    return _xode_new(p, name, XODE_TYPE_TAG);
}


/*
 *  xode_insert_tag -- append a child tag to a tag
 *
 *  parameters
 *      parent -- pointer to the parent tag
 *      name -- name of the child tag
 *
 *  returns
 *      a pointer to the child tag node
 *      or NULL if it was unsuccessful
 */
xode xode_insert_tag(xode parent, const char* name)
{
    return _xode_insert(parent, name, XODE_TYPE_TAG);
}


/*
 *  xode_insert_cdata -- append character data to a tag
 *  If last child of the parent is CDATA, merges CDATA nodes. Otherwise
 *  creates a CDATA node, and appends it to the parent's child list.
 *
 *  parameters
 *      parent -- parent tag
 *      CDATA -- character data
 *      size -- size of CDATA
 *              or -1 for null-terminated CDATA strings
 *
 *  returns
 *      a pointer to the child CDATA node
 *      or NULL if it was unsuccessful
 */
xode xode_insert_cdata(xode parent, const char* CDATA, unsigned int size)
{
    xode result;

    if(CDATA == NULL || parent == NULL)
        return NULL;

    if(size == -1)
        size = strlen(CDATA);

    if ((parent->lastchild != NULL) && (parent->lastchild->type == XODE_TYPE_CDATA))
    {
        result = parent->lastchild;
        result->data = _xode_merge(result->p, result->data, result->data_sz, CDATA, size);
        result->data_sz = result->data_sz + size;
    }
    else
    {
        result = _xode_insert(parent, "", XODE_TYPE_CDATA);
        if (result != NULL)
        {
            result->data = (char*)xode_pool_malloc(result->p, size + 1);
            memcpy(result->data, CDATA, size);
            result->data[size] = '\0';
            result->data_sz = size;
        }
    }

    return result;
}


/*
 *  xode_gettag -- find given tag in an xode tree
 *
 *  parameters
 *      parent -- pointer to the parent tag
 *      name -- "name" for the child tag of that name
 *              "name/name" for a sub child (recurses)
 *              "?attrib" to match the first tag with that attrib defined
 *              "?attrib=value" to match the first tag with that attrib and value
 *              or any combination: "name/name/?attrib", etc
 *
 *  results
 *      a pointer to the tag matching search criteria
 *      or NULL if search was unsuccessful
 */
xode xode_get_tag(xode parent, const char* name)
{
    char *str, *slash, *qmark, *equals;
    xode step, ret;

    if(parent == NULL || parent->firstchild == NULL || name == NULL || name == '\0') return NULL;

    if(strstr(name, "/") == NULL && strstr(name,"?") == NULL)
        return _xode_search(parent->firstchild, name, XODE_TYPE_TAG);

    /* jer's note: why can't I modify the name directly, why do I have to strdup it?  damn c grrr! */
    str = strdup(name);
    slash = strstr(str, "/");
    qmark = strstr(str, "?");
    equals = strstr(str, "=");

    if(qmark != NULL && (slash == NULL || qmark < slash))
    { /* of type ?attrib */

        *qmark = '\0';
        qmark++;
        if(equals != NULL)
        {
            *equals = '\0';
            equals++;
        }

        for(step = parent->firstchild; step != NULL; step = xode_get_nextsibling(step))
        {
            if(xode_get_type(step) != XODE_TYPE_TAG)
                continue;

            if(*str != '\0')
                if(_xode_strcmp(xode_get_name(step),str) != 0)
                    continue;

            if(xode_get_attrib(step,qmark) == NULL)
                continue;

            if(equals != NULL && _xode_strcmp(xode_get_attrib(step,qmark),equals) != 0)
                continue;

            break;
        }

        free(str);
        return step;
    }


    *slash = '\0';
    ++slash;

    for(step = parent->firstchild; step != NULL; step = xode_get_nextsibling(step))
    {
        if(xode_get_type(step) != XODE_TYPE_TAG) continue;

        if(_xode_strcmp(xode_get_name(step),str) != 0)
            continue;

        ret = xode_get_tag(step, slash);
        if(ret != NULL)
        {
            free(str);
            return ret;
        }
    }

    free(str);
    return NULL;
}


/* return the cdata from any tag */
char *xode_get_tagdata(xode parent, const char *name)
{
    xode tag;

    tag = xode_get_tag(parent, name);
    if(tag == NULL) return NULL;

    return xode_get_data(tag);
}


void xode_put_attrib(xode owner, const char* name, const char* value)
{
    xode attrib;

    if(owner == NULL || name == NULL || value == NULL) return;

    /* If there are no existing attributes, allocate a new one to start
    the list */
    if (owner->firstattrib == NULL)
    {
        attrib = _xode_new(owner->p, name, XODE_TYPE_ATTRIB);
        owner->firstattrib = attrib;
        owner->lastattrib  = attrib;
    }
    else
    {
        attrib = _xode_search(owner->firstattrib, name, XODE_TYPE_ATTRIB);
        if(attrib == NULL)
        {
            attrib = _xode_appendsibling(owner->lastattrib, name, XODE_TYPE_ATTRIB);
            owner->lastattrib = attrib;
        }
    }
    /* Update the value of the attribute */
    attrib->data_sz = strlen(value);
    attrib->data    = xode_pool_strdup(owner->p, value);

}

char* xode_get_attrib(xode owner, const char* name)
{
    xode attrib;

    if (owner != NULL && owner->firstattrib != NULL)
    {
        attrib = _xode_search(owner->firstattrib, name, XODE_TYPE_ATTRIB);
        if (attrib != NULL)
            return (char*)attrib->data;
    }
    return NULL;
}

void xode_put_vattrib(xode owner, const char* name, void *value)
{
    xode attrib;

    if (owner != NULL)
    {
        attrib = _xode_search(owner->firstattrib, name, XODE_TYPE_ATTRIB);
        if (attrib == NULL)
        {
            xode_put_attrib(owner, name, "");
            attrib = _xode_search(owner->firstattrib, name, XODE_TYPE_ATTRIB);
        }
        if (attrib != NULL)
            attrib->firstchild = (xode)value;
    }
}

void* xode_get_vattrib(xode owner, const char* name)
{
    xode attrib;

    if (owner != NULL && owner->firstattrib != NULL)
    {
        attrib = _xode_search(owner->firstattrib, name, XODE_TYPE_ATTRIB);
        if (attrib != NULL)
            return (void*)attrib->firstchild;
    }
    return NULL;
}

xode xode_get_firstattrib(xode parent)
{
    if (parent != NULL)
        return parent->firstattrib;
    return NULL;
}

xode xode_get_firstchild(xode parent)
{
    if (parent != NULL)
        return parent->firstchild;
    return NULL;
}

xode xode_get_lastchild(xode parent)
{
    if (parent != NULL)
        return parent->lastchild;
    return NULL;
}

xode xode_get_nextsibling(xode sibling)
{
    if (sibling != NULL)
        return sibling->next;
    return NULL;
}

xode xode_get_prevsibling(xode sibling)
{
    if (sibling != NULL)
        return sibling->prev;
    return NULL;
}

xode xode_get_parent(xode node)
{
    if (node != NULL)
        return node->parent;
    return NULL;
}

char* xode_get_name(xode node)
{
    if (node != NULL)
        return node->name;
    return NULL;
}

char* xode_get_data(xode node)
{
    xode cur;

    if(node == NULL) return NULL;

    if(xode_get_type(node) == XODE_TYPE_TAG) /* loop till we find a CDATA */
    {
        for(cur = xode_get_firstchild(node); cur != NULL; cur = xode_get_nextsibling(cur))
            if(xode_get_type(cur) == XODE_TYPE_CDATA)
                return cur->data;
    }else{
        return node->data;
    }
    return NULL;
}

int xode_get_datasz(xode node)
{
	
    if( node == NULL )
    {
        return (int)(long)NULL;	    
    }	    
    else if(xode_get_type(node) == XODE_TYPE_TAG) /* loop till we find a CDATA */
    {
    	xode cur;	
        for(cur = xode_get_firstchild(node); cur != NULL; cur = xode_get_nextsibling(cur))
            if(xode_get_type(cur) == XODE_TYPE_CDATA)
                return cur->data_sz;
    }else{
        return node->data_sz;
    }
    return (int)(long)NULL;
}

int xode_get_type(xode node)
{
    if (node != NULL)
    {
        return node->type;
    }
    return (int)(long)NULL;
}

int xode_has_children(xode node)
{
    if ((node != NULL) && (node->firstchild != NULL))
        return 1;
    return 0;
}

int xode_has_attribs(xode node)
{
    if ((node != NULL) && (node->firstattrib != NULL))
        return 1;
    return 0;
}

xode_pool xode_get_pool(xode node)
{
    if (node != NULL)
        return node->p;
    return (xode_pool)NULL;
}

void xode_hide(xode child)
{
    xode parent;

    if(child == NULL || child->parent == NULL)
        return;

    parent = child->parent;

    /* first fix up at the child level */
    _xode_hidesibling(child);

    /* next fix up at the parent level */
    if(parent->firstchild == child)
        parent->firstchild = child->next;
    if(parent->lastchild == child)
        parent->lastchild = child->prev;
}

void xode_hide_attrib(xode parent, const char *name)
{
    xode attrib;

    if(parent == NULL || parent->firstattrib == NULL || name == NULL)
        return;

    attrib = _xode_search(parent->firstattrib, name, XODE_TYPE_ATTRIB);
    if(attrib == NULL)
        return;

    /* first fix up at the child level */
    _xode_hidesibling(attrib);

    /* next fix up at the parent level */
    if(parent->firstattrib == attrib)
        parent->firstattrib = attrib->next;
    if(parent->lastattrib == attrib)
        parent->lastattrib = attrib->prev;
}



/*
 *  xode2str -- convert given xode tree into a string
 *
 *  parameters
 *      node -- pointer to the xode structure
 *
 *  results
 *      a pointer to the created string
 *      or NULL if it was unsuccessful
 */
char *xode_to_str(xode node)
{
     return xode_spool_tostr(_xode_tospool(node));
}


/* loop through both a and b comparing everything, attribs, cdata, children, etc */
int xode_cmp(xode a, xode b)
{
    int ret = 0;

    while(1)
    {
        if(a == NULL && b == NULL)
            return 0;

        if(a == NULL || b == NULL)
            return -1;

        if(xode_get_type(a) != xode_get_type(b))
            return -1;

        switch(xode_get_type(a))
        {
        case XODE_TYPE_ATTRIB:
            ret = _xode_strcmp(xode_get_name(a), xode_get_name(b));
            if(ret != 0)
                return -1;
            ret = _xode_strcmp(xode_get_data(a), xode_get_data(b));
            if(ret != 0)
                return -1;
            break;
        case XODE_TYPE_TAG:
            ret = _xode_strcmp(xode_get_name(a), xode_get_name(b));
            if(ret != 0)
                return -1;
            ret = xode_cmp(xode_get_firstattrib(a), xode_get_firstattrib(b));
            if(ret != 0)
                return -1;
            ret = xode_cmp(xode_get_firstchild(a), xode_get_firstchild(b));
            if(ret != 0)
                return -1;
            break;
        case XODE_TYPE_CDATA:
            ret = _xode_strcmp(xode_get_data(a), xode_get_data(b));
            if(ret != 0)
                return -1;
        }
        a = xode_get_nextsibling(a);
        b = xode_get_nextsibling(b);
    }
}


xode xode_insert_tagnode(xode parent, xode node)
{
    xode child;

    child = xode_insert_tag(parent, xode_get_name(node));
    if (xode_has_attribs(node))
        xode_insert_node(child, xode_get_firstattrib(node));
    if (xode_has_children(node))
        xode_insert_node(child, xode_get_firstchild(node));

    return child;
}

/* places copy of node and node's siblings in parent */
void xode_insert_node(xode parent, xode node)
{
    if(node == NULL || parent == NULL)
        return;

    while(node != NULL)
    {
        switch(xode_get_type(node))
        {
        case XODE_TYPE_ATTRIB:
            xode_put_attrib(parent, xode_get_name(node), xode_get_data(node));
            break;
        case XODE_TYPE_TAG:
            xode_insert_tagnode(parent, node);
            break;
        case XODE_TYPE_CDATA:
            xode_insert_cdata(parent, xode_get_data(node), xode_get_datasz(node));
        }
        node = xode_get_nextsibling(node);
    }
}


/* produce full duplicate of x with a new xode_pool, x must be a tag! */
xode xode_dup(xode x)
{
    xode x2;

    if(x == NULL)
        return NULL;

    x2 = xode_new(xode_get_name(x));

    if (xode_has_attribs(x))
        xode_insert_node(x2, xode_get_firstattrib(x));
    if (xode_has_children(x))
        xode_insert_node(x2, xode_get_firstchild(x));

    return x2;
}

xode xode_dup_frompool(xode_pool p, xode x)
{
    xode x2;

    if(x == NULL)
        return NULL;

    x2 = xode_new_frompool(p, xode_get_name(x));

    if (xode_has_attribs(x))
        xode_insert_node(x2, xode_get_firstattrib(x));
    if (xode_has_children(x))
        xode_insert_node(x2, xode_get_firstchild(x));

    return x2;
}

xode xode_wrap(xode x,const char *wrapper)
{
    xode wrap;
    if(x==NULL||wrapper==NULL) return NULL;
    wrap=xode_new_frompool(xode_get_pool(x),wrapper);
    if(wrap==NULL) return NULL;
    wrap->firstchild=x;
    wrap->lastchild=x;
    x->parent=wrap;
    return wrap;
}

void xode_free(xode node)
{
    if(node == NULL)
        return;

    xode_pool_free(node->p);
}


void
_xode_to_prettystr( xode_spool s, xode x, int deep )
{
	int i;
	xode y;

	if(xode_get_type(x) != XODE_TYPE_TAG) return;
	
	for(i=0; i<deep; i++) xode_spool_add(s, "\t");	

	xode_spooler( s , "<" , xode_get_name(x) ,  s );

	y = xode_get_firstattrib(x);
	while( y )
	{
		xode_spooler( s , " " , xode_get_name(y) , "='", xode_get_data(y) , "'" , s );

		y = xode_get_nextsibling( y );
	}
	xode_spool_add(s,">");
	xode_spool_add(s,"\n");
		
	if( xode_get_data(x))
	{
		for(i=0; i<=deep; i++) xode_spool_add(s, "\t");	
		xode_spool_add( s , xode_get_data(x)); 
	}
			
	y = xode_get_firstchild(x);
	while( y )
	{
		_xode_to_prettystr(s , y, deep+1);
		y = xode_get_nextsibling(y);
		xode_spool_add(s,"\n");
	}
		
	for(i=0; i<deep; i++) xode_spool_add(s, "\t");	
	xode_spooler( s , "</" , xode_get_name(x) , ">" , s );

	return;
}

char * 
xode_to_prettystr( xode x )
{
	xode_spool s;

	if( !x) return NULL;
	
	s = xode_spool_newfrompool( xode_get_pool(x));

	_xode_to_prettystr( s , x, 0 );

	return xode_spool_tostr(s);
}