/*
 * Copyright (c) Camden Dixie O'Brien
 * SPDX-License-Identifier: AGPL-3.0-only
 */

#include "desugar.h"

#include <assert.h>
#include <stdlib.h>
#include <string.h>

static bool desugar_class(regex_term_t *term)
{
	if (term->class.negated)
		return false;

	const int count = term->class.count;
	regex_sequence_t *alternatives
	    = malloc(count * sizeof(regex_sequence_t));
	if (NULL == alternatives)
		return false;

	for (int i = 0; i < count; ++i) {
		regex_term_t *terms = malloc(sizeof(regex_term_t));
		terms[0].quantifier = REGEX_QUANTIFIER_NONE;
		terms[0].type = REGEX_TERM_LITERAL;
		terms[0].literal = term->class.contents[i];
		alternatives[i].count = alternatives[i].capacity = 1;
		alternatives[i].contents = terms;
	}

	regex_class_free(&term->class);
	term->type = REGEX_TERM_SUBEXPR;
	term->subexpr.count = term->subexpr.capacity = count;
	term->subexpr.contents = alternatives;

	return true;
}

static bool deep_copy_term(regex_term_t *dst, regex_term_t *src);

static bool deep_copy_sequence(regex_sequence_t *dst, regex_sequence_t *src)
{
	dst->count = dst->capacity = src->count;
	dst->contents = malloc(dst->capacity * sizeof(regex_term_t));
	if (NULL == dst->contents)
		return false;

	for (int i = 0; i < dst->count; ++i)
		assert(deep_copy_term(&dst->contents[i], &src->contents[i]));

	return true;
}

static bool deep_copy_term(regex_term_t *dst, regex_term_t *src)
{
	assert(REGEX_TERM_WILDCARD != src->type);
	assert(REGEX_TERM_CLASS != src->type);

	memcpy(dst, src, sizeof(regex_term_t));
	if (REGEX_TERM_SUBEXPR == src->type) {
		dst->subexpr.capacity = src->subexpr.count;
		dst->subexpr.contents
		    = malloc(dst->subexpr.capacity * sizeof(regex_sequence_t));
		if (NULL == dst->subexpr.contents)
			return false;

		for (int i = 0; i < dst->subexpr.count; ++i) {
			assert(deep_copy_sequence(
			    &dst->subexpr.contents[i], &src->subexpr.contents[i]));
		}
	}

	return true;
}

static bool desugar_plus(regex_term_t *term)
{
	regex_sequence_t *alternatives = malloc(sizeof(regex_sequence_t));
	if (NULL == alternatives)
		return false;
	alternatives[0].count = alternatives[0].capacity = 2;
	alternatives[0].contents = malloc(2 * sizeof(regex_term_t));
	if (NULL == alternatives[0].contents)
		return false;

	memcpy(&alternatives[0].contents[0], term, sizeof(regex_term_t));
	if (!deep_copy_term(&alternatives[0].contents[1], term))
		return false;
	alternatives[0].contents[0].quantifier = REGEX_QUANTIFIER_NONE;
	alternatives[0].contents[1].quantifier = REGEX_QUANTIFIER_STAR;

	term->quantifier = REGEX_QUANTIFIER_NONE;
	term->type = REGEX_TERM_SUBEXPR;
	term->subexpr.count = term->subexpr.capacity = 1;
	term->subexpr.contents = alternatives;

	return true;
}

static bool desugar_qmark(regex_term_t *term)
{
	regex_sequence_t *alternatives = malloc(2 * sizeof(regex_sequence_t));
	if (NULL == alternatives)
		return false;

	alternatives[0].count = alternatives[0].capacity = 1;
	alternatives[0].contents = malloc(sizeof(regex_term_t));
	if (NULL == alternatives[0].contents)
		return false;
	alternatives[0].contents[0].quantifier = REGEX_QUANTIFIER_NONE;
	alternatives[0].contents[0].type = REGEX_TERM_EMPTY;

	alternatives[1].count = alternatives[0].capacity = 1;
	alternatives[1].contents = malloc(sizeof(regex_term_t));
	if (NULL == alternatives[1].contents)
		return false;
	memcpy(&alternatives[1].contents[0], term, sizeof(regex_term_t));
	alternatives[1].contents[0].quantifier = REGEX_QUANTIFIER_NONE;

	term->quantifier = REGEX_QUANTIFIER_NONE;
	term->type = REGEX_TERM_SUBEXPR;
	term->subexpr.count = term->subexpr.capacity = 2;
	term->subexpr.contents = alternatives;

	return true;
}

static bool desugar_term(regex_term_t *term)
{
	switch (term->type) {
	case REGEX_TERM_WILDCARD:
		return false;
	case REGEX_TERM_CLASS:
		if (!desugar_class(term))
			return false;
		break;

	case REGEX_TERM_LITERAL:
	case REGEX_TERM_SUBEXPR:
	case REGEX_TERM_EMPTY:
		break;
	}

	switch (term->quantifier) {
	case REGEX_QUANTIFIER_PLUS:
		if (!desugar_plus(term))
			return false;
		break;
	case REGEX_QUANTIFIER_QMARK:
		if (!desugar_qmark(term))
			return false;
		break;
	case REGEX_QUANTIFIER_NONE:
	case REGEX_QUANTIFIER_STAR:
		break;
	}

	return true;
}

bool desugar_regex(regex_t *regex)
{
	for (int i = 0; i < regex->count; ++i) {
		for (int j = 0; j < regex->contents[i].count; ++j) {
			if (!desugar_term(&regex->contents[i].contents[j]))
				return false;
		}
	}
	return true;
}