/*
 * 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 void deep_copy_term(parse_term_t *dst, parse_term_t *src);

static void deep_copy_sequence(parse_sequence_t *dst, parse_sequence_t *src)
{
	dst->count = dst->capacity = src->count;
	dst->contents = malloc(dst->capacity * sizeof(parse_term_t));
	for (int i = 0; i < dst->count; ++i)
		deep_copy_term(&dst->contents[i], &src->contents[i]);
}

static void deep_copy_term(parse_term_t *dst, parse_term_t *src)
{
	assert(PARSE_TERM_WILDCARD != src->type);
	assert(PARSE_TERM_CLASS != src->type);

	memcpy(dst, src, sizeof(parse_term_t));
	if (PARSE_TERM_SUBEXPR == src->type) {
		dst->subexpr.capacity = src->subexpr.count;
		dst->subexpr.contents
		    = malloc(dst->subexpr.capacity * sizeof(parse_sequence_t));
		for (int i = 0; i < dst->subexpr.count; ++i) {
			deep_copy_sequence(
			    &dst->subexpr.contents[i], &src->subexpr.contents[i]);
		}
	}
}

static void desugar_plus(parse_term_t *term)
{
	parse_sequence_t *alternatives = malloc(sizeof(parse_sequence_t));
	alternatives[0].count = alternatives[0].capacity = 2;
	alternatives[0].contents = malloc(2 * sizeof(parse_term_t));

	memcpy(&alternatives[0].contents[0], term, sizeof(parse_term_t));
	deep_copy_term(&alternatives[0].contents[1], term);
	alternatives[0].contents[0].quantifier = PARSE_QUANTIFIER_NONE;
	alternatives[0].contents[1].quantifier = PARSE_QUANTIFIER_STAR;

	term->quantifier = PARSE_QUANTIFIER_NONE;
	term->type = PARSE_TERM_SUBEXPR;
	term->subexpr.count = term->subexpr.capacity = 1;
	term->subexpr.contents = alternatives;
}

static void desugar_qmark(parse_term_t *term)
{
	parse_sequence_t *alternatives = malloc(2 * sizeof(parse_sequence_t));

	alternatives[0].count = alternatives[0].capacity = 1;
	alternatives[0].contents = malloc(sizeof(parse_term_t));
	alternatives[0].contents[0].quantifier = PARSE_QUANTIFIER_NONE;
	alternatives[0].contents[0].type = PARSE_TERM_EMPTY;

	alternatives[1].count = alternatives[0].capacity = 1;
	alternatives[1].contents = malloc(sizeof(parse_term_t));
	memcpy(&alternatives[1].contents[0], term, sizeof(parse_term_t));
	alternatives[1].contents[0].quantifier = PARSE_QUANTIFIER_NONE;

	term->quantifier = PARSE_QUANTIFIER_NONE;
	term->type = PARSE_TERM_SUBEXPR;
	term->subexpr.count = term->subexpr.capacity = 2;
	term->subexpr.contents = alternatives;
}

static void desugar_term(parse_term_t *term)
{
	switch (term->quantifier) {
	case PARSE_QUANTIFIER_PLUS:
		desugar_plus(term);
		break;
	case PARSE_QUANTIFIER_QMARK:
		desugar_qmark(term);
		break;
	case PARSE_QUANTIFIER_NONE:
	case PARSE_QUANTIFIER_STAR:
		break;
	}
}

void desugar_regex(parse_tree_t *regex)
{
	for (int i = 0; i < regex->count; ++i) {
		for (int j = 0; j < regex->contents[i].count; ++j)
			desugar_term(&regex->contents[i].contents[j]);
	}
}