#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"

void
jvm_generate_ldst_prepare(gen_proc_t * p, gen_var_t * v)
{
	char * desc = v -> type -> desc;
	char * full_name = v -> full_name;
	switch(v -> storage)
	{
		case JVM_STORAGE_REGISTER:
		case JVM_STORAGE_STATIC:
		case JVM_STORAGE_FIELD:
		case JVM_STORAGE_PARAM:
			break;
		case JVM_STORAGE_REGISTER_VAR:
		case JVM_STORAGE_PARAM_VAR:
			jvm_generate(p, 0, 1, "aload %i", v -> reg);
			jvm_generate(p, 0, 1, "iconst_0");
			break;
		case JVM_STORAGE_STATIC_VAR:
			jvm_generate(p, 0, 1, "getstatic %s [%s", full_name, desc);
			jvm_generate(p, 0, 1, "iconst_0");
			break;
		case JVM_STORAGE_FIELD_VAR:
			jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
			jvm_generate(p, 0, 1, "iconst_0");
			break;
		case JVM_STORAGE_PARAM_VARPTR:
			jvm_generate(p, 0, 1, "aload %i", v -> reg);
			jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
			break;
		case JVM_STORAGE_FRAME:
		case JVM_STORAGE_FRAME_PARAM:
			jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
			break;
		case JVM_STORAGE_FRAME_VAR:
		case JVM_STORAGE_FRAME_PARAM_VAR:
			jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
			jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
			jvm_generate(p, 0, 1, "iconst_0");
			break;
		case JVM_STORAGE_FRAME_PARAM_VARPTR:
			jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
			jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
			jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
			jvm_generate(p, 1, 1, "getfield %s$offset I", full_name);
			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;
	char postfix = src -> type -> postfix;
	int cell_size = src -> type -> cell_size;
	char * full_name = src -> full_name;
	char * desc = src -> type -> desc;

	switch(src -> storage)
	{
		case JVM_STORAGE_REGISTER:
		case JVM_STORAGE_PARAM:
			jvm_generate(p, 0, cell_size, "%cload %i", prefix, src -> reg);
			break;
		case JVM_STORAGE_STATIC:
			jvm_generate(p, 0, cell_size, "getstatic %s %s", full_name, desc);
			break;
		case JVM_STORAGE_FIELD:
			jvm_generate(p, 0, cell_size, "getfield %s %s", full_name, desc);
			break;
		case JVM_STORAGE_REGISTER_VAR:
		case JVM_STORAGE_STATIC_VAR:
		case JVM_STORAGE_FIELD_VAR:
		case JVM_STORAGE_PARAM_VAR:
		case JVM_STORAGE_PARAM_VARPTR:
		case JVM_STORAGE_FRAME_VAR:
		case JVM_STORAGE_FRAME_PARAM_VAR:
		case JVM_STORAGE_FRAME_PARAM_VARPTR:
			jvm_generate_ldst_prepare(p, src);
			jvm_generate(p, 1 + 1, cell_size, "%caload", postfix);
			break;
		case JVM_STORAGE_FRAME:
		case JVM_STORAGE_FRAME_PARAM:
			jvm_generate_ldst_prepare(p, src);
			jvm_generate(p, 1, cell_size, "getfield %s %s", full_name, desc);
			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;
	char postfix = dst -> type -> postfix;
	int cell_size = dst -> type -> cell_size;
	char * full_name = dst -> full_name;
	char * desc = dst -> type -> desc;

	switch(dst -> storage)
	{
		case JVM_STORAGE_REGISTER:
		case JVM_STORAGE_PARAM:
			jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg);
			break;
		case JVM_STORAGE_STATIC:
			jvm_generate(p, 0, cell_size, "putstatic %s %s", full_name, desc);
			break;
		case JVM_STORAGE_FIELD:
			jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc);
			break;
		case JVM_STORAGE_REGISTER_VAR:
		case JVM_STORAGE_STATIC_VAR:
		case JVM_STORAGE_FIELD_VAR:
		case JVM_STORAGE_PARAM_VAR:
		case JVM_STORAGE_PARAM_VARPTR:
		case JVM_STORAGE_FRAME_VAR:
		case JVM_STORAGE_FRAME_PARAM_VAR:
		case JVM_STORAGE_FRAME_PARAM_VARPTR:
			jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
			break;
		case JVM_STORAGE_FRAME:
		case JVM_STORAGE_FRAME_PARAM:
			jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc);
			break;
		default:
			gen_error("jvm_generate_store: unknow storage type %i", dst -> storage);
			break;
	}
}

