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

#include <fwd/analyze.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

struct state {
};

static int analyze(struct state *state, struct scope *scope, struct ast *node);
static int analyze_list(struct state *state, struct scope *scope,
                        struct ast *nodes);

static int analyze_type(struct state *state, struct scope *scope,
                        struct type *type);
static int analyze_type_list(struct state *state, struct scope *scope,
                             struct type *types);

static int analyze_proc(struct state *state, struct scope *scope,
                        struct ast *node)
{
	(void)state;
	(void)scope;

	struct scope *proc_scope = create_scope();
	if (!proc_scope) {
		internal_error("failed allocating proc scope");
		return -1;
	}

	scope_add_scope(scope, proc_scope);

	struct state proc_state = {};
	if (analyze_list(&proc_state, proc_scope, proc_params(node)))
		return -1;

	struct type *proc_type = tgen_func_ptr(NULL, node->loc);
	if (!proc_type) {
		internal_error("failed allocating proc type");
		return -1;
	}

	size_t group = 0;
	foreach_node(param, proc_params(node)) {
		if (param->ol == NULL && param->or == NULL)
			group++; /* no opt group */

		if (param->ol == NULL && param->or)
			group++; /* start of new group */

		/* otherwise same or ending group, don't increment */

		param->t->group = group;
		type_append(&proc_type->t0, clone_type(param->t));
	}

	node->t = proc_type;

	return analyze(&proc_state, proc_scope, proc_body(node));
}

static int analyze_unop(struct state *state, struct scope *scope,
                        struct ast *node)
{
	/** @todo check expr is some primitive type */
	struct ast *expr = unop_expr(node);
	if (analyze(state, scope, expr))
		return -1;

	node->t = expr->t;
	return 0;
}

static int analyze_binop(struct state *state, struct scope *scope,
                         struct ast *node)
{
	struct ast *lhs = binop_left(node);
	struct ast *rhs = binop_right(node);

	if (analyze(state, scope, lhs))
		return -1;

	if (analyze(state, scope, rhs))
		return -1;


	if (!types_match(lhs->t, rhs->t)) {
		type_mismatch(scope, node, lhs->t, rhs->t);
		return -1;
	}

	/** @todo check type is some primitive */
	node->t = lhs->t;
	return 0;
}

static int analyze_comparison(struct state *state, struct scope *scope,
                              struct ast *node)
{
	struct ast *lhs = comparison_left(node);
	struct ast *rhs = comparison_right(node);

	if (analyze(state, scope, lhs))
		return -1;

	if (analyze(state, scope, rhs))
		return -1;


	if (!types_match(lhs->t, rhs->t)) {
		type_mismatch(scope, node, lhs->t, rhs->t);
		return -1;
	}

	/** @todo check type is some primitive */
	char *tf = strdup("bool");
	if (!tf) {
		internal_error("failed allocating comparison bool str");
		return -1;
	}

	node->t = tgen_id(tf, node->loc);
	if (!node->t) {
		internal_error("failed allocating comparison bool type");
		free(tf);
		return -1;
	}

	return 0;
}

static int analyze_block(struct state *state, struct scope *scope,
                         struct ast *node)
{
	struct scope *block_scope = create_scope();
	if (!block_scope) {
		internal_error("failed to allocate block scope");
		return -1;
	}

	scope_add_scope(scope, block_scope);
	if (analyze_list(state, block_scope, block_body(node)))
		return -1;

	struct ast *last = ast_last(block_body(node));
	if (last)
		node->t = last->t;
	else
		node->t = tgen_void(node->loc);

	return 0;
}

static int analyze_var(struct state *state, struct scope *scope,
                       struct ast *node)
{
	if (analyze_type(state, scope, var_type(node)))
		return -1;

	node->t = var_type(node);
	return scope_add_var(scope, node);
}

static int analyze_let(struct state *state, struct scope *scope,
                       struct ast *node)
{
	if (analyze(state, scope, let_var(node)))
		return -1;

	if (analyze(state, scope, let_expr(node)))
		return -1;

	struct type *l = (let_var(node))->t;
	struct type *r = (let_expr(node))->t;
	if (!types_match(l, r)) {
		type_mismatch(scope, node, l, r);
		return -1;
	}

