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

#include "include.h"

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


void map_free(map_t* x) {
    mnode_t* t;
    mnode_t* c;

    c = x->root;

    while (!mnode_is_empty(x->root)) {
        if (!mnode_is_empty(c->left)) {
            c = c->left;
        } else if (!mnode_is_empty(c->right)) {
            c = c->right;
        } else if (!mnode_is_root(c)) {
            vnode_free(&c->key,   x->type);
            vnode_free(&c->value, c->type);

            t = c;
            c = c->parent;

            if (t == c->left) c->left  = mnode_empty;
            else              c->right = mnode_empty;

            free(t);
        } else {
            vnode_free(&c->key,   x->type);
            vnode_free(&c->value, c->type);
            x->root = mnode_empty;
        }
    }

    x->type = 0;
}


size_t map_size(const map_t* x) {
    stack_t   z = { .prev = 0, .value = x->root };
    size_t    n = 0;
    rbnode_t* c;

    if (!mnode_is_empty(x->root)) {
        while ((c = stack_pop(&z))) {
            ++n;
            if (!rbnode_is_empty(c->left))
                stack_push(&z, c->left);
            if (!rbnode_is_empty(c->right))
                stack_push(&z, c->right);
        }
    }

    return n;
}


int map_compare(const map_t* s0, const map_t* s1) {

    stack_t z = { .prev = 0, .value = 0 };
    vtype   t = s0->type;
    int     c = 0;

    if (s0 == s1 || s0->root == s1->root) return 0;
    if (s0->type != s1->type) return s0->type - s1->type;

    stack_push(&z, s1->root);
    stack_push(&z, s0->root);

    for (mnode_t *c0, *c1;!is_null(z.value);) {
        c0 = stack_pop(&z);
        c1 = stack_pop(&z);

        if (mnode_is_empty(c0) || mnode_is_empty(c1)) {
            if (c0 != c1) {
                stack_flush(&z);
                return mnode_is_empty(c0) ? -1 : 1;
            }
        } else if ((c = vnode_compare(c0->key, t, c1->key, t)) || (c = vnode_compare(c0->value, c0->type, c1->value, c1->type))) {
            if (c0->left == c1->right) {
                        c = vnode_compare(c1->key,         t,        c0->right->key,   t       );
                if (!c) c = vnode_compare(c1->value,       c1->type, c0->right->value, c0->type);
                if (!c) c = vnode_compare(c1->left->key,   t,        c0->key,          t       );
                if (!c) c = vnode_compare(c1->left->value, c1->type, c0->value,        c0->type);
            } else if (c0->right == c1->left) {
                        c = vnode_compare(c0->key,         t,        c1->right->key,   t       );
                if (!c) c = vnode_compare(c0->value,       c0->type, c1->right->value, c1->type);
                if (!c) c = vnode_compare(c0->left->key,   t,        c1->key,          t       );
                if (!c) c = vnode_compare(c0->left->value, c0->type, c1->value,        c1->type);
            }

            if (c) { stack_flush(&z); return c; }
        } else {
            stack_push(&z, c1->right);
            stack_push(&z, c0->right);
            stack_push(&z, c1->left);
            stack_push(&z, c0->left);
        }
    }

    return 0;
}