/**

 * @file annot.c

 * @brief Implementation of the annotation set object.

 * @class ln_annot annot.h

 *//*

 * Copyright 2011 by Rainer Gerhards and Adiscon GmbH.

 *

 * Modified by Pavel Levshin (pavel@levshin.spb.ru) in 2013

 *

 * This file is part of liblognorm.

 *

 * 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 Sannott, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * A copy of the LGPL v2.1 can be found in the file "COPYING" in this distribution.

 */

#include "config.h"

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <assert.h>

#include <ctype.h>

#include <libestr.h>

#include "lognorm.h"

#include "samp.h"

#include "annot.h"

#include "internal.h"

ln_annotSet*

ln_newAnnotSet(ln_ctx ctx)

{

	ln_annotSet *as;

	if((as = calloc(1, sizeof(struct ln_annotSet_s))) == NULL)

		goto done;

	as->ctx = ctx;

done:	return as;

}

void

ln_deleteAnnotSet(ln_annotSet *as)

{

	ln_annot *node, *nextnode;

	if(as == NULL)

		goto done;

	for(node = as->aroot; node != NULL; node = nextnode) {

		nextnode = node->next;

		ln_deleteAnnot(node);

	}

	free(as);

done:	return;

}

ln_annot*

ln_findAnnot(ln_annotSet *as, es_str_t *tag)

{

	ln_annot *annot;

	if(as == NULL) {

		annot = NULL;

		goto done;

	}

	for(  annot = as->aroot

	    ; annot != NULL && es_strcmp(annot->tag, tag)

	    ; annot = annot->next) {

		; /* do nothing, just search... */

	}

done:	return annot;

}

/**

 * Combine two annotations.

 * @param[in] annot currently existing and surviving annotation

 * @param[in] add   annotation to be added. This will be destructed

 *                  as part of the process.

 * @returns 0 if ok, something else otherwise

 */

static int

ln_combineAnnot(ln_annot *annot, ln_annot *add)

{

	int r = 0;

	ln_annot_op *op, *nextop;

	for(op = add->oproot; op != NULL; op = nextop) {

		CHKR(ln_addAnnotOp(annot, op->opc, op->name, op->value));

		nextop = op->next;

		free(op);

	}

	es_deleteStr(add->tag);

	free(add);

done:	return r;

}

int

ln_addAnnotToSet(ln_annotSet *as, ln_annot *annot)

{

	int r = 0;

	ln_annot *aexist;

	assert(annot->tag != NULL);

	aexist = ln_findAnnot(as, annot->tag);

	if(aexist == NULL) {

		/* does not yet exist, simply store new annot */

		annot->next = as->aroot;

		as->aroot = annot;

	} else { /* annotation already exists, combine */

		r = ln_combineAnnot(aexist, annot);

	}

	return r;

}

ln_annot*

ln_newAnnot(es_str_t *tag)

{

	ln_annot *annot;

	if((annot = calloc(1, sizeof(struct ln_annot_s))) == NULL)

		goto done;

	annot->tag = tag;

done:	return annot;

}

void

ln_deleteAnnot(ln_annot *annot)

{

	ln_annot_op *op, *nextop;

	if(annot == NULL)

		goto done;

	es_deleteStr(annot->tag);

	for(op = annot->oproot; op != NULL; op = nextop) {

		es_deleteStr(op->name);

		if(op->value != NULL)

			es_deleteStr(op->value);

		nextop = op->next;

		free(op);

	}

	free(annot);

done:	return;

}

int

ln_addAnnotOp(ln_annot *annot, ln_annot_opcode opc, es_str_t *name, es_str_t *value)

{

	int r = -1;

	ln_annot_op *node;

	if((node = calloc(1, sizeof(struct ln_annot_op_s))) == NULL)

		goto done;

	node->opc = opc;

	node->name = name;

	node->value = value;

	if(annot->oproot != NULL) {

		node->next = annot->oproot;

	}

	annot->oproot = node;

	r = 0;

done:	return r;

}

/* annotate the event with a specific tag. helper to keep code

 * small and easy to follow.

 */

static inline int

ln_annotateEventWithTag(ln_ctx ctx, struct json_object *json, es_str_t *tag)

{

	int r=0;

	ln_annot *annot;

	ln_annot_op *op;

	struct json_object *field;

	char *cstr;

	if (NULL == (annot = ln_findAnnot(ctx->pas, tag)))

		goto done;

	for(op = annot->oproot ; op != NULL ; op = op->next) {

		if(op->opc == ln_annot_ADD) {

			CHKN(cstr = ln_es_str2cstr(&op->value));

			CHKN(field = json_object_new_string(cstr));

			CHKN(cstr = ln_es_str2cstr(&op->name));

			json_object_object_add(json, cstr, field);

		} else {

			// TODO: implement

		}

	}

done: 	return r;

}

int

ln_annotate(ln_ctx ctx, struct json_object *json, struct json_object *tagbucket)

{

	int r = 0;

	es_str_t *tag;

	struct json_object *tagObj;

	const char *tagCstr;

	int i;

	ln_dbgprintf(ctx, "ln_annotate called [aroot=%p]", ctx->pas->aroot);

	/* shortcut: terminate immediately if nothing to do... */

	if(ctx->pas->aroot == NULL)

		goto done;

	/* iterate over tagbucket */

	for (i = json_object_array_length(tagbucket) - 1; i >= 0; i--) {

		CHKN(tagObj = json_object_array_get_idx(tagbucket, i));

		CHKN(tagCstr = json_object_get_string(tagObj));

		ln_dbgprintf(ctx, "ln_annotate, current tag %d, cstr %s", i, tagCstr);

		CHKN(tag = es_newStrFromCStr(tagCstr, strlen(tagCstr)));

		CHKR(ln_annotateEventWithTag(ctx, json, tag));

		es_deleteStr(tag);

	}

done:	return r;

}