/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * Copyright (C) 2003 Imendio AB
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <config.h>
#include <string.h>

#include <glib.h>

#include "lm-debug.h"
#include "lm-internals.h"
#include "lm-message-node.h"
#include "lm-parser.h"

#define SHORT_END_TAG "/>"
#define XML_MAX_DEPTH 5

#define LM_PARSER(o) ((LmParser *) o)

struct LmParser {
	LmParserMessageFunction  function;
	gpointer                 user_data;
	GDestroyNotify           notify;
	
	LmMessageNode           *cur_root;
	LmMessageNode           *cur_node;
		
	GMarkupParser           *m_parser;
	GMarkupParseContext     *context;
};


/* Used while parsing */
static void    parser_start_node_cb (GMarkupParseContext  *context,
				     const gchar          *node_name,
				     const gchar         **attribute_names,
				     const gchar         **attribute_values,
				     gpointer              user_data,
				     GError              **error);
static void    parser_end_node_cb   (GMarkupParseContext  *context,
				     const gchar          *node_name,
				     gpointer              user_data,
				     GError              **error);
static void    parser_text_cb       (GMarkupParseContext  *context,
				     const gchar          *text,
				     gsize                 text_len,  
				     gpointer              user_data,
				     GError              **error);
static void    parser_error_cb      (GMarkupParseContext  *context,
				     GError               *error,
				     gpointer              user_data);

static void
parser_start_node_cb (GMarkupParseContext  *context,
		      const gchar          *node_name,
		      const gchar         **attribute_names,
		      const gchar         **attribute_values,
		      gpointer              user_data,
		      GError              **error)
{	
	LmParser     *parser;
	gint          i;
	
	parser = LM_PARSER (user_data);;
	

/* 	parser->cur_depth++; */

	if (!parser->cur_root) {
		/* New toplevel element */
		parser->cur_root = _lm_message_node_new (node_name);
		parser->cur_node = parser->cur_root;
	} else {
		LmMessageNode *parent_node;
		
		parent_node = parser->cur_node;
		
		parser->cur_node = _lm_message_node_new (node_name);
		_lm_message_node_add_child_node (parent_node,
						 parser->cur_node);
	}

	for (i = 0; attribute_names[i]; ++i) {
		/*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_PARSER, 
		       "ATTRIBUTE: %s = %s\n", 
		       attribute_names[i],
		       attribute_values[i]);*/
		
		lm_verbose ("[parser_start_node_cb]: ATTRIBUTE: %s = %s\n", 
		       attribute_names[i],
		       attribute_values[i]);
		
		lm_message_node_set_attributes (parser->cur_node,
						attribute_names[i],
						attribute_values[i], 
						NULL);
	}
	
	if (strcmp ("stream:stream", node_name) == 0) {
		parser_end_node_cb (context,
				    "stream:stream",
				    user_data, 
				    error);
	}
}

static void
parser_end_node_cb (GMarkupParseContext  *context,
		    const gchar          *node_name,
		    gpointer              user_data,
		    GError              **error)
{
	LmParser     *parser;
	
	parser = LM_PARSER (user_data);
	
	/*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_PARSER,
	       "Trying to close node: %s\n", node_name);*/
    lm_verbose ("[parser_end_node_cb]:Trying to close node: %s\n", node_name);
    if (!parser->cur_node) {
                /* FIXME: LM-1 should look at this */
                return;
        }
        
	if (strcmp (parser->cur_node->name, node_name) != 0) {
		if (strcmp (node_name, "stream:stream")) {
			g_print ("Got an stream:stream end\n");
		}
		g_warning ("Trying to close node that isn't open: %s",
			   node_name);
		return;
	}

	if (parser->cur_node == parser->cur_root) {
		LmMessage *m;
		
		m = _lm_message_new_from_node (parser->cur_root);

		if (!m) {
			g_warning ("Couldn't create message: %s\n",
				   parser->cur_root->name);
			return;
		}

		/*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_PARSER,
		       "Have a new message\n");*/
		lm_verbose("[parser_end_node_cb]: Have a new message\n");
		if (parser->function) {
			(* parser->function) (parser, m, parser->user_data);
		}

		lm_message_unref (m);
		lm_message_node_unref (parser->cur_root);
		
			
		parser->cur_node = parser->cur_root = NULL;
	} else {
		LmMessageNode *tmp_node;
		tmp_node = parser->cur_node;
		parser->cur_node = parser->cur_node->parent;

		lm_message_node_unref (tmp_node);
	}
	UNUSED_FORMAL_PARAM(context);
	UNUSED_FORMAL_PARAM(error);
}

static void
parser_text_cb (GMarkupParseContext   *context,
		const gchar           *text,
		gsize                  text_len,  
		gpointer               user_data,
		GError               **error)
{
	LmParser *parser;
	
	g_return_if_fail (user_data != NULL);
	
	parser = LM_PARSER (user_data);
	
	if (parser->cur_node && strcmp (text, "") != 0) {
		lm_message_node_set_value (parser->cur_node, text);
	} 
	UNUSED_FORMAL_PARAM(context);
	UNUSED_FORMAL_PARAM(error);
	UNUSED_FORMAL_PARAM(text_len);
}

static void
parser_error_cb (GMarkupParseContext *context,
		 GError              *error,
		 gpointer             user_data)
{
	g_return_if_fail (user_data != NULL);
	g_return_if_fail (error != NULL);
	
	g_warning ("Parsing failed: %s\n", error->message);
	UNUSED_FORMAL_PARAM(context);
}

EXPORT_C LmParser *
lm_parser_new (LmParserMessageFunction function, 
	       gpointer                user_data, 
	       GDestroyNotify          notify)
{
	LmParser *parser;
	
	parser = g_new0 (LmParser, 1);
	if (!parser) {
		return NULL;
	}
	
	parser->m_parser = g_new0 (GMarkupParser, 1);
	if (!parser->m_parser) {
		g_free (parser);
		return NULL;
	}

	parser->function  = function;
	parser->user_data = user_data;
	parser->notify    = notify;
	
	parser->m_parser->start_element = parser_start_node_cb;
	parser->m_parser->end_element   = parser_end_node_cb;
	parser->m_parser->text          = parser_text_cb;
	parser->m_parser->error         = parser_error_cb;

	parser->context = g_markup_parse_context_new (parser->m_parser, 0,
						      parser, NULL);

	parser->cur_root = NULL;
	parser->cur_node = NULL;

	return parser;
}

EXPORT_C void
lm_parser_parse (LmParser *parser, const gchar *string)
{
	g_return_if_fail (parser != NULL);
	
        if (!parser->context) {
                parser->context = g_markup_parse_context_new (parser->m_parser, 0,
                                                              parser, NULL);
        }
        
        if (g_markup_parse_context_parse (parser->context, string, 
                                          (gssize)strlen (string), NULL)) {
        } else {
		g_markup_parse_context_free (parser->context);
		parser->context = NULL;
        }
}

EXPORT_C void
lm_parser_free (LmParser *parser)
{
	if (parser->notify) {
		(* parser->notify) (parser->user_data);
	}

	if (parser->context) {
		g_markup_parse_context_free (parser->context);
	}
	g_free (parser->m_parser);
	g_free (parser);
}