#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ply.h"

struct providers {
	provider_t **prov;
	size_t len;
} providers;

provider_t *provider_get(const char *name)
{
	size_t i;

	for (i = 0; i < providers.len; i++) {
		if (strstr(providers.prov[i]->name, name)
		    == providers.prov[i]->name)
			return providers.prov[i];
	}

	return NULL;
}

void provider_register(provider_t *prov)
{
	assert(prov);
	assert(prov->probe);
	assert(prov->resolve);

	providers.prov = realloc(providers.prov,
				 ++providers.len * sizeof(*providers.prov));

	providers.prov[providers.len - 1] = prov;
}

typedef struct pass pass_t;
struct pass {
	int (*run)(pass_t *, ctx_t *);
	walk_fn pre;
	walk_fn post;
};


symtab_t globals = { .sym = NULL, .len = 0 };
symtab_t locals = { .sym = NULL, .len = 0 };

ctx_t *ctx_get(void)
{
	ctx_t *ctx;
	prog_t *prog;

	ctx = calloc(1, sizeof(*ctx));
	ctx->globals = calloc(1, sizeof(*ctx->globals));

	ctx->progs = calloc(3, sizeof(*ctx->progs));

	/* PROBE0 */
	prog = calloc(1, sizeof(*prog));
	prog->locals = calloc(1, sizeof(*prog->locals));
	prog->globals = ctx->globals;

	prog->probe = "k:SyS_read";
	/* { t0 = time(); @reads[pid()] = quantize(arg2) } */
	prog->ast =
		node_vlist(
			node_vlist(node_keyword('='),
				   node_ident("t0"),
				   node_list(node_ident("time")),
				   NULL),
			node_vlist(node_keyword('='),
				   node_vlist(node_keyword('['),
					      node_ident("@reads"),
					      node_list(node_ident("pid")),
					      NULL),
				   node_vlist(node_ident("quantize"),
					      node_ident("arg2"),
					      NULL),
				   NULL),
			NULL);

	prog->provider = provider_get("k");
	prog->provider->probe(prog);
	ctx->progs[0] = prog;

	/* PROBE1 */
	prog = calloc(1, sizeof(*prog));
	prog->locals = calloc(1, sizeof(*prog->locals));
	prog->globals = ctx->globals;

	/* TODO: k -> kret */
	prog->probe = "k:SyS_read2"; 
	/* { @times[pid()] = quantize(time() - t0) } */
	prog->ast =
		node_list(
			node_vlist(node_keyword('='),
				   node_vlist(node_keyword('['),
					      node_ident("@times"),
					      node_list(node_ident("pid")),
					      NULL),
				   node_vlist(node_ident("quantize"),
					      node_vlist(node_keyword('-'),
							 node_list(node_ident("time")),
							 node_ident("t0"),
							 NULL),
					      NULL),
				   NULL)
			);

	prog->provider = provider_get("k");
	prog->provider->probe(prog);
	ctx->progs[1] = prog;

	return ctx;
}


int pass_resolve_symbols(node_t *n, void *_prog)
{
	prog_t *prog = _prog;
	provider_t *global = provider_get(":");
	node_t *op;
	int err;

	if (n->ntype != N_IDENT)
		return 0;

	/* .IDENT/->IDENT is a struct/union member, skip */
	/* op = node_prev(node_prev(n)); */
	/* if (op && (op->ntype == N_IDENT) && !strcmp(".", op->ident)) */
	/* 	return 0; */

	err = prog->provider->resolve(prog, n);
	if (!err || (err != -ENOENT))
		return err;

	err = global->resolve(prog, n);
	if (!err || (err != -ENOENT))
		return err;

	/* neither provider identifier nor global ditto => user
	 * variable, add it as a global symbol of unknown type. */
	return sym_add(prog->globals, n->ident, NULL, &n->sym);
}

int infer_type_list(prog_t *prog, node_t *n)
{
	type_t *t;

	/* list of lists (code block) => void */
	if (n->list->ntype == N_LIST) {
		n->type = &t_v;
		return 0;
	}

	t = n->list->type;
	if (!t)
		return 0;

	switch (t->ttype) {
	case T_FUNC:
		n->type = t->t.func.type;
		break;
	default:
		n->type = t;
	}
	return 0;
}

