/*

 * Copyright 2013 Red Hat Inc., Durham, North Carolina.

 * All Rights Reserved.

 *

 * This library 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.1 of the License, or (at your option) any later version.

 *

 * This library 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 library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 *

 * Authors:

 *      Šimon Lukašík

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "oval_definitions_impl.h"

static void _oval_definition_fill_vardef(struct oval_definition *definition, struct oval_string_map *vardef);

static void _oval_criteria_fill_vardef(struct oval_criteria_node *cnode, struct oval_string_map *vardef, const char *definition_id);

static void _oval_test_fill_vardef(struct oval_test *test, struct oval_string_map *vardef, const char *definition_id);

static void _oval_object_fill_vardef(struct oval_object *object, struct oval_string_map *vardef, const char *definition_id);

static void _oval_setobject_fill_vardef(struct oval_setobject *set, struct oval_string_map *vardef, const char *definition_id);

static void _oval_state_fill_vardef(struct oval_state *state, struct oval_string_map *vardef, const char *definition_id);

static void _oval_entity_fill_vardef(struct oval_entity *entity, struct oval_string_map *vardef, const char *definition_id);

static void _vardef_insert(struct oval_string_map *vardef, const char *definition_id, const char *variable_id);

struct oval_string_map *oval_definition_model_build_vardef_mapping(struct oval_definition_model *model)

{

	struct oval_string_map *vardef = oval_string_map_new();

	struct oval_definition_iterator *def_it = oval_definition_model_get_definitions(model);

	while (oval_definition_iterator_has_more(def_it)) {

		struct oval_definition *definition = oval_definition_iterator_next(def_it);

		_oval_definition_fill_vardef(definition, vardef);

	}

	oval_definition_iterator_free(def_it);

	return vardef;

}

void _oval_definition_fill_vardef(struct oval_definition *definition, struct oval_string_map *vardef)

{

	struct oval_criteria_node *cnode = oval_definition_get_criteria(definition);

	if (cnode != NULL)

		_oval_criteria_fill_vardef(cnode, vardef, oval_definition_get_id(definition));

}

void _oval_criteria_fill_vardef(struct oval_criteria_node *cnode, struct oval_string_map *vardef, const char *definition_id)

{

	switch (oval_criteria_node_get_type(cnode)) {

	case OVAL_NODETYPE_CRITERION:{

		struct oval_test *test = oval_criteria_node_get_test(cnode);

		if (test != NULL)

			_oval_test_fill_vardef(test, vardef, definition_id);

		} break;

	case OVAL_NODETYPE_CRITERIA:{

		struct oval_criteria_node_iterator *cnode_it = oval_criteria_node_get_subnodes(cnode);

		if (cnode_it != NULL) {

			while (oval_criteria_node_iterator_has_more(cnode_it)) {

				struct oval_criteria_node *node = oval_criteria_node_iterator_next(cnode_it);

				if (node != NULL)

					_oval_criteria_fill_vardef(node, vardef, definition_id);

			}

			oval_criteria_node_iterator_free(cnode_it);

		}

		} break;

	case OVAL_NODETYPE_EXTENDDEF:{

		struct oval_definition *definition = oval_criteria_node_get_definition(cnode);

		if (definition != NULL) {

			struct oval_criteria_node *node = oval_definition_get_criteria(definition);

			if (node != NULL)

				_oval_criteria_fill_vardef(node, vardef, definition_id);

		}

		} break;

	case OVAL_NODETYPE_UNKNOWN:

	default:

		assert(false);

		break;

	}

}

void _oval_test_fill_vardef(struct oval_test *test, struct oval_string_map *vardef, const char *definition_id)

{

	struct oval_object *object = oval_test_get_object(test);

	if (object != NULL)

		_oval_object_fill_vardef(object, vardef, definition_id);

	struct oval_state_iterator *ste_it = oval_test_get_states(test);

	while (oval_state_iterator_has_more(ste_it)) {

		struct oval_state *state = oval_state_iterator_next(ste_it);

		if (state != NULL)

			_oval_state_fill_vardef(state, vardef, definition_id);

	}

	oval_state_iterator_free(ste_it);

}

void _oval_object_fill_vardef(struct oval_object *object, struct oval_string_map *vardef, const char *definition_id)

{

	struct oval_object_content_iterator *content_it = oval_object_get_object_contents(object);

	while (oval_object_content_iterator_has_more(content_it)) {

		struct oval_object_content *content = oval_object_content_iterator_next(content_it);

		switch (oval_object_content_get_type(content)) {

		case OVAL_OBJECTCONTENT_ENTITY:{

			struct oval_entity *entity = oval_object_content_get_entity(content);

			_oval_entity_fill_vardef(entity, vardef, definition_id);

			} break;

		case OVAL_OBJECTCONTENT_SET:{

			struct oval_setobject *set = oval_object_content_get_setobject(content);

			_oval_setobject_fill_vardef(set, vardef, definition_id);

			} break;

		default:

			break;

		}

	}

	oval_object_content_iterator_free(content_it);

}

void _oval_setobject_fill_vardef(struct oval_setobject *set, struct oval_string_map *vardef, const char *definition_id)

{

	switch (oval_setobject_get_type(set)) {

	case OVAL_SET_AGGREGATE:{

		struct oval_setobject_iterator *subset_it = oval_setobject_get_subsets(set);

		while (oval_setobject_iterator_has_more(subset_it)) {

			struct oval_setobject *subset = oval_setobject_iterator_next(subset_it);

			_oval_setobject_fill_vardef(subset, vardef, definition_id);

		}

		oval_setobject_iterator_free(subset_it);

		} break;

	case OVAL_SET_COLLECTIVE:{

		struct oval_object_iterator *object_it = oval_setobject_get_objects(set);

		while (oval_object_iterator_has_more(object_it)) {

			struct oval_object *object = oval_object_iterator_next(object_it);

			_oval_object_fill_vardef(object, vardef, definition_id);

		}

		oval_object_iterator_free(object_it);

		struct oval_filter_iterator *filter_it = oval_setobject_get_filters(set);

		while (oval_filter_iterator_has_more(filter_it)) {

			struct oval_filter *filter = oval_filter_iterator_next(filter_it);

			struct oval_state *state = oval_filter_get_state(filter);

			_oval_state_fill_vardef(state, vardef, definition_id);

		}

		oval_filter_iterator_free(filter_it);

		} break;

	default:

		break;

	}

}

void _oval_state_fill_vardef(struct oval_state *state, struct oval_string_map *vardef, const char *definition_id)

{

	struct oval_state_content_iterator *content_it = oval_state_get_contents(state);

	while (oval_state_content_iterator_has_more(content_it)) {

		struct oval_state_content *content = oval_state_content_iterator_next(content_it);

		struct oval_entity *entity = oval_state_content_get_entity(content);

		if (entity != NULL)

			_oval_entity_fill_vardef(entity, vardef, definition_id);

	}

	oval_state_content_iterator_free(content_it);

}

void _oval_entity_fill_vardef(struct oval_entity *entity, struct oval_string_map *vardef, const char *definition_id)

{

	if (oval_entity_get_varref_type(entity) == OVAL_ENTITY_VARREF_ATTRIBUTE ||

		oval_entity_get_varref_type(entity) == OVAL_ENTITY_VARREF_ELEMENT) {

		struct oval_variable *variable = oval_entity_get_variable(entity);

		if (variable != NULL)

			_vardef_insert(vardef, definition_id, oval_variable_get_id(variable));

	}

}

void _vardef_insert(struct oval_string_map *vardef, const char *definition_id, const char *variable_id)

{

	struct oval_string_map *def_list = (struct oval_string_map *) oval_string_map_get_value(vardef, variable_id);

	if (def_list == NULL) {

		def_list = oval_string_map_new();

		oval_string_map_put(vardef, variable_id, def_list);

	}

	oval_string_map_put(def_list, definition_id, (void *) "");

}