/*
 * mod_rayo for FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 * Copyright (C) 2013-2014, Grasshopper
 *
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is mod_rayo for FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 *
 * The Initial Developer of the Original Code is Grasshopper
 * Portions created by the Initial Developer are Copyright (C)
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 * Chris Rienzo <chris.rienzo@grasshopper.com>
 *
 * nlsml.c -- Parses / creates NLSML results
 *
 */
#include <switch.h>
#include <iksemel.h>

#include "nlsml.h"

struct nlsml_parser;

/** function to handle tag attributes */
typedef int (* tag_attribs_fn)(struct nlsml_parser *, char **);
/** function to handle tag CDATA */
typedef int (* tag_cdata_fn)(struct nlsml_parser *, char *, size_t);

/**
 * Tag definition
 */
struct tag_def {
	tag_attribs_fn attribs_fn;
	tag_cdata_fn cdata_fn;
	switch_bool_t is_root;
	switch_hash_t *children_tags;
};

/**
 * library configuration
 */
typedef struct {
	/** true if initialized */
	switch_bool_t init;
	/** Mapping of tag name to definition */
	switch_hash_t *tag_defs;
	/** library memory pool */
	switch_memory_pool_t *pool;
} nlsml_globals;
static nlsml_globals globals = { 0 };

/**
 * The node in the XML tree
 */
struct nlsml_node {
	/** tag name */
	const char *name;
	/** tag definition */
	struct tag_def *tag_def;
	/** parent to this node */
	struct nlsml_node *parent;
};

/**
 * The SAX parser state
 */
struct nlsml_parser {
	/** current node */
	struct nlsml_node *cur;
	/** optional UUID for logging */
	const char *uuid;
	/** true if a match exists */
	int match;
	/** true if noinput */
	int noinput;
	/** true if nomatch */
	int nomatch;
};

/**
 * Tag def destructor
 */
static void destroy_tag_def(void *ptr)
{
    struct tag_def *tag = (struct tag_def *) ptr;
	if (tag->children_tags) {
		switch_core_hash_destroy(&tag->children_tags);
	}
}

/**
 * Add a definition for a tag
 * @param tag the name
 * @param attribs_fn the function to handle the tag attributes
 * @param cdata_fn the function to handler the tag CDATA
 * @param children_tags comma-separated list of valid child tag names
 * @return the definition
 */
static struct tag_def *add_tag_def(const char *tag, tag_attribs_fn attribs_fn, tag_cdata_fn cdata_fn, const char *children_tags)
{
	struct tag_def *def = switch_core_alloc(globals.pool, sizeof(*def));
	switch_core_hash_init(&def->children_tags);
	if (!zstr(children_tags)) {
		char *children_tags_dup = switch_core_strdup(globals.pool, children_tags);
		char *tags[32] = { 0 };
		int tag_count = switch_separate_string(children_tags_dup, ',', tags, sizeof(tags) / sizeof(tags[0]));
		if (tag_count) {
			int i;
			for (i = 0; i < tag_count; i++) {
				switch_core_hash_insert(def->children_tags, tags[i], tags[i]);
			}
		}
	}
	def->attribs_fn = attribs_fn;
	def->cdata_fn = cdata_fn;
	def->is_root = SWITCH_FALSE;
	switch_core_hash_insert_destructor(globals.tag_defs, tag, def, destroy_tag_def);
	return def;
}

/**
 * Add a definition for a root tag
 * @param tag the name
 * @param attribs_fn the function to handle the tag attributes
 * @param cdata_fn the function to handler the tag CDATA
 * @param children_tags comma-separated list of valid child tag names
 * @return the definition
 */
static struct tag_def *add_root_tag_def(const char *tag, tag_attribs_fn attribs_fn, tag_cdata_fn cdata_fn, const char *children_tags)
{
	struct tag_def *def = add_tag_def(tag, attribs_fn, cdata_fn, children_tags);
	def->is_root = SWITCH_TRUE;
	return def;
}

/**
 * Handle tag attributes
 * @param parser the parser
 * @param name the tag name
 * @param atts the attributes
 * @return IKS_OK if OK IKS_BADXML on parse failure
 */
static int process_tag(struct nlsml_parser *parser, const char *name, char **atts)
{
	struct nlsml_node *cur = parser->cur;
	if (cur->tag_def->is_root && cur->parent == NULL) {
		/* no parent for ROOT tags */
		return cur->tag_def->attribs_fn(parser, atts);
	} else if (!cur->tag_def->is_root && cur->parent) {
		/* check if this child is allowed by parent node */
		struct tag_def *parent_def = cur->parent->tag_def;
		if (switch_core_hash_find(parent_def->children_tags, "ANY") ||
			switch_core_hash_find(parent_def->children_tags, name)) {
			return cur->tag_def->attribs_fn(parser, atts);
		} else {
			switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser->uuid), SWITCH_LOG_INFO, "<%s> cannot be a child of <%s>\n", name, cur->parent->name);
		}
	} else if (cur->tag_def->is_root && cur->parent != NULL) {
		switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser->uuid), SWITCH_LOG_INFO, "<%s> must be the root element\n", name);
	} else {
		switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser->uuid), SWITCH_LOG_INFO, "<%s> cannot be a root element\n", name);
	}
	return IKS_BADXML;
}

