/*    /daemon/emote.c
 *    From the Dead Souls Object Library
 *    A centralized soul handler
 *    Created by Descartes of Borg 961207
 *    Version: @(#) soul.c 1.11@(#)
 *    Last modified: 96/12/15
 */

#include <lib.h>
#include <pov.h>
#include <privs.h>
#include <save.h>
#include <daemons.h>

inherit LIB_DAEMON;

class emote {
    string ErrorMessage;
    mapping Rules;
}

class rule {
    mixed array Message;
    string array Adverbs;
}

private mapping Emotes = ([]);
private string array Adverbs = ({});

static private void validate() {
    if(!this_player()) return 0;
    if( !(master()->valid_apply(({ "ASSIST" }))) && 
            !member_group(this_player(), "EMOTES") )
        error("Illegal attempt to access SOUL_D: "+get_stack()+" "+identify(previous_object(-1)));
}

varargs int AddAdverbs(string array advs...) {
    validate();
    Adverbs = distinct_array(Adverbs + advs);
    eventSave();
    return 1;
}

varargs int AddRule(string verb, string rle, mixed array msg,
        string array advs) {
    class emote e = Emotes[verb];
    class rule r;
    validate();

    if( !e ) {
        return 0;
    }
    r = new(class rule);
    r->Message = msg;
    r->Adverbs = (advs || ({}));
    e->Rules[rle] = r;
    if( catch(parse_add_rule(verb, rle)) ) {
        return 0;
    }
    eventSave();
    return 1;
}

int AddVerb(string verb, string err) {
    class emote e;
    validate();

    if( Emotes[verb] ) {
        return 0;
    }
    else {
        e = new(class emote);
    }
    e->ErrorMessage = err;
    e->Rules = ([]);
    Emotes[verb] = e;
    eventSave();
    return 1;
}

int RemoveRule(string emt, string rle) {
    class emote e = Emotes[emt];
    validate();

    if( !e ) {
        return 0;
    }
    map_delete(e->Rules, rle);
    eventSave();
    return 1;
}

int RemoveVerb(string verb) {
    validate();
    map_delete(Emotes, verb);
    eventSave();
    return 1;
}

string array GetAdverbs() {
    return copy(Adverbs);
}

varargs mixed array GetChannelEmote(string emote, string parse, string args) {
    class emote e = Emotes[emote];
    mapping adverb = ([]);
    class rule r;

    if( !e ) {
        return 0;
    }
    r = e->Rules[parse];
    if( !r ) {
        parse = replace_string(parse, "LIV", "LVS");
        r = e->Rules[parse];
        if( !r ) {
            return 0;
        }
    }
    if( args ) {
        string array pool = r->Adverbs;
        int any_adv = (member_array("*", pool) != -1);

        if( member_array("-", pool) != -1 ) {
            pool += Adverbs;
        }
        if( !any_adv && member_array(args, pool) == -1 ) {
            string array matches = regexp(pool, "^" + args);

            if( !sizeof(matches) ) {
                return 0;
            }
            adverb = ([ "$adverb" : matches[0] ]);
        }
        else {
            adverb = ([ "$adverb" : args ]);
        }
    }
    return ({ r->Message, adverb });
}

string array GetEmotes() {
    return keys(Emotes);
}

string GetErrorMessage(string verb) {
    class emote e = Emotes[verb];

    if( !e ) {
        return 0;
    }
    return e->ErrorMessage;
}

