/*
 * Copyright (c) 2026 Nakidai Perumenei <nakidai at disroot dot org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "thac.h"

#include <stdio.h>
#include <stdlib.h>


struct val
deref(struct val val, struct scope *scope)
{
	long i;

	if (val.type == VVAR)
	{
		i = findvar(val.name, &scope);
		if (i < 0)
			complain(1, "no such variable: %s", val.name);
		val = scope->vars[i].val;
	}

	return val;
}

struct val
getval(enum val_t t, struct val val, struct scope *scope, int doderef)
{
	if (doderef)
		val = deref(val, scope);
	if (val.type != t)
		complain(1, "expected %s, got %s", valname(t), valname(val.type));
	return val;
}

struct val
copyval(struct val old)
{
	struct val new;
	ulong i;

	new = old;
	if (new.type == VARR)
	{
		new.arr = malloc(sizeof(*new.arr) * new.len);
		if (!new.arr)
			dieno(1, "malloc()");

		for (i = 0; i < new.len; ++i)
			new.arr[i] = copyval(old.arr[i]);
	}

	return new;
}

void
freeval(struct val val)
{
	ulong i;

	if (val.type == VARR)
	{
		for (i = 0; i < val.len; ++i)
			freeval(val.arr[i]);
		free(val.arr);
	}
}

static void
connectarr(struct val arr, ulong single, int arr_to_single)
{
	ulong i;

	for (i = 0; i < arr.len; ++i) switch (arr.arr[i].type)
	{
	break; case VARR:
		connectarr(arr.arr[i], single, arr_to_single);
	break; case VNUM:
		if (arr_to_single)
			addedge(arr.arr[i].num, single);
		else
			addedge(single, arr.arr[i].num);
	break; default: complain(1, "%s can not be connected", valname(arr.arr[i].type));
	}
}

static void
connectarrarr(struct val from, struct val to)
{
	ulong i;

	if (from.len != to.len)
		complain(1, "cannot connect nonisomorphic arrays");

	for (i = 0; i < from.len; ++i)
	{
		if (from.arr[i].type != to.arr[i].type)
			complain(1, "cannot connect nonisomorphic arrays");
		switch (from.arr[i].type)
		{
		break; case VARR: connectarrarr(from.arr[i], to.arr[i]);
		break; case VNUM: addedge(from.arr[i].num, to.arr[i].num);
		break; default: complain(1, "%s can not be connected", valname(from.arr[i].type));
		}
	}
}

struct val
connectval(struct val refl, struct val refr, struct scope *scope)
{
	struct val l, r;

	l = deref(refl, scope);
	r = deref(refr, scope);

	if (l.type == VNUM && r.type == VNUM)
		addedge(r.num, l.num);
	else if (l.type == VARR && r.type == VNUM)
		connectarr(l, r.num, 0);
	else if (l.type == VNUM && r.type == VARR)
		connectarr(r, l.num, 1);
	else if (l.type == VARR && r.type == VARR)
		connectarrarr(r, l);
	else
		complain(1, "cannot connect %s and %s", valname(l.type), valname(r.type));

	if (refr.type != VVAR)
		freeval(r);

	return refl;
}