/* Copyright (c) 1992 by David Moore.  All rights reserved. */
/* flags.c,v 2.8 1994/02/21 08:32:48 dmoore Exp */
#include "config.h"

#include "db.h"
#include "params.h"
#include "flags.h"
#include "buffer.h"
#include "externs.h"

struct object_type_name {
    const char *long_name;
    const char *short_name;
    object_flag_type kind;
};

static struct object_type_name type_names [] = {
    { "ROOM",           "R" },
    { "THING",          ""  },
    { "EXIT/ACTION",    "E" },
    { "PLAYER",         "P" },
    { "FORTH",          "F" },
    { "---",            ""  },
    { "GARBAGE",        ""  },
    { "NOTYPE",         ""  },
    { NULL, NULL }
};

struct object_flag_name {
    const char *long_name;
    const char *short_name;
    object_flag_type flag;
    object_flag_type kind;
};

static struct object_flag_name flag_names[] = {
#ifdef DRUID_MUCK
    { "INVISIBLE","I", INVISIBLE, TYPE_PLAYER },
#endif
#ifdef GOD_FLAGS
    { "GOD",	  "G", GOD,	 TYPE_ANY },
#endif
    { "WIZARD",   "W", WIZARD,   TYPE_ANY },
    { "LINK_OK",  "L", LINK_OK,  TYPE_ANY },
    { "DARK",     "D", DARK,     TYPE_ROOM },
    { "DARK",     "D", DARK,     TYPE_PLAYER },
    { "DARK",     "D", DARK,     TYPE_THING },
    { "DARK",     "D", DARK,     TYPE_EXIT },
    { "DEBUG",    "D", DEBUG,    TYPE_PROGRAM },
    { "STICKY",   "S", STICKY,   TYPE_ROOM },
    { "STICKY",   "S", STICKY,   TYPE_PLAYER },
    { "STICKY",   "S", STICKY,   TYPE_THING },
    { "STICKY",   "S", STICKY,   TYPE_EXIT },
    { "SETUID",   "S", SETUID,   TYPE_PROGRAM },
    { "BUILDER",  "B", BUILDER,  TYPE_ANY },
    { "CHOWN_OK", "C", CHOWN_OK, TYPE_ANY },
    { "JUMP_OK",  "J", JUMP_OK,  TYPE_ANY },
    { "HAVEN",    "H", HAVEN,    TYPE_ANY },
    { "ABODE",    "A", ABODE,    TYPE_ANY },
    { "MURKY",    "M", MURKY,    TYPE_ROOM},
    { "MUCKER",   "M", MUCKER,   TYPE_PLAYER },
    { "MUCKER",   "M", MUCKER,   TYPE_THING },
    { "MUCKER",   "M", MUCKER,   TYPE_EXIT },
    { "MUCKER",   "M", MUCKER,   TYPE_PROGRAM },
    { "QUELL",    "Q", QUELL,    TYPE_ANY },
    { "LINE_NUMBERS",  "",  LINE_NUMBERS, TYPE_PLAYER },
    { NULL, NULL, 0, 0 }
};


const char *unparse_flag(const dbref thing, object_flag_type flag, const int long_name)
{
    static Buffer buf;
    struct object_flag_name *temp;

    Bufcpy(&buf, "");
    for (temp = flag_names; temp->long_name; temp++) {
	if ((flag & temp->flag)
            && ((temp->kind == TYPE_ANY) || (Typeof(thing) == temp->kind))) {
	    if (long_name) Bufcat(&buf, temp->long_name);
	    else Bufcat(&buf, temp->short_name);
	}
    }

    return Buftext(&buf);
}


const char *unparse_flags(const dbref thing)
{
    static Buffer buf;
    struct object_flag_name *temp;

    /* Stick in the type, P, F, E, etc. */
    Bufcpy(&buf, type_names[Typeof(thing)].short_name);

    /* Loop building up the other flags. */
    for (temp = flag_names; temp->long_name; temp++) {
	if (HasFlag(thing, temp->flag)
	    && ((temp->kind == TYPE_ANY)
		|| (Typeof(thing) == temp->kind))) {
	    /* This object has both this flag set, and is the right type. */
	    Bufcat(&buf, temp->short_name);
	}
    }

    return Buftext(&buf);
}


const char *unparse_long_flags(const dbref thing, const int dump_format)
{
    struct object_flag_name *temp;
    int saw_a_flag = 0;
    static Buffer buf;

    /* Stick in the type. */
    if (!dump_format) {
	Bufcpy(&buf, "Type: ");
    } else {
	Bufcpy(&buf, "");
    }
    Bufcat(&buf, type_names[Typeof(thing)].long_name);

    /* Loop building up the other flags. */
    for (temp = flag_names; temp->long_name; temp++) {
	if (HasFlag(thing, temp->flag)
	    && ((temp->kind == TYPE_ANY)
		|| (Typeof(thing) == temp->kind))) {
	    /* This object has both this flag set, and is the right type. */
	    if (!dump_format && !saw_a_flag) {
		Bufcat(&buf, "  Flags:");
		saw_a_flag++;
	    }
	    Bufcatlist(&buf, " ", temp->long_name, NULL);
	}
    }

    return Buftext(&buf);
}


object_flag_type parse_flags(const char *flagstr)
{
    object_flag_type objtype, result;
    const char *p;
    struct object_flag_name *tflag;
    struct object_type_name *ttype;
    Buffer buf;

    result = 0;
    
    if (!flagstr) return 0;

    /* Copy out the type of the object. */
    Bufcpy(&buf, "");
    for (p = flagstr; *p && (*p != ' '); p++)
	Bufcat_char(&buf, *p);
   
    /* Move up flagstr to be just after found type. */
    if (*p) flagstr = p + 1;
    else flagstr = p;

    /* Lookup the type. */
    p = Buftext(&buf);
    for (ttype = type_names; ttype->long_name; ttype++) {
	if (!muck_stricmp(p, ttype->long_name)) {
	    objtype = result = ttype - type_names;
	    break;
	}
    }

    /* Loop collecting all of the other flags. */
    while (*flagstr) {
	Bufcpy(&buf, "");
	for (p = flagstr; *p && (*p != ' '); p++)
	    Bufcat_char(&buf, *p);

	/* Move up flagstr to just after found flag. */
	if (*p) flagstr = p + 1;
	else flagstr = p;

	/* Lookup the flag. */
	p = Buftext(&buf);
	for (tflag = flag_names; tflag->long_name; tflag++) {
	    if ((!muck_stricmp(p, tflag->long_name))
		&& ((tflag->kind == TYPE_ANY)
		    || (objtype == tflag->kind))) {
		result |= tflag->flag;
		break;
	    }
	}
    }

    return result;
}


/* Lookup the flag for a given object and string version of flag name.
   If no such flag return BAD_FLAG (-1). */
int which_flag(object_flag_type type, const char *flagstr)
{
    struct object_flag_name *temp;    

    /* Loop building up the other flags. */
    for (temp = flag_names; temp->long_name; temp++) {
	if ((temp->kind != TYPE_ANY) && (temp->kind != type))
	    continue;

	if (muck_strprefix(flagstr, temp->short_name)) {
	    if (muck_strprefix(temp->long_name, flagstr)) {
		return temp->flag;
	    } else {
		/* Matched beginning of a valid flag, but remainder is bad. */
		return BAD_FLAG;
	    }
	}
    }

    return BAD_FLAG;		/* Didn't end up matching anything. */
}