	node->t = l;
	return 0;
}

static int analyze_init(struct state *state, struct scope *scope,
                        struct ast *node)
{
	if (analyze_type_list(state, scope, init_args(node)))
		return -1;

	if (analyze(state, scope, init_body(node)))
		return -1;

	/** @todo check that all parameters match, though that requires that the
	 * type is defined in fwd and not in C++, so this might have to wait a
	 * bit */
	node->t = tgen_construct(strdup(init_id(node)), init_args(node),
	                         node->loc);
	if (!node->t) {
		internal_error("failed allocating type for construct");
		return -1;
	}

	return 0;
}

static int analyze_call(struct state *state, struct scope *scope,
                        struct ast *node)
{
	struct ast *expr = call_expr(node);
	if (analyze(state, scope, expr))
		return -1;

	if (!is_callable(expr->t)) {
		semantic_error(scope, node, "expected callable expression");
		return -1;
	}

	struct type *types = callable_types(expr->t);
	struct ast *args = call_args(node);
	if (analyze_list(state, scope, args))
		return -1;

	size_t expected = type_list_len(types);
	size_t got = ast_list_len(args);
	if (expected != got) {
		semantic_error(scope, node, "expected %d params, got %d",
		               expected, got);
		return -1;
	}

	struct type *type = types;
	foreach_node(arg, args) {
		if (!types_match(type, arg->t)) {
			type_mismatch(scope, node, type, arg->t);
			return -1;
		}

		/* clone group info */
		arg->t->group = type->group;
		type = type->n;
	}

	node->t = tgen_void(node->loc);
	if (!node->t) {
		internal_error("failed allocating void type for call");
		return -1;
	}

	return 0;
}

static int analyze_ref(struct state *state, struct scope *scope,
                       struct ast *node)
{
	struct ast *expr = ref_base(node);
	if (analyze(state, scope, expr))
		return -1;

	if (!is_lvalue(expr)) {
		semantic_error(node->scope, node, "trying to reference rvalue");
		return -1;
	}

	struct type *ref = tgen_ref(expr->t, node->loc);
	if (!ref) {
		internal_error("failed allocating ref type");
		return -1;
	}

	node->t = ref;
	return 0;
}

static int analyze_id(struct state *state, struct scope *scope,
                      struct ast *node)
{
	struct ast *found = file_scope_find_symbol(scope, id_str(node));
	if (!found) {
		semantic_error(scope, node, "no symbol named \"%s\"",
		               id_str(node));
		return -1;
	}

	/* kind of hacky, functions are given their type before they've been
	 * analyzed fully, this enables recursion */
	if (!found->t && !ast_flags(found, AST_FLAG_ANALYZED)) {
		assert(found->k == AST_PROC_DEF);
		/* a proc def will use its own state and scope, but pass these
		 * on in case the analysis wants to print errors or something
		 */
		if (analyze(state, scope, found))
			return -1;
	}

	node->t = found->t;
	return 0;
}

static int analyze_closure(struct state *state, struct scope *scope,
                           struct ast *node)
{
	struct scope *closure_scope = create_scope();
	if (!closure_scope) {
		internal_error("failed allocating closure scope");
		return -1;
	}

	scope_add_scope(scope, closure_scope);

	if (analyze_list(state, closure_scope, closure_bindings(node)))
		return -1;

	if (analyze(state, closure_scope, closure_body(node)))
		return -1;

	struct type *callable = NULL;
	if (ast_flags(node, AST_FLAG_NOMOVES))
		callable = tgen_pure_closure(NULL, node->loc);
	else
		callable = tgen_closure(NULL, node->loc);

	if (!callable) {
		internal_error("failed allocating closure type");
		return -1;
	}

	foreach_node(binding, closure_bindings(node)) {
		type_append(&callable->t0, clone_type(binding->t));
	}

	node->t = callable;
	return 0;
}

static int analyze_int(struct state *state, struct scope *scope,
                       struct ast *node)
{
	/** @todo do this properly, very hacky, bad bad bad */
	char *i = strdup("int");
	if (!i) {
		internal_error("failed allocating constant int type string");
		return -1;
	}

	node->t = tgen_id(i, node->loc);
	if (!node->t) {
		internal_error("failed allocating constant int type");
		free(i);
		return -1;
	}