int infer_type_keyword(prog_t *prog, node_t *n)
{
	node_t *dst, *src;

	switch (n->keyword) {
	case KW_ASSIGN:
		dst = node_next(n);
		src = node_next(dst);
		assert(dst && src);

		if (!src->type)
			return 0;

		/* TODO: assignment is statement for now. do we need
		 * c-style assignment expressions? e.g `a = b = 2;` */
		n->type = &t_v;

		if (dst->type)
			return 0;

		dst->type = src->type;

		if (dst->ntype != N_IDENT)
			return 0;

		return sym_add(dst->sym->st, dst->ident, dst->type, NULL);

	case KW_ADD:
	case KW_SUB:
	case KW_MUL:
	case KW_DIV:
		dst = node_next(n);
		src = node_next(dst);
		assert(dst && src);

		if (!(src->type && dst->type && type_equal(src->type, dst->type)))
			return 0;

		n->type = dst->type;
		return 0;

	default:
		return 0;
	}

	return -ENOSYS;
}

int infer_type_sym(prog_t *prog, node_t *n)
{
	node_t *parent, *key;

	if (n->sym->type) {
		/* the symbol type could have been inferred in another
		 * probe, in that case copy the type to this node. */
		if (!n->type)
			n->type = n->sym->type;

		return 0;
	}

	parent = node_up(n);
	key = node_next(n);

	/* match `somemap[somekey]` where the type of the entire
	 * expression and the type of the key is known, since that
	 * means the type of the map itself is also known. */
	if (parent && parent->type
	    && (parent->list->ntype == N_KEYWORD)
	    && (parent->list->keyword == KW_SUBSCRIPT)
	    && key && key->type) {
		n->type = type_get_map_of(key->type, parent->type);

		return sym_add(n->sym->st, n->ident, n->type, NULL);
	}

	return 0;
}

int pass_infer_types(node_t *n, void *_prog)
{
	prog_t *prog = _prog;

	if (n->type)
		return 0;

	switch (n->ntype) {
	case N_LIST:
		return infer_type_list(prog, n);
	case N_KEYWORD:
		return infer_type_keyword(prog, n);
	case N_IDENT:
		return infer_type_sym(prog, n);
	default:
		break;
	}

	return 0;
}

/* int pass_walk(pass_t *pass, prog_t *prog) */
/* { */
/* 	return node_walk(prog->ast, pass->pre, pass->post, prog); */
/* } */

int pass_validate_types(node_t *n, void *_prog)
{
	prog_t *prog = _prog;

	
	return 0;
}

int pass_walk(pass_t *pass, ctx_t *ctx)
{
	prog_t **prog;
	int err;

	for (prog = ctx->progs; *prog; prog++) {
		err = node_walk((*prog)->ast, pass->pre, pass->post, *prog);
		if (err)
			return err;
	}

	return 0;
}

pass_t passes[] = {
	{ .run = pass_walk, .post = pass_resolve_symbols },
	{ .run = pass_walk, .post = pass_infer_types },
	{ .run = pass_walk, .post = pass_infer_types },
	{ .run = pass_walk, .post = pass_infer_types },
	{ .run = pass_walk, .post = pass_validate_types },

	{ NULL }
};

int main(void)
{
	ctx_t *ctx = ctx_get();
	prog_t **prog;
	pass_t *pass;
	int err;

	for (pass = passes; pass->run; pass++) {
		err = pass->run(pass, ctx);
		if (err)
			break;
	}

	for (prog = ctx->progs; *prog; prog++) {
		printf("\n\e[34m%s\e[0m\n", (*prog)->probe);
		node_dump((*prog)->ast, stdout);
		printf("\n-- locals\n");
		symtab_dump((*prog)->locals, stdout);
	}

	printf("\n\n-- globals\n");
	symtab_dump(ctx->globals, stdout);
	return err;
}