static gen_var_t *
jvm_new_var()
{
	gen_var_t * v = GC_MALLOC(sizeof *v);
	memset(v, 0, sizeof *v);
	return v;
}

gen_var_t *
jvm_create_class_var(struct gen_class * class, enum gen_storage storage, char * name, gen_type_t * t)
{
	gen_var_t * v = jvm_new_var();
	v -> storage = storage;
	v -> name = new_string(name);
	v -> type = t;
	v -> class = class;

	assert(class -> p == NULL);
	switch(storage)
	{
		case JVM_STORAGE_STATIC:
		case JVM_STORAGE_FIELD:
		case JVM_STORAGE_STATIC_VAR:
		case JVM_STORAGE_FIELD_VAR:
		        v -> full_name = new_string("%s/%s", class -> full_name, name);
			break;
		default:
			gen_error("jvm_create_class_var: invalid storage %i", storage);
			break;
	}

	return v;
}

gen_var_t *
jvm_create_function_var(gen_proc_t * p, enum gen_storage storage, char * name, gen_type_t * t)
{
	gen_var_t * v = jvm_new_var();
	v -> storage = storage;
	v -> name = new_string(name);
	v -> type = t;
	v -> p = p;
	v -> level = p -> level;

	switch(storage)
	{
		case JVM_STORAGE_REGISTER:
		case JVM_STORAGE_PARAM:
		case JVM_STORAGE_PARAM_VAR:
			v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
			break;
		case JVM_STORAGE_PARAM_VARPTR:
			/* Содержит пару массив+индекс */
			v -> reg = jvm_alloc_register_untyped(p -> rf, true);
			break;
		case JVM_STORAGE_REGISTER_VAR:
			/* Содержит массив */
			v -> reg = jvm_alloc_register_untyped(p -> rf, false);
			break;
		case JVM_STORAGE_FRAME:
		case JVM_STORAGE_FRAME_VAR:
			v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
			break;
		case JVM_STORAGE_FRAME_PARAM:
		case JVM_STORAGE_FRAME_PARAM_VAR:
			v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
			v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
			break;
		case JVM_STORAGE_FRAME_PARAM_VARPTR:
			/* Содержит пару массив+индекс */
			v -> reg = jvm_alloc_register_untyped(p -> rf, true);
			v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
			break;
		default:
			gen_error("jvm_create_class_var: invalid storage %i", storage);
			break;
	}

	return v;
}

gen_var_t *
jvm_create_function_temp_var(gen_proc_t * p, gen_type_t * t)
{
	gen_var_t * v = jvm_new_var();
	v -> storage = JVM_STORAGE_REGISTER;
	v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
	v -> name = new_string("$TEMP_%i$", v -> reg);
	v -> type = t;
	v -> p = p;
	v -> level = p -> level;
	return v;
}