	return 0;
}

static int analyze_str(struct state *state, struct scope *scope,
                       struct ast *node)
{
	/** @todo do this properly, very hacky, bad bad bad */
	char *i = strdup("char");
	if (!i) {
		internal_error("failed allocating constant char type string");
		return -1;
	}

	struct type *ch = tgen_id(i, node->loc);
	if (!ch) {
		internal_error("failed allocating constant char type");
		free(i);
		return -1;
	}

	struct type *str = tgen_ptr(ch, node->loc);
	if (!str) {
		internal_error("failed allocating constant str type");
		return -1;
	}

	node->t = str;
	return 0;
}

static int analyze_if(struct state *state, struct scope *scope,
                      struct ast *node)
{
	if (analyze(state, scope, if_cond(node)))
		return -1;

	if (analyze(state, scope, if_body(node)))
		return -1;

	if (analyze(state, scope, if_else(node)))
		return -1;

	node->t = tgen_void(node->loc);
	if (!node->t) {
		internal_error("failed allocating 'if' void type");
		return -1;
	}

	return 0;
}

static int analyze(struct state *state, struct scope *scope, struct ast *node)
{
	if (!node)
		return 0;

	if (ast_flags(node, AST_FLAG_ANALYZED)) {
		assert(node->t);
		return 0;
	}

	if (ast_flags(node, AST_FLAG_PREANALYZIS)) {
		semantic_error(scope, node, "semantic loop detected");
		return -1;
	}

	ast_set_flags(node, AST_FLAG_PREANALYZIS);

	if (!node->scope)
		node->scope = scope;

	int ret = 0;
	if (is_binop(node)) {
		ret = analyze_binop(state, scope, node);
		goto out;
	}

	if (is_comparison(node)) {
		ret = analyze_comparison(state, scope, node);
		goto out;
	}

	if (is_unop(node)) {
		ret = analyze_unop(state, scope, node);
		goto out;
	}

	switch (node->k) {
	case AST_CLOSURE: ret = analyze_closure(state, scope, node); break;
	case AST_PROC_DEF: ret = analyze_proc(state, scope, node); break;
	case AST_VAR_DEF: ret = analyze_var(state, scope, node); break;
	case AST_BLOCK: ret = analyze_block(state, scope, node); break;
	case AST_INIT: ret = analyze_init(state, scope, node); break;
	case AST_CALL: ret = analyze_call(state, scope, node); break;
	case AST_REF: ret = analyze_ref(state, scope, node); break;
	case AST_LET: ret = analyze_let(state, scope, node); break;
	case AST_ID: ret = analyze_id(state, scope, node); break;
	case AST_IF: ret = analyze_if(state, scope, node); break;

	case AST_CONST_INT: ret = analyze_int(state, scope, node); break;
	case AST_CONST_STR: ret = analyze_str(state, scope, node); break;

	case AST_EMPTY:
		node->t = tgen_void(node->loc);
		ret = 0;
		break;
	default:
		internal_error("missing ast analysis for %s", ast_str(node->k));
		return -1;
	}

out:
	if (ret)
		return ret;

	assert(node->t);
	assert(node->scope);
	ast_set_flags(node, AST_FLAG_ANALYZED);
	return 0;
}

static int analyze_list(struct state *state, struct scope *scope,
                        struct ast *nodes)
{
	foreach_node(node, nodes) {
		if (analyze(state, scope, node))
			return -1;
	}

	return 0;
}

static int analyze_type(struct state *state, struct scope *scope,
                        struct type *type)
{
	/* for now, let's just say all types are fine as they are, specified by
	 * the user. */
	(void)state;
	(void)scope;
	(void)type;
	return 0;
}

static int analyze_type_list(struct state *state, struct scope *scope,
                             struct type *types)
{
	foreach_type(type, types) {
		if (analyze_type(state, scope, type))
			return -1;
	}

	return 0;
}

int analyze_root(struct scope *scope, struct ast *root)
{
	foreach_node(node, root) {
		assert(node->k == AST_PROC_DEF);
		if (scope_add_proc(scope, node))
			return -1;
	}

	foreach_node(node, root) {
		struct state state = {};
		if (analyze(&state, scope, node))
			return -1;
	}

	return 0;
}