#include "std.h"
#include "comm.h"
#include "master.h"
#include "efuns_main.h"
#include "otable.h"

object_t *master_ob = 0;
function_lookup_info_t *master_applies = 0;

/* Note that now, once the master object loads once, there is ALWAYS a
 * master object, so the only way this can fail is if the master object
 * hasn't loaded yet.  In that case, we return (svalue_t *)-1, and the
 * calling routine should let the check succeed.
 */
svalue_t *apply_master_ob P2(int, fun, int, num_arg)
{
    if (!master_ob) {
        pop_n_elems(num_arg);
        return (svalue_t *)-1;
    }

    if (master_applies[fun].func) {
#ifdef TRACE
        if (TRACEP(TRACE_APPLY)) {
            do_trace("master apply", master_applies[fun].func->funcname, "\n");
        }
#endif
        DEBUG_CHECK(master_ob->flags & O_SWAPPED, "Master object swapped!\n");

        call_direct(master_ob, master_applies[fun].index,
                    ORIGIN_DRIVER, num_arg);
        free_svalue(&apply_ret_value, "apply_master_ob");
        apply_ret_value = *sp--;
        return &apply_ret_value;
    } else {
        pop_n_elems(num_arg);
        return 0;
    }
}

/* Hmm, need something like a safe_call_direct() to do this one */
svalue_t *safe_apply_master_ob P2(int, fun, int, num_arg)
{
    if (!master_ob) {
        pop_n_elems(num_arg);
        return (svalue_t *)-1;
    }
    return safe_apply(applies_table[fun], master_ob, num_arg, ORIGIN_DRIVER);
}

void init_master() {
    char buf[512];
#ifdef LPC_TO_C
    lpc_object_t *compiled_version;
#endif
    object_t *new_ob;

    if (!strip_name(MASTER_FILE, buf, sizeof buf))
        error("Illegal master file name '%s'\n", MASTER_FILE);
    
#ifdef LPC_TO_C
    compiled_version = (lpc_object_t *)lookup_object_hash(buf);
#endif

    new_ob = load_object(buf, compiled_version);
    if (new_ob == 0) {
        fprintf(stderr, "The master file %s was not loaded.\n",
                MASTER_FILE);
        exit(-1);
    }
    set_master(new_ob);
}

static void get_master_applies P1(object_t *, ob) {
    int i;
    
    /* master_applies will be allocated if we're recompiling master_ob */
    if (master_applies)
        FREE(master_applies);
    master_applies = CALLOCATE(NUM_MASTER_APPLIES, function_lookup_info_t,
                               TAG_SIMULS, "get_master_applies");

    for (i = 0; i < NUM_MASTER_APPLIES; i++) {
        char *name = applies_table[i];
        int ind, ri;
        
        if (find_function_by_name(ob, name, &ind, &ri)) {
            master_applies[i].func = find_func_entry(ob->prog, ri);
            master_applies[i].index = ri;
        } else {
            master_applies[i].func = 0;
        }
    }
}

void set_master P1(object_t *, ob) {
#if defined(PACKAGE_UIDS) || defined(PACKAGE_MUDLIB_STATS)
    int first_load = (!master_ob);
#endif
#ifdef PACKAGE_UIDS
    svalue_t *ret;
#endif

    get_master_applies(ob);
    master_ob = ob;
    /* Make sure master_ob is never made a dangling pointer. */
    add_ref(master_ob, "set_master");
#ifndef PACKAGE_UIDS
#  ifdef PACKAGE_MUDLIB_STATS
    if (first_load) {
        set_backbone_domain("BACKBONE");
        set_master_author("NONAME");
    }
#  endif
#else
    ret = apply_master_ob(APPLY_GET_ROOT_UID, 0);
    /* can't be -1 or we wouldn't be here */
    if (!ret) {
        debug_message("No function %s() in master object; possibly the mudlib doesn't want PACKAGE_UIDS to be defined.\n",
                      applies_table[APPLY_GET_ROOT_UID]);
        exit(-1);
    }
    if (ret->type != T_STRING) {
        debug_message("%s() in master object does not work.\n",
                      applies_table[APPLY_GET_ROOT_UID]);
        exit(-1);
    }
    if (first_load) {
        master_ob->uid = set_root_uid(ret->u.string);
        master_ob->euid = master_ob->uid;
#  ifdef PACKAGE_MUDLIB_STATS
        set_master_author(ret->u.string);
#  endif
        ret = apply_master_ob(APPLY_GET_BACKBONE_UID, 0);
        if (ret == 0 || ret->type != T_STRING) {
            debug_message("%s() in the master file does not work\n",
                          applies_table[APPLY_GET_BACKBONE_UID]);
            exit(-1);
        }
        set_backbone_uid(ret->u.string);
#  ifdef PACKAGE_MUDLIB_STATS
        set_backbone_domain(ret->u.string);
#  endif
    } else {
        master_ob->uid = add_uid(ret->u.string);
        master_ob->euid = master_ob->uid;
    }
#endif
}