#include "../cmd.h"

#include <fx/cmd.h>
#include <fx/term.h>
#include <mie/attribute/attribute-definition.h>
#include <mie/ctx.h>
#include <mie/dialect/arith.h>
#include <mie/dialect/builtin.h>
#include <mie/dialect/cf.h>
#include <mie/dialect/dialect.h>
#include <mie/dialect/func.h>
#include <mie/dialect/index.h>
#include <mie/dialect/meta.h>
#include <mie/dialect/ptr.h>
#include <mie/dialect/scf.h>
#include <mie/dialect/select.h>
#include <mie/ir/builder.h>
#include <mie/ir/op.h>
#include <mie/pass/builtin.h>
#include <mie/pass/pass-manager.h>
#include <mie/print/printer.h>

enum {
	OPT_GENERIC,
	OPT_NO_ABBREV,
	OPT_PASS_OFFSET = 100,
};

static int builder_test(
	const fx_command *cmd, const fx_arglist *args, const fx_array *_)
{
	struct mie_ctx *ctx = mie_ctx_create();
	mie_builtin_dialect_create(ctx);
	mie_meta_dialect_create(ctx);
	mie_select_dialect_create(ctx);
	mie_ptr_dialect_create(ctx);
	mie_arith_dialect_create(ctx);
	mie_func_dialect_create(ctx);
	mie_cf_dialect_create(ctx);
	mie_scf_dialect_create(ctx);
	mie_index_dialect_create(ctx);

	mie_builtin_passes_register(ctx);

	struct mie_op *module = mie_ctx_create_op(ctx, "builtin", "module");
	struct mie_builder *builder = mie_builder_create(ctx, module);

	const struct mie_type *i32 = mie_ctx_get_int_type(ctx, 32);
	const struct mie_type *i64 = mie_ctx_get_int_type(ctx, 64);

	struct mie_func_parameter params[] = {
		{.param_name = "p1", .param_type = i32},
		{.param_name = "p2", .param_type = i64},
	};
	size_t nr_params = sizeof params / sizeof params[0];
	const struct mie_type *ret_type = mie_ctx_get_int_type(ctx, 64);

	struct mie_op *func = mie_func_func_put(
		MIE_EMITTER(builder), "test_func", params, nr_params, &ret_type, 1);
	mie_builder_step_into_op(builder, func);

	struct mie_region *r_true, *r_false;
	struct mie_op *if_op = mie_scf_if_put(
		MIE_EMITTER(builder), params[0].param_reg, i32, &r_true,
		&r_false, NULL);

	struct mie_register *tmp = NULL;

	mie_builder_step_into_region(builder, r_true);
	tmp = mie_arith_constant_i_put(MIE_EMITTER(builder), 10, NULL);
	mie_scf_yield_put(MIE_EMITTER(builder), tmp);
	mie_builder_step_out(builder);

	mie_builder_step_into_region(builder, r_false);
	tmp = mie_arith_constant_i_put(MIE_EMITTER(builder), 20, NULL);
	mie_scf_yield_put(MIE_EMITTER(builder), tmp);
	mie_builder_step_out(builder);

	struct mie_register *v1
		= mie_arith_constant_i_put(MIE_EMITTER(builder), 1024, NULL);
	struct mie_register *v2
		= mie_arith_constant_i_put(MIE_EMITTER(builder), 2048, NULL);
	struct mie_register *add
		= mie_arith_addi_put(MIE_EMITTER(builder), v1, v2, NULL);
	struct mie_register *add2 = mie_arith_addi_put(
		MIE_EMITTER(builder), add, &if_op->op_result.items[0], NULL);

	mie_builder_step_out(builder);

	struct mie_pass_manager *pm = mie_pass_manager_create(ctx);
	struct mie_pass_manager *module_pm = mie_pass_manager_nest(pm);
	mie_pass_manager_filter_op(module_pm, "builtin", "module");

	struct mie_pass_manager *func_pm = mie_pass_manager_nest(pm);
	mie_pass_manager_filter_op(module_pm, "func", "func");

	fx_arglist_iterator it;
	fx_arglist_foreach(&it, args)
	{
		if (it.opt_id < OPT_PASS_OFFSET) {
			continue;
		}

		const fx_command_option *opt
			= fx_command_get_option(cmd, it.opt_id);
		if (!opt) {
			continue;
		}

		const char *pass_name = fx_command_option_get_long_name(opt);
		struct mie_pass *pass = NULL;
		enum mie_status status
			= mie_ctx_get_pass(ctx, pass_name, NULL, &pass);
		if (status != MIE_SUCCESS) {
			printf("cannot load pass %s\n", pass_name);
			return -1;
		}

		mie_pass_manager_add_pass(func_pm, pass);
	}

	mie_pass_manager_run(pm, module);

	enum mie_print_flags flags = 0;
	if (fx_arglist_get_count(args, OPT_GENERIC, FX_COMMAND_INVALID_ID) > 0) {
		flags |= MIE_PRINT_F_GENERIC;
	}

	if (fx_arglist_get_count(args, OPT_NO_ABBREV, FX_COMMAND_INVALID_ID) == 0) {
		flags |= MIE_PRINT_F_ABBREVIATED;
	}

	struct mie_printer printer;
	mie_printer_init(&printer, ctx, fx_stdout, flags);
	mie_printer_print_op(&printer, module);
	printf("\n");

	return 0;
}

FX_COMMAND(CMD_INTERNAL_BUILDER_TEST, CMD_INTERNAL)
{
	FX_COMMAND_NAME("builder-test");
	FX_COMMAND_DESC("mie_builder test");
	FX_COMMAND_FUNCTION(builder_test);

	FX_COMMAND_OPTION(OPT_GENERIC)
	{
		FX_OPTION_LONG_NAME("generic");
		FX_OPTION_SHORT_NAME('g');
		FX_OPTION_DESC("print operations in generic format.");
	}

	FX_COMMAND_OPTION(OPT_NO_ABBREV)
	{
		FX_OPTION_LONG_NAME("no-abbrev");
		FX_OPTION_SHORT_NAME('n');
		FX_OPTION_DESC(
			"don't use abbreviations for builtin types and ops.");
	}

	FX_COMMAND_HELP_OPTION();

	struct mie_ctx *ctx = mie_ctx_create();
	mie_builtin_passes_register(ctx);

	size_t i = 0;
	fx_bst_node *node = fx_bst_first(&ctx->ctx_passes.map_entries);
	while (node) {
		mie_id *id = fx_unbox(mie_id, node, e_node);
		struct mie_pass_definition *pass
			= fx_unbox(struct mie_pass_definition, id, p_id);

		FX_COMMAND_OPTION_GEN(OPT_PASS_OFFSET + i)
		{
			FX_OPTION_LONG_NAME(pass->p_name);
			FX_OPTION_DESC(pass->p_description);
		}

		node = fx_bst_next(node);
		i++;
	}
}