/* This software is licensed by the MIT License, see LICENSE file */
/*                                Copyright © 2022 Gregory Lirent */

#include "include.h"

#define mtree_duplicate(s, t)    rbtree_duplicate((rbnode_t*)s, (void*)mnode_duplicate, t)
#define mtree_compare(s0, s1, t) rbtree_compare((void*)s0, (void*)s1, (void*)mnode_compare, (void*)t)

static mnode_t* mnode_duplicate(const mnode_t* s, mnode_t* p, const vtype* t) {
    mnode_t* x;

    x        = mnode_create(vnode_duplicate(&s->key, *t), p, s->colored);
    x->type  = s->type;
    x->value = vnode_duplicate(&s->value, s->type);

    return x;
}

static int mnode_compare(const mnode_t* s0, const mnode_t* s1, vtype* t) {
    int c = vnode_compare_eq(&s0->key, &s1->key, *t);

    return !c ? vnode_compare(&s0->value, s0->type, &s1->value, s1->type) : c;
}

static hash_t mnode_hash(const mnode_t* s, vtype* tp) {
    vtype t = (!is_null(tp)) ? *tp : VTYPE_POINTER;
    return vnode_hash(s->key, t) + vnode_hash(s->value, s->type) + t;
}

void libcdsb_mnode_free(mnode_t* x, vtype* t) {
    vnode_free(&x->key, *t);
    vnode_free(&x->value, x->type);
}

/*#####################################################################################################################*/

hash_t map_hash(const map_t* s) {
    return rbtree_hash(s->root, (void*)mnode_hash, (void*)&s->type) + VTYPE_MAP;
}

void map_init(map_t* x, vtype t) {
    x->root = mnode_empty;
    x->type = t;
}

void map_free(map_t* x) {
    rbtree_free(x->root, (void*)mnode_free, &x->type);

    x->root = mnode_empty;
    x->type = 0;
}

/*#####################################################################################################################*/

size_t map_size(const map_t* x) {
    return rbtree_size(x->root);
}

/*#####################################################################################################################*/

int map_compare(const map_t* s0, const map_t* s1) {
    if (s0 == s1) return 0;
    if (s0->type != s1->type) return s0->type - s1->type;

    return mtree_compare(s0->root, s1->root, &s0->type);
}

/*#####################################################################################################################*/

map_t map_copy(const map_t* s) {
    map_t x;

    x.type = s->type;
    x.root = mtree_duplicate(s->root, &x.type);

    return x;
}

map_t* map_duplicate(const map_t* s) {
    map_t *x = malloc(sizeof(*x));

    x->type = s->type;
    x->root = mtree_duplicate(s->root, &x->type);

    return x;
}

void map_copy_init(map_t* x, const map_t* s) {
    x->type = s->type;
    x->root = mtree_duplicate(s->root, &x->type);
}