/* SPDX-License-Identifier: copyleft-next-0.3.1 */
/* Copyright 2024 Kim Kuparinen < kimi.h.kuparinen@gmail.com > */

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

#include <fwd/lower.h>
#include <fwd/scope.h>
#include <fwd/vec.h>

struct state {
	long indent;
};

static void increase_indent(struct state *state)
{
	state->indent++;
}

static void decrease_indent(struct state *state)
{
	state->indent--;
}

static void indent(struct state *state)
{
	for (long i = 0; i < state->indent; ++i)
		putchar(' ');
}

static int lower_var(struct ast *expr);

static int lower_expr(struct state *state, struct ast *expr);
static int lower_block(struct state *state, struct ast *block);
static int lower_closure(struct state *state, struct ast *closure);
static int lower_statement(struct state *state, struct ast *stmt);

static int lower_type(struct type *type);
static int lower_types(struct type *types);

static int lower_binop(struct state *state, struct ast *binop)
{
	printf("(");
	if (lower_expr(state, binop_left(binop)))
		return -1;

	switch (binop->k) {
	case AST_ADD:   printf(" + "); break;
	case AST_SUB:   printf(" - "); break;
	case AST_MUL:   printf(" * "); break;
	case AST_DIV:   printf(" / "); break;
	case AST_REM:   printf(" %% "); break;
	case AST_LSHIFT:        printf(" << "); break;
	case AST_RSHIFT:        printf(" >> "); break;
	default:
		internal_error("missing binop lowering");
		return -1;
	}

	if (lower_expr(state, binop_right(binop)))
		return -1;

	printf(")");
	return 0;
}

static int lower_comparison(struct state *state, struct ast *comp)
{
	printf("(");
	if (lower_expr(state, comparison_left(comp)))
		return -1;

	switch (comp->k) {
	case AST_LT: printf(" < "); break;
	case AST_GT: printf(" > "); break;
	case AST_LE: printf(" <= "); break;
	case AST_GE: printf(" <= "); break;
	case AST_NE: printf(" != "); break;
	case AST_EQ: printf(" == "); break;
	default:
		internal_error("missing comparison lowering");
		return -1;
	}

	if (lower_expr(state, comparison_right(comp)))
		return -1;

	printf(")");
	return 0;
}

static int lower_exprs(struct state *state, struct ast *exprs)
{
	if (!exprs)
		return 0;

	if (lower_expr(state, exprs))
		return -1;

	foreach_node(expr, exprs->n) {
		printf(", ");
		if (lower_expr(state, expr))
			return -1;
	}

	return 0;
}

static int lower_type_construct(struct type *type)
{
	printf("%s", tconstruct_id(type));
	printf("<");

	if (lower_types(tconstruct_args(type)))
		return -1;

	printf(">");
	return 0;
}

static int lower_type_callable(struct type *type)
{
	printf("std::function<void(");

	if (lower_types(tcallable_args(type)))
		return -1;

	printf(")>");
	return 0;
}

static int lower_type_ref(struct type *type)
{
	if (lower_type(tref_base(type)))
		return -1;

	printf("&");
	return 0;
}

static int lower_type_ptr(struct type *type)
{
	/* would I need parentheses in some cases? */
	if (lower_type(tptr_base(type)))
		return -1;

	printf("*");
	return 0;
}

static int lower_type(struct type *type)
{
	switch (type->k) {
	case TYPE_ID: printf("%s", tid_str(type)); return 0;
	case TYPE_CONSTRUCT: return lower_type_construct(type);
	case TYPE_CALLABLE: return lower_type_callable(type);
	case TYPE_REF: return lower_type_ref(type);
	case TYPE_PTR: return lower_type_ptr(type);
	default:
		internal_error("missing type lowering");
		return -1;
	}

	return 0;
}

static int lower_types(struct type *types)
{
	if (!types)
		return 0;

	if (lower_type(types))
		return -1;

	foreach_type(type, types->n) {
		printf(", ");
		if (lower_type(type))
			return -1;
	}

	return 0;
}

static int lower_init(struct state *state, struct ast *init)
{
	printf("%s", init_id(init));

	if (init_args(init)) {
		printf("<");
		if (lower_types(init_args(init)))
			return -1;

		printf(">");
	}

	printf("{");

	if (lower_exprs(state, init_body(init)))
		return -1;

	printf("}");
	return 0;
}

static int lower_unop(struct state *state, struct ast *expr)
{
	switch (expr->k) {
	case AST_LNOT:  printf("-"); break;
	case AST_NOT:   printf("~"); break;
	case AST_NEG:   printf("-"); break;
	default:
		internal_error("missing unop lowering");
		return -1;
	}

	return lower_expr(state, unop_expr(expr));
}