string GetHelp(string arg) {
    class emote e;
    string array rls;
    string str;

    if( arg == "soul" ) {
        str = "Your \"soul\" is a system of expressions you can use "
            "to express how you are feeling.  Though it does not really "
            "cause anything to happen, other people, including NPC's, may "
            "react to your emotions, especially when they are violent or "
            "negative.\n\n"
            "Some soul commands allow you to express an adverb to give some "
            "sort of emphasis to the expression.  Some commands are limited "
            "to a certain set of adverbs, while most commands will allow you "
            "to choose from the list of system wide adverbs given below.  "
            "You may always use your racial adverb in any expression "
            "allowing an adverb.  A racial adverb is simply a way of "
            "emoting unique to your race, like \"smile gnomishly\".\n\n"
            "For a list of soul commands, try <help feelings>.\n\n"
            "The list of system adverbs are:\n";
        str += format_page(sort_array(Adverbs, 1), 5);
        return str;
    }
    e  = Emotes[arg];
    if( !e ) {
        return 0;
    }
    rls = keys(e->Rules);
    if( !sizeof(rls) ) {
        return "This emote is not yet valid.";
    }
    else {
        int w = member_array("", rls);

        if( w > 0 ) {
            if( w < sizeof(rls) -1 ) {
                rls = ({ rls[w], rls[0..(w-1)]..., rls[(w+1)..]... });
            }
            else {
                rls = ({ rls[w], rls[0..(w-1)]... });
            }
        }
    }
    if( rls[0] == "" ) {
        str = "Syntax: <" + arg + ">\n";
    }
    else {
        class rule r = e->Rules[rls[0]];
        string array pool = r->Adverbs;
        int all_advs = (member_array("-", r->Adverbs) != -1);
        int anything = (member_array("*", r->Adverbs) != -1);
        string rule = rls[0];

        rule = replace_string(rule, "LIV", "SINGLE_LIVING");
        rule = replace_string(rule, "LVS", "ONE_OR_MORE_LIVINGS");
        if( anything ) {
            rule = replace_string(rule, "STR", "PHRASE");
        }
        else if( all_advs ) {
            pool = (pool - ({ "-", "*" })) + ({ "system adverbs" });
            rule = replace_string(rule, "STR", "ADVERB");
        }
        str = "Syntax: <" + arg + " " + rule + ">\n";
        if( !anything ) {
            if( sizeof(pool) ) {
                str += " Adverbs: " + item_list(pool);
            }
        }
        str += "\n";
    }
    if( sizeof(rls) > 1 ) {
        rls = rls[1..];
        foreach(string rule in rls) {
            class rule r = e->Rules[rule];

            if( rule == "" ) {
                str += "        <" + arg + ">\n";
            }
            else {
                string array pool = r->Adverbs;
                int all_advs = (member_array("-", r->Adverbs) != -1);
                int anything = (member_array("*", r->Adverbs) != -1);

                rule = replace_string(rule, "LIV", "SINGLE_LIVING");
                rule = replace_string(rule, "LVS", "ONE_OR_MORE_LIVINGS");
                if( anything ) {
                    rule = replace_string(rule, "STR", "PHRASE");
                }
                else if( all_advs ) {
                    pool = (pool - ({ "-", "*" })) + ({ "system adverbs" });
                    rule = replace_string(rule, "STR", "ADVERB");
                }
                str += "        <" + arg + " " + rule + ">";
                if( !anything ) {
                    if( sizeof(pool) ) {
                        str += " Adverbs: " + item_list(pool);
                    }
                }
                str += "\n";
            }
        }
    }
    str += "\n";
    str += capitalize(arg) + " is a soul command and affects nothing.\n";
    str += "System adverbs are listed in <help soul>.\n";
    str += "SINGLE_LIVING: You can target a single living thing\n"
        "ONE_OR_MORE_LIVINGS: You can target multiple people using \"all\"\n"
        "PHRASE: Any random phrase\n"
        "ADVERB: Any adverb from the list of supported adverbs, or your "
        "racial adverb.";
    return str;
}

void SetErrorMessage(string verb, string msg) {
    class emote e = Emotes[verb];
    validate();

    if( !e ) {
        AddVerb(verb, msg);
    }
    else {
        e->ErrorMessage = msg;
        eventSave();
    }
}

string GetRaceAdverb(mixed who) {
    string res;

    if( objectp(who) ) {
        res = who->GetRace();
    }

    if( !res ) {
        return "godly";
    }
    switch(res) {
        case "gnome": return "gnomishly";
        case "elf": return "elvenly";
        case "half-elf": return "half-elvenly";
        case "orc": return "orcishly";
        case "half-orc": return "half-orcishly";
        default: return res + "ly";
    }
}

