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

#include <gc.h>

#include "../../../include/oberon.h"
#include "../../oberon-internals.h"
#include "generator-jvm.h"
#include "generator-jvm-abi.h"
#include "generator-jvm-asm.h"
#include "generator-jvm-basic.h"

/*
 *   --- Каждый модуль является объектом.
 *       Импортируемые модули представляются полями.
 *       Каждая глобальная переменная представляется не статическим полем.
 *       Каждая процедура представляется не статическим метеодом.
 *       Процедура инициализации модуля имеет название BEGIN.
 *       Процедура финализации модуля имеет название END.
 *         Это позволит сделать динамическую загрузку и выгрузку.
 *   +++ всем переменным и полям в дескриптор добавляется "["
 *         Это позволит делать ссылки на переменные в VAR-параметрах.
 *   --- Каждая процедура снабжается параметром-фреймом.
 *       Это позволит реализовать локальные процедуры и средства рефлекции над стеком.
 */ 

void
jvm_generate_ldst_prepare(gen_proc_t * p, gen_var_t * v)
{
	char * full_name = v -> full_name;
	char * desc = v -> type -> desc;

	switch(v -> storage)
	{
		case JVM_STORAGE_REGISTER:
			break;
		case JVM_STORAGE_STATIC:
			jvm_generate(p, 0, 1, "getstatic %s [%s", full_name, desc);
			jvm_generate(p, 0, 1, "iconst_0");
			break;
		case JVM_STORAGE_FIELD:
			jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
			jvm_generate(p, 0, 1, "iconst_0");
			break;
		case JVM_STORAGE_LOCAL:
			jvm_generate(p, 0, 1, "aload %i", v -> reg);
			jvm_generate(p, 0, 1, "iconst_0");
			break;
		case JVM_STORAGE_VARPTR:
			jvm_generate(p, 0, 1, "aload %i", v -> reg);
			jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
			break;
		default:
			gen_error("jvm_abi_obn_generate_ldst_prepare: wat %i", v -> storage);
	}
}

void
jvm_generate_load(gen_proc_t * p, gen_var_t * src)
{
	char prefix = src -> type -> prefix;
	int cell_size = src -> type -> cell_size;

	switch(src -> storage)
	{
		case JVM_STORAGE_REGISTER:
			jvm_generate(p, 0, cell_size, "%cload %i", prefix, src -> reg);
			break;
		case JVM_STORAGE_STATIC:
		case JVM_STORAGE_FIELD:
		case JVM_STORAGE_LOCAL:
		case JVM_STORAGE_VARPTR:
			jvm_generate_ldst_prepare(p, src);
			jvm_generate(p, 1 + 1, cell_size, "%caload", prefix);
			break;
		default:
			gen_error("jvm_generate_load: unknow storage type %i", src -> storage);
			break;
	}
}

void
jvm_generate_store(gen_proc_t * p, gen_var_t * dst)
{
	char prefix = dst -> type -> prefix;
	int cell_size = dst -> type -> cell_size;

	switch(dst -> storage)
	{
		case JVM_STORAGE_REGISTER:
			jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg);
			break;
		case JVM_STORAGE_STATIC:
		case JVM_STORAGE_FIELD:
		case JVM_STORAGE_LOCAL:
		case JVM_STORAGE_VARPTR:
			jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", prefix);
			break;
		default:
			gen_error("jvm_generate_store: unknow storage type %i", dst -> storage);
			break;
	}
}

void
jvm_generate_and_init_global_var(struct gen_class * class, gen_var_t * v, char * name, gen_type_t * t)
{
	assert(class -> p == NULL);
        fprintf(class -> fp, ".field public static %s [%s\n\n", name, t -> desc);

        v -> storage = JVM_STORAGE_STATIC;
        v -> full_name = new_string("%s/%s", class -> full_name, name);
	v -> type = t;
}

void
jvm_generate_and_init_field(struct gen_class * class, gen_var_t * v, char * name, gen_type_t * t)
{
	assert(class -> p == NULL);
        fprintf(class -> fp, ".field public %s [%s\n\n", name, t -> desc);

        v -> storage = JVM_STORAGE_FIELD;
        v -> full_name = new_string("%s/%s", class -> full_name, name);
	v -> type = t;
}

void
jvm_generate_and_init_local_var(gen_proc_t * p, gen_var_t * v, gen_type_t * t)
{
	v -> storage = JVM_STORAGE_REGISTER;
        v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
	v -> type = t;
}

void
jvm_generate_and_init_named_local_var(gen_proc_t * p, gen_var_t * v, char * name, gen_type_t * t)
{
	jvm_generate_and_init_local_var(p, v, t);
        jvm_generate(p, 0, 0, ".var %i is %s %s from start to end", v -> reg, name, t -> desc);
}

void
jvm_generate_and_init_var_param(gen_proc_t * p, gen_var_t * v, char * name, gen_type_t * t)
{
	v -> storage = JVM_STORAGE_VARPTR;
        v -> reg = jvm_alloc_register_untyped(p -> rf, true);
	v -> type = t;
        jvm_generate(p, 0, 0, ".var %i is %s [%s from start to end", v -> reg, name, t -> desc);
        jvm_generate(p, 0, 0, ".var %i is __%s_offset I from start to end", v -> reg + 1, name);
}

void
jvm_generate_variable_initialization(gen_proc_t * p, gen_var_t * v)
{
	if(v -> storage == JVM_STORAGE_STATIC)
	{
		jvm_generate(p, 0, 1, "iconst_1");
		jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
		jvm_generate(p, 1, 0, "putstatic %s [%s", v -> full_name, v -> type -> desc);
	}
	else if(v -> storage == JVM_STORAGE_FIELD)
	{
		jvm_generate(p, 0, 1, "iconst_1");
		jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
		jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);
	}
}

void
jvm_generate_param_initialization(gen_proc_t * p, gen_var_t * v)
{
	assert(v -> storage == JVM_STORAGE_REGISTER);

	int old_reg = v -> reg;
	bool wide = v -> type -> wide;
	int cell_size = v -> type -> cell_size;
	char prefix = v -> type -> prefix;
	char * desc = v -> type -> desc;

	v -> storage = JVM_STORAGE_LOCAL;
        v -> reg = jvm_alloc_register_untyped(p -> rf, wide);

	jvm_generate(p, 0, 1, "iconst_1");
	jvm_generate(p, 1, 1, "multianewarray [%s 1", desc);
	jvm_generate(p, 1, 2, "dup");
	jvm_generate(p, 1, 0, "astore %i", v -> reg);

	jvm_generate(p, 0, 1, "iconst_0");
	jvm_generate(p, 0, cell_size, "%cload %i", prefix, old_reg);
	jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", prefix);
}