#include "sema.h"
#include "ast.h"
#include "collection.h"
#include <assert.h>
#include <stdlib.h>

typedef struct {
    Hashmap ord_syms;
    Hashmap tag_syms;
} Rib;

static void rib_init(Rib* r)
{
    *r = (Rib) {
        .ord_syms = { },
        .tag_syms = { },
    };
    hashmap_init(&r->ord_syms, sizeof(Sym*));
    hashmap_init(&r->tag_syms, sizeof(Sym*));
}

static void rib_deinit(Rib* r)
{
    hashmap_deinit(&r->ord_syms);
    hashmap_deinit(&r->tag_syms);
}

struct Sema {
    Arena sym_arena;
    ARRAY_FIELD(Rib, ribs);
    Hashmap labels;
};

Sema* sema_new(void)
{
    Sema* s = malloc(sizeof(Sema));
    *s = (Sema) {
        .sym_arena = { },
        ARRAY_FIELD_INIT(ribs),
        .labels = { },
    };

    arena_init(&s->sym_arena, 1024);

    ARRAY_FIELD_PUSH(s, ribs, (&(Rib) { }));
    rib_init(&s->ribs[0]);

    hashmap_init(&s->labels, sizeof(LabelSym*));

    return s;
}

void sema_free(Sema* s)
{
    arena_deinit(&s->sym_arena);
    for (size_t i = 0; i < s->ribs_size; ++i)
        rib_deinit(&s->ribs[i]);
    if (s->ribs)
        free(s->ribs);
    hashmap_deinit(&s->labels);
    free(s);
}

void sema_scope_enter(Sema* s)
{
    ARRAY_FIELD_PUSH(s, ribs, (&(Rib) { }));
    rib_init(&s->ribs[s->ribs_size - 1]);
}

void sema_scope_leave(Sema* s)
{
    assert(s->ribs_size > 0);
    rib_deinit(&s->ribs[s->ribs_size - 1]);
    s->ribs_size -= 1;
}

void sema_function_enter(Sema* s, AstDeclar* declar)
{
    assert(declar->ty == AstDeclar_Function);

    // clear label map
    hashmap_deinit(&s->labels);
    hashmap_init(&s->labels, sizeof(LabelSym*));

    sema_scope_enter(s);

    for (size_t i = 0; i < declar->function.params_size; ++i) { }
}

void sema_function_leave(Sema* s)
{
    sema_scope_leave(s);
}

void sema_visit_function_declar(Sema* s, AstDeclar* declar)
{
}

void sema_visit_stmt(Sema* s, AstStmt* stmt)
{
    if (stmt->ty == AstStmt_Decl) { }
}

void sema_visit_expr(Sema* s, AstExpr* expr)
{
}