mapping GetRules(string emote) {
    class emote e = Emotes[emote];
    mapping m = ([]);

    if( !e ) {
        return 0;
    }
    foreach(string rle, class rule r in e->Rules) {
        m[rle] = ({ r->Adverbs, r->Message });
    }
    if( !master()->valid_apply(({ PRIV_ASSIST }))  
            || (this_player() && !member_group(this_player(), "EMOTES"))){
        return copy(m);
    }
    return m;
}

int CanTarget(object who, string verb, object target, string rule) {
    if( Emotes[verb] ) {
        return 1;
    }
    else {
        return 0;
    }
}

mixed can_verb_rule(string verb, string rle) {
    class emote e = Emotes[verb];
    class rule r;

    if( !e ) {
        return 0;
    }
    r = e->Rules[rle];
    if( !r ) {
        return 0;
    }
    return 1;
}

varargs mixed do_verb_rule(string verb, string rle, mixed args...) {
    object env = environment(this_player());
    class emote e = Emotes[verb];
    class rule r = e->Rules[rle];
    string adv = 0;

    switch( rle ) {
        case "":
            args = 0;
            adv = 0;
            break;

        case "LIV": case "at LIV": case "with LIV": case "to LIV":
        case "around LIV": case "on LIV":
        case "OBJ": case "at OBJ": case "with OBJ": case "to OBJ":
        case "LVS": case "at LVS": case "with LVS": case "to LVS":
        case "around LVS": case "on LVS":
            args = args[0];
            adv = 0;
            break;

        case "STR": case "for STR": case "about STR":
            adv = args[0];
            args = 0;
            break;

        case "STR LIV": case "STR at LIV": case "STR with LIV":
        case "STR around LIV": case "STR on LIV":
        case "for STR LIV": case "for STR to LIV":
        case "STR OBJ": case "STR at OBJ": case "STR with OBJ":
        case "STR LVS": case "STR at LVS": case "STR with LVS":
        case "STR around LVS": case "STR on LVS":
        case "for STR LVS": case "for STR to LVS":
            adv = args[0];
            args = args[1];
            break;

        case "LIV STR": case "at LIV STR": case "LIV of STR": case "with LIV STR":
        case "around LIV STR": case "on LIV STR":
        case "LIV for STR": case "to LIV for STR":
        case "OBJ STR": case "at OBJ STR": case "OBJ of STR": case "with OBJ STR":
        case "LVS STR": case "at LVS STR": case "LVS of STR": case "with LVS STR":
        case "around LVS STR": case "on LVS STR":
        case "LVS for STR": case "to LVS for STR":
            adv = args[1];
            args = args[0];
            break;

        default:
            this_player()->eventPrint("Unknown soul syntax.");
            return 1;
    }
    if( arrayp(args) ) {
        args = filter(args, (: objectp :));
    }
    if( adv ) {
        string array pool = r->Adverbs + ({ GetRaceAdverb(this_player()) });
        int any_adv = (member_array("*", pool) != -1);

        if( member_array("-", pool) != -1 ) {
            pool += Adverbs;
        }
        if( !any_adv && member_array(adv, pool) == -1 ) {
            string array matches = regexp(pool, "^" + adv);

            if( !sizeof(matches) ) {
                this_player()->eventPrint("You cannot " + verb + " " + adv +
                        "!");
                return 1;
            }
            adv = matches[0];
        }
        send_messages(r->Message[0], r->Message[1], this_player(), args, env,
                ([ "$adverb" : adv ]));
        if( args ) {
            args->eventReceiveEmote(this_player(), verb, adv);
        }
    }
    else {
        send_messages(r->Message[0], r->Message[1], this_player(), args, env);
        if( args ) {
            args->eventReceiveEmote(this_player(), verb);
        }
    }
    return 1;
}

static void create() {
    SetSaveFile(SAVE_SOUL);
    daemon::create();
    if(!file_exists(GetSaveFile()) && 
            file_exists(old_savename(GetSaveFile()))){
        cp(old_savename(GetSaveFile()), GetSaveFile());
    }
    SetNoClean(1);
    parse_init();
    foreach(string verb, class emote data in Emotes) {
        foreach(string rle in keys(data->Rules)) {
            parse_add_rule(verb, rle);
        }
    }
    eventSave();
}