/**
 * Handle tag attributes that are ignored
 * @param parser the parser
 * @param atts the attributes
 * @return IKS_OK
 */
static int process_attribs_ignore(struct nlsml_parser *parser, char **atts)
{
	return IKS_OK;
}

/**
 * Handle CDATA that is ignored
 * @param parser the parser
 * @param data the CDATA
 * @param len the CDATA length
 * @return IKS_OK
 */
static int process_cdata_ignore(struct nlsml_parser *parser, char *data, size_t len)
{
	return IKS_OK;
}

/**
 * Handle CDATA that is not allowed
 * @param parser the parser
 * @param data the CDATA
 * @param len the CDATA length
 * @return IKS_BADXML if any printable characters
 */
static int process_cdata_bad(struct nlsml_parser *parser, char *data, size_t len)
{
	int i;
	for (i = 0; i < len; i++) {
		if (isgraph(data[i])) {
			switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser->uuid), SWITCH_LOG_INFO, "Unexpected CDATA for <%s>\n", parser->cur->name);
			return IKS_BADXML;
		}
	}
	return IKS_OK;
}

/**
 * Handle CDATA with match text
 * @param parser the parser
 * @param data the CDATA
 * @param len the CDATA length
 * @return IKS_OK
 */
static int process_cdata_match(struct nlsml_parser *parser, char *data, size_t len)
{
	int i;
	for (i = 0; i < len; i++) {
		if (isgraph(data[i])) {
			parser->match++;
			return IKS_OK;
		}
	}
	return IKS_OK;
}

/**
 * Handle nomatch
 * @param parser the parser
 * @param atts the attributes
 * @return IKS_OK
 */
static int process_nomatch(struct nlsml_parser *parser, char **atts)
{
	parser->nomatch++;
	return IKS_OK;
}

/**
 * Handle noinput
 * @param parser the parser
 * @param atts the attributes
 * @return IKS_OK
 */
static int process_noinput(struct nlsml_parser *parser, char **atts)
{
	parser->noinput++;
	return IKS_OK;
}

/**
 * Process a tag
 */
static int tag_hook(void *user_data, char *name, char **atts, int type)
{
	int result = IKS_OK;
	struct nlsml_parser *parser = (struct nlsml_parser *)user_data;

	if (type == IKS_OPEN || type == IKS_SINGLE) {
		struct nlsml_node *child_node = malloc(sizeof(*child_node));
		child_node->name = name;
		child_node->tag_def = switch_core_hash_find(globals.tag_defs, name);
		if (!child_node->tag_def) {
			child_node->tag_def = switch_core_hash_find(globals.tag_defs, "ANY");
		}
		child_node->parent = parser->cur;
		parser->cur = child_node;
		switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser->uuid), SWITCH_LOG_DEBUG1, "<%s>\n", name);
		result = process_tag(parser, name, atts);
	}

	if (type == IKS_CLOSE || type == IKS_SINGLE) {
		struct nlsml_node *node = parser->cur;
		parser->cur = node->parent;
		free(node);
		switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser->uuid), SWITCH_LOG_DEBUG1, "</%s>\n", name);
	}

	return result;
}

/**
 * Process cdata
 * @param user_data the parser
 * @param data the CDATA
 * @param len the CDATA length
 * @return IKS_OK
 */
static int cdata_hook(void *user_data, char *data, size_t len)
{
	struct nlsml_parser *parser = (struct nlsml_parser *)user_data;
	if (!parser) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Missing parser\n");
		return IKS_BADXML;
	}
	if (parser->cur) {
		struct tag_def *def = parser->cur->tag_def;
		if (def) {
			return def->cdata_fn(parser, data, len);
		}
		switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser->uuid), SWITCH_LOG_INFO, "Missing definition for <%s>\n", parser->cur->name);
		return IKS_BADXML;
	}
	return IKS_OK;
}

/**
 * Parse the result, looking for noinput/nomatch/match
 * @param nlsml_result the NLSML result to parse
 * @param uuid optional UUID for logging
 * @return true if successful
 */
enum nlsml_match_type nlsml_parse(const char *nlsml_result, const char *uuid)
{
	struct nlsml_parser parser = { 0 };
	int result = NMT_BAD_XML;
	iksparser *p = NULL;
	parser.uuid = uuid;

	if (!zstr(nlsml_result)) {
		p = iks_sax_new(&parser, tag_hook, cdata_hook);
		if (iks_parse(p, nlsml_result, 0, 1) == IKS_OK) {
			/* check result */
			if (parser.match) {
				result = NMT_MATCH;
				goto end;
			}
			if (parser.nomatch) {
				result = NMT_NOMATCH;
				goto end;
			}
			if (parser.noinput) {
				result = NMT_NOINPUT;
				goto end;
			}
			switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser.uuid), SWITCH_LOG_INFO, "NLSML result does not have match/noinput/nomatch!\n");
		} else {
			switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser.uuid), SWITCH_LOG_INFO, "Failed to parse NLSML!\n");
		}
	} else {
		switch_log_printf(SWITCH_CHANNEL_UUID_LOG(parser.uuid), SWITCH_LOG_INFO, "Missing NLSML result\n");
	}
 end:

	if ( p ) {
		iks_parser_delete(p);
	}
	return result;
}