void
jvm_generate_var(gen_var_t * v)
{
	enum gen_storage storage = v -> storage;
	int reg = v -> reg;
	char * name = v -> name;
	char * desc = v -> type -> desc;
	gen_proc_t * p = v -> p;

	switch(v -> storage)
	{
		case JVM_STORAGE_REGISTER:
		case JVM_STORAGE_PARAM:
		case JVM_STORAGE_PARAM_VAR:
		case JVM_STORAGE_FRAME:
		case JVM_STORAGE_FRAME_VAR:
		case JVM_STORAGE_FRAME_PARAM:
		case JVM_STORAGE_FRAME_PARAM_VAR:
		        jvm_generate(p, 0, 0, ".var %i is '%s' %s from start to end", reg, name, desc);
			break;
		case JVM_STORAGE_REGISTER_VAR:
		        jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc);
			break;
		case JVM_STORAGE_PARAM_VARPTR:
		case JVM_STORAGE_FRAME_PARAM_VARPTR:
		        jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc);
		        jvm_generate(p, 0, 0, ".var %i is '%s$offset' I from start to end", reg + 1, name);
			break;
		case JVM_STORAGE_STATIC:
			fprintf(v -> class -> fp, ".field public static '%s' %s\n\n", name, desc);
			break;
		case JVM_STORAGE_STATIC_VAR:
			fprintf(v -> class -> fp, ".field public static '%s' [%s\n\n", name, desc);
			break;
		case JVM_STORAGE_FIELD:
			fprintf(v -> class -> fp, ".field public '%s' %s\n\n", name, desc);
			break;
		case JVM_STORAGE_FIELD_VAR:
			fprintf(v -> class -> fp, ".field public '%s' [%s\n\n", name, desc);
			break;
		default:
			gen_error("jvm_generate_var: invalid storage %i", storage);
			break;
	}
}

static void
jvm_generate_param_initialization(gen_proc_t * p, gen_var_t * v)
{
	int old_reg = v -> reg;
	int cell_size = v -> type -> cell_size;
	char prefix = v -> type -> prefix;
	char postfix = v -> type -> postfix;
	char * name = v -> name;
	char * desc = v -> type -> desc;

	v -> reg = jvm_alloc_register_untyped(p -> rf, false);
	jvm_generate(p, 0, 0, ".var %i is $%s [%s from start to end", v -> reg, name, desc);

	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", postfix);
}

void
jvm_generate_var_initialization(gen_proc_t * p, gen_var_t * v)
{
	if(v -> storage == JVM_STORAGE_REGISTER_VAR)
	{
		jvm_generate(p, 0, 1, "iconst_1");
		jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
		jvm_generate(p, 1, 0, "astore %i", v -> reg);
	}
	else if(v -> storage == JVM_STORAGE_STATIC_VAR)
	{
		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_VAR)
	{
		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);
	}
	else if(v -> storage == JVM_STORAGE_PARAM_VAR)
	{
		jvm_generate_param_initialization(p, v);
	}
	else if(v -> storage == JVM_STORAGE_FRAME_PARAM
		|| v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
	{
		jvm_generate_ldst_prepare(p, v);
		jvm_generate(p, 0, v -> type -> cell_size, "%cload %i", v -> type -> prefix, v -> reg);
		jvm_generate_store(p, v);
	}
	else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
	{
		jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
		jvm_generate(p, 0, 1, "aload %i", v -> reg);
		jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);

		jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
		jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
		jvm_generate(p, 1, 0, "putfield %s$offset I", v -> full_name);
	}
}

/*
static void
jvm_generate_abstract_frame_class()
{
	FILE * fp;
	char * cname;
	struct gen_class * class;

	cname = "SYSTEM$FRAME";
	class = jvm_create_class(cname);
	fp = class -> fp;

	fprintf(fp, ".source SYSTEM\n");
	fprintf(fp, ".class  public abstract %s\n", cname);
	fprintf(fp, ".super  java/lang/Object\n\n");

	fprintf(fp, ".field public $UP L%s;\n\n", cname);

	fprintf(fp, ".method <init>()V\n");
	fprintf(fp, "  aload_0\n");
	fprintf(fp, "  invokespecial java/lang/Object/<init>()V\n");
	fprintf(fp, "  return\n");
	fprintf(fp, ".end method\n\n");

	jvm_destroy_class(class);
}
*/

