/**********************************************************/
/*  apimagic: cparser-based API normalization utility     */
/*  Copyright (C) 2015--2021  SysDeer Technologies, LLC   */
/*  Released under GPLv2 and GPLv3; see COPYING.APIMAGIC. */
/**********************************************************/

#include <cparser/ast/ast_t.h>
#include <cparser/ast/entity_t.h>
#include <cparser/ast/symbol_t.h>

#include <apimagic/apimagic.h>

static const struct amgc_entity * enumval_vector_entity(
	const struct amgc_unit_ctx *	uctx,
	const union entity_t *		entity)
{
	const struct amgc_entity * aentity;

	aentity = uctx->entities->enumvals;

	for (; aentity->entity; aentity++)
		if (aentity->entity == entity)
			return aentity;

	return 0;
}

static int enumval_cmp(const void * ptra, const void * ptrb)
{
	struct amgc_entity * entitya = (struct amgc_entity *)ptra;
	struct amgc_entity * entityb = (struct amgc_entity *)ptrb;

	if (entitya->enumval == entityb->enumval)
		return (strcmp(
				entitya->altname
					? entitya->altname
					: entitya->entity->base.symbol->string,
				entityb->altname
					? entityb->altname
					: entityb->entity->base.symbol->string));
	else if ((entitya->enumval <= -128) && (entityb->enumval >= 0))
		return 1;
	else if ((entityb->enumval <= -128) && (entitya->enumval >= 0))
		return -1;
	else if ((entitya->enumval < entityb->enumval)
			&& (entitya->enumval > -128)
			&& (entityb->enumval > -128))
		return -1;
	else
		return 1;
}

int amgc_get_enum_members(
	const struct amgc_unit_ctx *	uctx,
	const union entity_t *		penum,
	struct amgc_entity **		pmembers)
{
	int				nmembers;
	struct amgc_entity *		buffer;
	struct amgc_entity *		pentity;
	const struct amgc_entity *	aentity;
	const union entity_t *		entity;

	if (penum->base.kind != ENTITY_ENUM)
		return -1;

	entity	= penum->enume.first_value;
	nmembers= 0;

	for (; entity && (entity->base.kind == ENTITY_ENUM_VALUE); ) {
		if (!(aentity = enumval_vector_entity(uctx,entity)))
			return -1;

		if (!aentity->fexclude)
			nmembers++;

		entity = entity->base.next;
	}

	/* use first element as a guard */
	if (!(buffer = calloc(1+nmembers+1,sizeof(*buffer))))
		return -1;

	pentity = &buffer[1];
	entity	= penum->enume.first_value;

	for (; entity && (entity->base.kind == ENTITY_ENUM_VALUE); ) {
		aentity = enumval_vector_entity(uctx,entity);

		if (!aentity->fexclude)
			memcpy(pentity++,aentity,sizeof(*pentity));

		entity = entity->base.next;
	}

	*pmembers = &buffer[1];
	qsort(*pmembers,nmembers,sizeof(struct amgc_entity),enumval_cmp);

	return 0;
}

void amgc_free_enum_members(struct amgc_entity * members)
{
	/* first element is a guard */
	if (members)
		free(--members);
}