#include <errno.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <limits.h>
#include <stdlib.h>

#include <lyn/lyn.h>
#include <lyn/ast.h>
#include <lyn/parser.h>
#include <lyn/debug.h>

static int eval_group(struct lyn *lyn, struct lyn_value value)
{
	fprintf(lyn->output, "((lambda () (begin");

	lyn->depth++;
	foreach_vec(gi, value.args) {
		fprintf(lyn->output, "\n%*s(", 2 * lyn->depth, " ");
		struct lyn_value arg = lyn_at(value.args, gi);
		if (lyn_eval(lyn, arg))
			return -1;

		fprintf(lyn->output, ")");
	}
	fprintf(lyn->output, "\n%*s)))", 2 * lyn->depth, " ");
	lyn->depth--;

	return 0;
}

static int eval_apply(struct lyn *lyn, struct lyn_value value)
{
	fprintf(lyn->output, "(");
	foreach_vec(ai, value.args) {
		struct lyn_value arg = lyn_at(value.args, ai);
		if (lyn_eval(lyn, arg))
			return -1;
	}

	fprintf(lyn->output, ")");
	return 0;
}

static int eval_cmd(struct lyn *lyn, struct lyn_value value)
{
	foreach_vec(ci, value.args) {
		struct lyn_value arg = lyn_at(value.args, ci);
		if (lyn_eval(lyn, arg))
			return -1;

		/* don't print a space after the last argument */
		if (ci < vec_len(&value.args) - 1)
			fprintf(lyn->output, " ");
	}
	return 0;
}

static int eval_str(struct lyn *lyn, struct lyn_value value)
{
	fprintf(lyn->output, "%s", value.s);
	return 0;
}

static int eval_int(struct lyn *lyn, struct lyn_value value)
{
	fprintf(lyn->output, "%lld", value.i);
	return 0;
}

static int eval_float(struct lyn *lyn, struct lyn_value value)
{
	fprintf(lyn->output, "%f", value.d);
	return 0;
}

static int eval_id(struct lyn *lyn, struct lyn_value value)
{
	fprintf(lyn->output, "%s", value.s);
	return 0;
}

int lyn_eval(struct lyn *lyn, struct lyn_value value)
{
	switch (value.kind) {
	case LYN_GROUP: return eval_group(lyn, value);
	case LYN_APPLY: return eval_apply(lyn, value);
	case LYN_FLOAT: return eval_float(lyn, value);
	case LYN_STR: return eval_str(lyn, value);
	case LYN_CMD: return eval_cmd(lyn, value);
	case LYN_INT: return eval_int(lyn, value);
	case LYN_ID: return eval_id(lyn, value);
	default: error("unhandled case during 'eval'"); break;
	}

	return -1;
}

static void destroy_val(struct lyn_value value);

static void destroy_group(struct lyn_value value)
{
	foreach_vec(gi, value.args) {
		struct lyn_value arg = lyn_at(value.args, gi);
		destroy_val(arg);
	}

	vec_destroy(&value.args);
}

static void destroy_apply(struct lyn_value value)
{
	foreach_vec(ai, value.args) {
		struct lyn_value arg = lyn_at(value.args, ai);
		destroy_val(arg);
	}

	vec_destroy(&value.args);
}

static void destroy_cmd(struct lyn_value value)
{
	foreach_vec(ci, value.args) {
		struct lyn_value arg = lyn_at(value.args, ci);
		destroy_val(arg);
	}

	vec_destroy(&value.args);
}

static void destroy_str(struct lyn_value value)
{
	free(value.s);
}

static void destroy_id(struct lyn_value value)
{
	free(value.s);
}

static void destroy_val(struct lyn_value value)
{
	switch (value.kind) {
	case LYN_GROUP: return destroy_group(value);
	case LYN_APPLY: return destroy_apply(value);
	case LYN_STR: return destroy_str(value);
	case LYN_CMD: return destroy_cmd(value);
	case LYN_ID: return destroy_id(value);
	case LYN_INT: return; /* nothing to do */
	default: error("unhandled case during 'destroy'"); break;
	}
}

int lyn_eval_str(struct lyn *lyn, const char *name, const char *str)
{
	struct parser *p = create_parser();
	if (!p)
		return -1;

	parse(p, name, str);
	struct lyn_value ast = p->tree;
	bool failed = p->failed;
	destroy_parser(p);

	if (failed)
		return -1;

	ast_dump(0, ast);

	lyn->output = fopen("/tmp/output.scm", "w");
	if (!lyn->output) {
		error("failed opening output file\n");
		return -1;
	}

	fprintf(lyn->output, "(define-syntax-rule (expand expr) expr)\n");
	fprintf(lyn->output, "(define (get expr) expr)\n");

	int ret = 0;
	foreach_vec(ii, ast.args) {
		fprintf(lyn->output, "(");
		struct lyn_value v = lyn_at(ast.args, ii);
		if ((ret = lyn_eval(lyn, v)))
			break;

		fprintf(lyn->output, ")\n");
	}
	fclose(lyn->output);
	destroy_val(ast);

	if (ret)
		return ret;

	return system("guile /tmp/output.scm");
}

/**
 * Read whole file into a buffer and return pointer to buffer.
 * Possibly kind of silly to have both \p file and \p f.
 * Apparently there's no standardized way to get the file name of a
 * file pointer.
 *
 * @param file Name of file to read.
 * @param f File pointer.
 * @return Pointer to buffer with file contents.
 */
static char *read_file(const char *file, FILE *f)
{
	fseek(f, 0, SEEK_END);
	/** @todo check how well standardized this actually is */
	long s = ftell(f);
	if (s == LONG_MAX) {
		error("%s might be a directory", file);
		return NULL;
	}

	fseek(f, 0, SEEK_SET);

	char *buf = malloc((size_t)(s + 1));
	if (!buf)
		return NULL;

	fread(buf, (size_t)(s + 1), 1, f);
	/* remember terminating null */
	buf[s] = 0;
	return buf;
}

int lyn_eval_file(struct lyn *lyn, const char *fname)
{
	FILE *f = fopen(fname, "rb");
	if (!f) {
		error("failed opening %s: %s\n", fname, strerror(errno));
		return -1;
	}

	char *buf = read_file(fname, f);
	fclose(f);

	if (!buf)
		return -1;

	int ret = lyn_eval_str(lyn, fname, buf);
	free(buf);

	return ret;
}

struct lyn lyn_create()
{
	return (struct lyn){};
}

void lyn_destroy(struct lyn *lyn)
{
	(void)lyn;
}