/* Do not remove the headers from this file! see /USAGE for more info. */

/* grammar related stuff */
private nosave string array ids;
private nosave string array plurals;
private nosave string array adjs;
private int quantity;
private string primary_id, primary_adj;

/* calculated internally */
private nosave mixed internal_short;
/* unique objects are refered to as 'the' instead of 'a' */
private nosave int unique;
/* ... As are plural objects (eg: stairs) */
private nosave int plural;
/*
 * proper_name: Proper_name should only be set for objects who should not
 *     be refered to as "a xxx" or "the xxx"
 */
private nosave mixed proper_name;


/*
** Can be implemented by subclasses to provide additional stuff dynamically
*/
string array fake_item_id_list();
int is_visible();
string invis_name();
int test_flag(mixed);

varargs mixed call_hooks(string, mixed, mixed);
private void resync();
varargs string get_attributes(object ob);

void create() 
{
    parse_init();
    ids = ({});
    plurals = ({});
    adjs = ({});
    resync();
}

//:FUNCTION set_proper_name
//Set the proper name of an object.  Objects with proper names never have
//adjectives added in front of their names.
nomask void set_proper_name(string str)
{
    proper_name = str;
    resync();
}

//:FUNCTION set_unique
//Unique objects are always refered to as 'the ...' and never 'a ...'
void set_unique(int x)
{
    unique = x;
}

//:FUNCTION query_unique
//Return the value of 'unique'
int query_unique()
{
    return unique;
}

//:FUNCTION set_plural
//Plural objects are referred to as "the", not "a"
void set_plural( int x )
{
    plural = x;
}

//:FUNCTION query_plural
//Return the value of plural
int query_plural()
{
    return plural;
}


private void resync() {
    if (!proper_name) {
	if (!primary_id && sizeof(ids))
	    primary_id = ids[0];
	if (!primary_adj && sizeof(adjs))
	    primary_adj = adjs[0];

	if (primary_id) {
	    if (primary_adj)
		internal_short = primary_adj + " " + primary_id;
	    else
		internal_short = primary_id;
	}
	else {
	    internal_short = "nondescript thing";
	}
    } else
	internal_short = proper_name;
    parse_refresh();
}

mixed ob_state() {
    return internal_short;
}

//:FUNCTION short
//Return the 'short' description of a object, which is the name by which
//it should be refered to
string short()
{
    if (!is_visible())
	return invis_name();
    return evaluate(internal_short);
}

//### obsolete?
//### I really don't think so.  Isn't it used by multiple copies of the same object ?
string plural_short() {
    if (!query_plural())
	return pluralize(short());
    else return short();
}

/* More could be done with these quantity functions, assuming that they 
 * belong here, which I haven't decided yet, thoughts? -- Tigran */
void set_quantity( int x ){
    quantity = x;
}

int query_quantity()
{
    return quantity;
}

//### should be somewhere else?
string add_article(string str) {
    if (quantity ) return "some " + str;
    switch (str[0]) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
	return "an "+str;
    }
    return "a "+str;
}

//:FUNCTION the_short
//return the short descriptions, with the word 'the' in front if appropriate
string the_short() {
    if(!is_visible())
	return invis_name();

    if (!proper_name) return "the "+short();
    return evaluate(proper_name);
}

//:FUNCTION a_short
//return the short descriptions, with the word 'a' in front if appropriate
string a_short() {
    if(!is_visible())
	return invis_name();

    if (plural || unique) return the_short();
    if (!proper_name) return add_article(short());
    return evaluate(proper_name);
}

/****** the id() functions ******/
int id(string arg)
{
    if(!arrayp( ids)) return 0;
    return member_array(arg,ids) != -1;
}

int plural_id( mixed arg ) {
    if( !arrayp( plurals)) return 0;
    return member_array(arg, plurals) != -1;
}

// In the following, id handles _both_ id and plural, except in the _no_plural
// cases.
/****** add_ ******/

//:FUNCTION add_adj
//:Adds adjectives.  The first one _DOES NOT_ become the prim
//:primary adjective when using add_adj().
void
add_adj(string array adj... )
{
    if(!arrayp(adjs)) 
	adjs = adj;
    else
	adjs += adj;
    resync();
}

//:FUNCTION add_plural
//Add a plural id
void add_plural( string array plural... )
{
    if(!arrayp(plurals))
	plurals = plural;
    else 
	plurals += plural;
    resync();
}

//:FUNCTION add_id_no_plural
//Add an id without adding the corresponding plural
void add_id_no_plural( string array id... ) {
    // set new primary
    if(!arrayp(ids))
	ids = id;
    else
	ids += id;
    resync();
}

//:FUNCTION add_id
//Add an id and its corresponding plural
void add_id( string array id... )
{
    if(!arrayp(ids))
	ids = id;
    else
	ids += id;
    plurals += map(id, (: pluralize :));
    resync();
}

/****** set_ ******/
//These actually add, but the first argument becomes the primary id/adjective
void set_id( string array id... ) {
    ids = id + ids; // Ensure proper order for resync of primary id
    plurals += map(id, (: pluralize :));
    primary_id = 0;
    resync();
}

void set_adj( string array adj... ) {
    if(!arrayp(adjs))
	adjs = adj;
    else
	adjs = adj + adjs; // Ensure proper order for resync of primary adj
    primary_adj = 0;
    resync();
}

/****** remove_ ******/
//:FUNCTION remove_id
//Remove the given id
void remove_id( string array id... )
{
    if(!arrayp(ids))
	return;
    ids -= id;
    plurals -= map(id, (: pluralize :));
    primary_id = 0;
    resync();
}

void remove_adj( string array adj ... ) {
    if(!arrayp(ids))
	return;
    adjs -= adj;
    primary_adj = 0;
    resync();
}

/****** clear_ ******/

//:FUNCTION clear_id
//removes all the ids of an object.
void clear_id() {
    ids = ({ });
    plurals = ({ });
    primary_id = 0;
    resync();
}

//:FUNCTION clear_adj
//Remove all the adjectives from an object
void clear_adj() 
{
    adjs = ({ });
    primary_adj = 0;
    resync();
}

/****** query_ ******/

//:FUNCTION query_id
//Returns an array containing the ids of an object
string array query_id() {
    string array fake = this_object()->fake_item_id_list();

    if (fake) return fake + ids;
    else return ids;
}

//:FUNCTION query_primary_id
//Returns the primary id of an object
string query_primary_id() {
    return primary_id;
}

//:FUNCTION query_primary_adj
//Returns the primary adj of an object
string query_primary_adj() {
    return primary_adj;
}

//:FUNCTION query_primary_name
//Returns the primary name (primary adj + primary id) of an object
string query_primary_name() {
    return (primary_adj ? primary_adj + " " : "") + primary_id;
}

//:FUNCTION query_adj
//return the adjectives
string array query_adj()
{
    return adjs;
}

/****** parser interaction ******/

string array parse_command_id_list()
{
    if (test_flag(INVIS)) return ({ });
    //### should strip non-alphanumerics here; might need an efun to do it
    //### efficiently
    return query_id();
}

nomask string array parse_command_plural_id_list() {
    if (test_flag(INVIS)) return ({ });
    return plurals;
}

nomask string array parse_command_adjectiv_id_list() {
    if (test_flag(INVIS)) return ({ });
    return adjs;
}