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

#include "include.h"

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

static inline 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 inline hash_t mnode_hash(const mnode_t* s, vtype t) {
    return vnode_hash(&s->key, t) + vnode_hash(&s->value, s->type) + t;
}

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

hash_t map_hash(const map_t* s) {

    stack_t        z;
    mnode_t *c0, *c1;
    hash_t   hash, v;

    if (mnode_is_empty(s->root))
        return 0;

    stack_init(&z);
    stack_push(&z, s->root->left);

    hash = 1;

    if (!mnode_is_empty(c0 = stack_pop(&z))) {
        do {
            ++hash;
            if (!mnode_is_empty(c0->right)) stack_push(&z,      c0->right);
            if (!mnode_is_empty(c0->left))  stack_push(&z, c1 = c0->left);
        } while (!is_null(c0 = stack_pop(&z)));
    }

    v  = mnode_hash(c1, s->type);
    stack_push(&z, s->root->right);

    if (!mnode_is_empty(c0 = stack_pop(&z))) {
        do {
            ++hash;
            if (!mnode_is_empty(c0->right)) stack_push(&z, c1 = c0->right);
            if (!mnode_is_empty(c0->left))  stack_push(&z,      c0->left);
        } while (!is_null(c0 = stack_pop(&z)));
    }

    v += mnode_hash(c1, s->type);

    return (hash ^ v) + VTYPE_MAP;
}

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

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

void map_free(map_t* x) {
    mnode_t *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;
    size_t    n;
    rbnode_t* c;

    stack_init(&z);
    stack_push(&z, x->root);

    n = 0;

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

    return n;
}

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

int map_compare(const map_t* s0, const map_t* s1) {
    stack_t        z;
    mnode_t *c0, *c1;
    int          cmp;

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

    stack_init(&z);
    stack_push_many(&z, 2, (void*)s1, (void*)s0);

    cmp = 0;

    do {
        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 ((cmp = mnode_compare(c0, c1, s0->type))) {
            if (c0->left == c1->right) {  // == mnode_empty
                          cmp = mnode_compare(c0->right, c1, s0->type);
                if (!cmp) cmp = mnode_compare(c0, c1->left, s0->type);
            } else if (c0->right == c1->left) { // == mnode_empty
                          cmp = mnode_compare(c0, c1->right, s0->type);
                if (!cmp) cmp = mnode_compare(c0->left, c1, s0->type);
            }

            if (cmp) {
                stack_flush(&z);
                return cmp;
            }
        } else stack_push_many(&z, 4, c1->right, c0->right, c1->left, c0->left);

    } while (!is_null(z.value));

    return 0;
}