static struct gen_class *
jvm_generate_frame_class(oberon_object_t * proc)
{
	FILE * fp;
	char * cname;
	char * abscname;
	struct gen_class * class;
	oberon_object_t * var;

	abscname = "SYSTEM$FRAME";
	cname = jvm_get_field_full_name_safe(proc);
	cname = new_string("%s$FRAME", cname);
	class = jvm_create_class(proc -> gen_proc -> class -> dir, cname);
	fp = class -> fp;

	class -> full_name = cname;

	fprintf(fp, ".source %s\n", proc -> module -> name);
	fprintf(fp, ".class  public %s\n", cname);
	fprintf(fp, ".super  %s\n\n", abscname);

	var = proc -> scope -> list -> next;
	while(var)
	{
		if(var -> class == OBERON_CLASS_VAR
			|| var -> class == OBERON_CLASS_PARAM
			|| var -> class == OBERON_CLASS_VAR_PARAM)
		{
			gen_var_t * v = var -> gen_var;
			if(v -> storage == JVM_STORAGE_FRAME
				|| v -> storage == JVM_STORAGE_FRAME_PARAM)
			{
				fprintf(fp, "; LEVEL %i\n", v -> level);
				fprintf(fp, ".field public '%s' %s\n\n", v -> name, v -> type -> desc);
			}
			else if(v -> storage == JVM_STORAGE_FRAME_VAR
				|| v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
			{
				fprintf(fp, "; LEVEL %i\n", v -> level);
				fprintf(fp, ".field public '%s' [%s\n\n", v -> name, v -> type -> desc);
			}
			else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
			{
				fprintf(fp, "; LEVEL %i\n", v -> level);
				fprintf(fp, ".field public '%s' [%s\n", v -> name, v -> type -> desc);
				fprintf(fp, ".field public '%s$offset' I\n\n", v -> name);
			}
		}
		var = var -> next;
	}

	fprintf(fp, ".method <init>()V\n");
	fprintf(fp, "  .limit stack 2\n");
	fprintf(fp, "  aload_0\n");
	fprintf(fp, "  invokespecial %s/<init>()V\n", abscname);

	var = proc -> scope -> list -> next;
	while(var)
	{
		if(var -> class == OBERON_CLASS_VAR
			|| var -> class == OBERON_CLASS_PARAM
			|| var -> class == OBERON_CLASS_VAR_PARAM)
		{
			gen_var_t * v = var -> gen_var;
			if(v -> storage == JVM_STORAGE_FRAME_VAR
				|| v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
			{
				fprintf(fp, "  aload_0\n");
				fprintf(fp, "  iconst_1\n");
				fprintf(fp, "  multianewarray [%s 1\n", v -> type -> desc);
				fprintf(fp, "  putfield %s [%s\n", v -> full_name, v -> type -> desc);
			}
		}
		var = var -> next;
	}

	fprintf(fp, "  return\n");
	fprintf(fp, ".end method\n\n");

	jvm_destroy_class(class);

	return class;
}

void
jvm_generate_procedure_frame(oberon_object_t * proc)
{
	gen_proc_t * p;
	gen_type_t * t;
	gen_var_t * v;
	struct gen_class * class;

	p = proc -> gen_proc;

//	jvm_generate_abstract_frame_class();

	class = jvm_generate_frame_class(proc);

	t = GC_MALLOC(sizeof *t);
	memset(t, 0, sizeof *t);
	t -> class = class;
	t -> wide = false;
	t -> prefix = 'a';
	t -> postfix = 'a';
	t -> cell_size = 1;
	t -> desc = new_string("L%s;", class -> full_name);

	v = jvm_create_function_var(p, JVM_STORAGE_REGISTER, "$FP$", t);
	p -> frame_v = v;
	p -> reg_frame[p -> level] = v -> reg;
}

void
jvm_generate_frame_initialization(gen_proc_t * p)
{
	jvm_generate_var(p -> frame_v);
	jvm_generate_ldst_prepare(p, p -> frame_v);
	jvm_generate(p, 0, 1, "new %s", p -> frame_v -> type -> class -> full_name);
	jvm_generate(p, 1, 2, "dup");
	jvm_generate(p, 1, 0, "invokespecial %s/<init>()V", p -> frame_v -> type -> class -> full_name);
	jvm_generate_store(p, p -> frame_v);
}

char *
jvm_get_procedure_signature(oberon_type_t * ps)
{
	char * signature;
	char * desc;
	int num;
	oberon_object_t * arg;

	signature = new_string("(");

	num = ps -> num_decl;
	arg = ps -> decl;
	for(int i = 0; i < num; i++)
	{
		desc = jvm_get_descriptor(arg -> type);
		if(arg -> class == OBERON_CLASS_VAR_PARAM)
		{
			signature = new_string("%s[%sI", signature, desc);
		}
		else
		{
			signature = new_string("%s%s", signature, desc);
		}
		arg = arg -> next;
	}

	desc = jvm_get_descriptor(ps -> base);
	signature = new_string("%s)%s", signature, desc);

	return signature;
}

static char *
jvm_get_frame_descriptor(oberon_object_t * proc)
{
	char * full_name = jvm_get_field_full_name_safe(proc);
	return new_string("L%s$FRAME;", full_name);
}

static char *
jvm_get_oberon_signature_static_links(oberon_object_t * parent)
{
	if(parent == NULL)
	{
		return "";
	}

	char * up = jvm_get_oberon_signature_static_links(parent -> parent);
	char * desc = jvm_get_frame_descriptor(parent);
	return new_string("%s%s", up, desc);
}

char *
jvm_get_local_procedure_signature(oberon_object_t * proc)
{
	char * stlinks;
	char * signature;
	char * desc;
	int num;
	oberon_object_t * arg;
	oberon_type_t * ps;

	ps = proc -> type;

	signature = new_string("(");

	if(proc -> local)
	{
		stlinks = jvm_get_oberon_signature_static_links(proc -> parent);
		signature = new_string("%s%s", signature, stlinks);
	}

	num = ps -> num_decl;
	arg = ps -> decl;
	for(int i = 0; i < num; i++)
	{
		desc = jvm_get_descriptor(arg -> type);
		if(arg -> class == OBERON_CLASS_VAR_PARAM)
		{
			signature = new_string("%s[%sI", signature, desc);
		}
		else
		{
			signature = new_string("%s%s", signature, desc);
		}
		arg = arg -> next;
	}

	desc = jvm_get_descriptor(ps -> base);
	signature = new_string("%s)%s", signature, desc);

	return signature;
}


static void
jvm_generate_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level)
{
	if(parent == NULL)
	{
		return;
	}

	jvm_generate_staticlinks_recursive(p, parent -> parent, level - 1);
	int reg = p -> reg_frame[level];
	char * desc = jvm_get_frame_descriptor(parent);
	jvm_generate(p, 0, 0, ".var %i is SL$%i %s from start to end", reg, level, desc);
}

void
jvm_generate_staticlinks(oberon_object_t * proc)
{
	gen_proc_t * p;

	p = proc -> gen_proc;

	jvm_generate_staticlinks_recursive(p, proc -> parent, p -> level);
}

static void
jvm_create_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level)
{
	if(parent == NULL)
	{
		return;
	}

	jvm_create_staticlinks_recursive(p, parent -> parent, level - 1);
	p -> reg_frame[level] = jvm_alloc_register_untyped(p -> rf, false);
}

void
jvm_create_static_links(oberon_object_t * proc)
{
	gen_proc_t * p;
	p = proc -> gen_proc;

	int max_frames = 0;
	oberon_object_t * prc = proc;
	while(prc)
	{
		max_frames += 1;
		prc = prc -> parent;
	}

	size_t sz = sizeof(*p -> reg_frame) * max_frames;
	p -> max_frames = max_frames;
	p -> reg_frame = GC_MALLOC(sz);
	memset(p -> reg_frame, 0, sz);

	p -> level = max_frames - 1;
	jvm_create_staticlinks_recursive(p, proc -> parent, p -> level);
}

static void
jvm_generate_push_static_links_recursive(gen_proc_t * p, oberon_object_t * parent)
{
	if(parent == NULL)
	{
		return;
	}

	jvm_generate_push_static_links_recursive(p, parent -> parent);
	int level = parent -> gen_proc -> level;
	jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[level]);
}

void
jvm_generate_push_static_links(gen_proc_t * p, oberon_object_t * proc)
{
	jvm_generate_push_static_links_recursive(p, proc -> parent);
}