static int lower_expr(struct state *state, struct ast *expr)
{
	if (is_unop(expr))
		return lower_unop(state, expr);

	if (is_binop(expr))
		return lower_binop(state, expr);

	if (is_comparison(expr))
		return lower_comparison(state, expr);

	switch (expr->k) {
	case AST_ID:            printf("%s", id_str(expr)); break;
	case AST_CONST_INT:     printf("%lld", int_val(expr)); break;
	case AST_CONST_FLOAT:   printf("%f", float_val(expr)); break;
	case AST_CONST_BOOL:    printf("%s", bool_val(expr) ? "true" : "false");
		break;
	case AST_CONST_STR:     printf("\"%s\"", str_val(expr)); break;
	case AST_CONST_CHAR:    printf("'%c'", (char)char_val(expr)); break;
	case AST_INIT:          return lower_init(state, expr);
	case AST_CLOSURE:       return lower_closure(state, expr);
	default:
		internal_error("missing expr lowering");
		return -1;
	}

	return 0;
}

static int lower_move(struct state *state, struct ast *move)
{
	if (move->k == AST_ID) {
		/** @todo once I start messing about with references, moves
		 * should only be outputted for parameters that take ownership
		 */
		printf("move(%s)", id_str(move));
		return 0;
	}

	return lower_expr(state, move);
}

static int lower_moves(struct state *state, struct ast *moves)
{
	if (!moves)
		return 0;

	if (lower_move(state, moves))
		return -1;

	foreach_node(move, moves->n) {
		printf(", ");
		if (lower_move(state, move))
			return -1;
	}

	return 0;
}

static int lower_call(struct state *state, struct ast *call)
{
	if (lower_expr(state, call_expr(call)))
		return -1;

	printf("(");

	if (lower_moves(state, call_args(call)))
		return -1;

	printf(");\n");
	return 0;
}

static int lower_let(struct state *state, struct ast *let)
{
	if (lower_var(let_var(let)))
		return -1;

	printf(" = ");

	if (lower_expr(state, let_expr(let)))
		return -1;

	printf(";\n");
	return 0;
}

static int lower_if(struct state *state, struct ast *stmt)
{
	printf("if (");
	if (lower_expr(state, if_cond(stmt)))
		return -1;

	printf(") ");

	if (lower_block(state, if_body(stmt)))
		return -1;

	if (!if_else(stmt))
		return 0;

	printf(" else ");
	if (lower_block(state, if_else(stmt)))
		return -1;

	printf("\n");
	return 0;
}

static int lower_statement(struct state *state, struct ast *stmt)
{
	switch (stmt->k) {
	case AST_LET:   return lower_let(state, stmt);
	case AST_CALL:  return lower_call(state, stmt);
	case AST_IF:    return lower_if(state, stmt);
	default:
		internal_error("missing statement lowering");
		return -1;
	}

	return 0;
}

static int lower_block(struct state *state, struct ast *block)
{
	printf("{\n");
	increase_indent(state);

	foreach_node(stmt, block_body(block)) {
		indent(state);

		if (lower_statement(state, stmt))
			return -1;
	}

	decrease_indent(state);

	indent(state);
	printf("}");
	return 0;
}

static int lower_var(struct ast *var)
{
	if (lower_type(var_type(var)))
		return -1;

	printf(" %s", var_id(var));
	return 0;
}

static int lower_vars(struct ast *vars)
{
	if (!vars)
		return 0;

	if (lower_var(vars))
		return -1;

	foreach_node(var, vars->n) {
		printf(", ");
		if (lower_var(var))
			return -1;
	}

	return 0;
}

static int lower_closure(struct state *state, struct ast *closure)
{
	printf("[&](");
	if (lower_vars(closure_bindings(closure)))
		return -1;

	printf(")");

	if (lower_block(state, closure_body(closure)))
		return -1;

	return 0;
}

static int lower_proto(struct ast *proc)
{
	if (strcmp("main", proc_id(proc)) == 0)
		printf("int ");
	else
		printf("void ");

	printf("%s(", proc_id(proc));

	if (lower_vars(proc_params(proc)))
		return -1;

	printf(");\n\n");
	return 0;
}

static int lower_proc(struct ast *proc)
{
	if (strcmp("main", proc_id(proc)) == 0)
		printf("int ");
	else
		printf("void ");

	printf("%s(", proc_id(proc));

	if (lower_vars(proc_params(proc)))
		return -1;

	printf(")\n");

	struct state state = {0};
	if (lower_block(&state, proc_body(proc)))
		return -1;

	printf("\n\n");
	return 0;
}

int lower(struct scope *root)
{
	printf("#include <fwdlib.hpp>\n");

	foreach_visible(visible, root->symbols) {
		struct ast *proc = visible->node;
		assert(proc->k == AST_PROC_DEF);
		if (lower_proto(proc))
			return -1;
	}

	foreach_visible(visible, root->symbols) {
		struct ast *proc = visible->node;
		if (lower_proc(proc))
			return -1;
	}

	return 0;
}