#define NLSML_NS "http://www.ietf.org/xml/ns/mrcpv2"

/**
 * Makes NLSML result to conform to mrcpv2
 * @param result the potentially non-conforming result
 * @return the conforming result
 */
iks *nlsml_normalize(const char *result)
{
	iks *result_xml = NULL;
	iksparser *p = iks_dom_new(&result_xml);
	if (iks_parse(p, result, 0, 1) == IKS_OK && result_xml) {
		/* for now, all that is needed is to set the proper namespace */
		iks_insert_attrib(result_xml, "xmlns", NLSML_NS);
	} else {
		/* unexpected ... */
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Failed to normalize NLSML result: %s\n", result);
		if (result_xml) {
			iks_delete(result_xml);
		}
	}
	iks_parser_delete(p);
	return result_xml;
}

/**
 * @return true if digit is a DTMF
 */
static int isdtmf(const char digit)
{
	switch(digit) {
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	case '*':
	case '#':
	case 'a':
	case 'A':
	case 'b':
	case 'B':
	case 'c':
	case 'C':
	case 'd':
	case 'D':
		return 1;
	}
	return 0;
}

/**
 * Construct an NLSML result for digit match
 * @param digits the matching digits
 * @param interpretation the optional digit interpretation
 * @return the NLSML <result>
 */
iks *nlsml_create_dtmf_match(const char *digits, const char *interpretation)
{
	iks *result = iks_new("result");
	iks_insert_attrib(result, "xmlns", NLSML_NS);
	iks_insert_attrib(result, "xmlns:xf", "http://www.w3.org/2000/xforms");
	if (!zstr(digits)) {
		int first = 1;
		int i;
		int num_digits = strlen(digits);
		switch_stream_handle_t stream = { 0 };

		iks *interpretation_node = iks_insert(result, "interpretation");
		iks *input_node = iks_insert(interpretation_node, "input");
		iks *instance_node = iks_insert(interpretation_node, "instance");
		iks_insert_attrib(input_node, "mode", "dtmf");
		iks_insert_attrib(input_node, "confidence", "100");

		SWITCH_STANDARD_STREAM(stream);
		for (i = 0; i < num_digits; i++) {
			if (isdtmf(digits[i])) {
				if (first) {
					stream.write_function(&stream, "%c", digits[i]);
					first = 0;
				} else {
					stream.write_function(&stream, " %c", digits[i]);
				}
			}
		}
		iks_insert_cdata(input_node, stream.data, strlen(stream.data));

		if (zstr(interpretation)) {
			iks_insert_cdata(instance_node, stream.data, strlen(stream.data));
		} else {
			iks_insert_cdata(instance_node, interpretation, strlen(interpretation));
		}
		switch_safe_free(stream.data);
	}
	return result;
}

/**
 * Initialize NLSML parser.  This function is not thread safe.
 */
int nlsml_init(void)
{
	if (globals.init) {
		return 1;
	}

	globals.init = SWITCH_TRUE;
	switch_core_new_memory_pool(&globals.pool);
	switch_core_hash_init(&globals.tag_defs);

	add_root_tag_def("result", process_attribs_ignore, process_cdata_ignore, "interpretation");
	add_tag_def("interpretation", process_attribs_ignore, process_cdata_ignore, "input,model,xf:model,instance,xf:instance");
	add_tag_def("input", process_attribs_ignore, process_cdata_match, "input,nomatch,noinput");
	add_tag_def("noinput", process_noinput, process_cdata_bad, "");
	add_tag_def("nomatch", process_nomatch, process_cdata_ignore, "");
	add_tag_def("model", process_attribs_ignore, process_cdata_ignore, "ANY");
	add_tag_def("xf:model", process_attribs_ignore, process_cdata_ignore, "ANY");
	add_tag_def("instance", process_attribs_ignore, process_cdata_ignore, "ANY");
	add_tag_def("xf:instance", process_attribs_ignore, process_cdata_ignore, "ANY");
	add_tag_def("ANY", process_attribs_ignore, process_cdata_ignore, "ANY");

	return 1;
}

/**
 * Destruction of NLSML parser environment
 */
void nlsml_destroy(void)
{
	if (globals.init) {
		if (globals.tag_defs) {
			switch_core_hash_destroy(&globals.tag_defs);
			globals.tag_defs = NULL;
		}
		if (globals.pool) {
			switch_core_destroy_memory_pool(&globals.pool);
			globals.pool = NULL;
		}
		globals.init = SWITCH_FALSE;
	}
}

/* For Emacs:
 * Local Variables:
 * mode:c
 * indent-tabs-mode:t
 * tab-width:4
 * c-basic-offset:4
 * End:
 * For VIM:
 * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet
 */