/*    /secure/cmds/admins/addemote.c
 *    From the Dead Souls Mud Library
 *    A sane command for doing emote addition
 *    Created by Descartes of Borg 961208
 *    Version: @(#) addemote.c 1.2@(#)
 *    Last modified: 96/12/14
 */

#include <lib.h>
#include <daemons.h>
#include <message_class.h>

inherit LIB_DAEMON;

static void MainMenu();
static void EditErrorMessage(string emote);
static void ShowEmote(string emote);
static void AddEmote(string emote);
static void AddRule(string rule, string emote);

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

static void EnterEmote(string emote, string array emotes) {
    int x = to_int(emote);
    validate();
    if( x < 1 || x > sizeof(emotes) ) {
        if( member_array(emote, emotes) == -1 ) {
            if( emote[0] == 'q' ) {
                return;
            }
            MainMenu();
            return;
        }
    }
    else {
        emote = emotes[x-1];
    }
    ShowEmote(emote);
}

static void EnterEditChoice(string str, string array rules, string emote) {
    int x = to_int(str);
    validate();
    if( x < 1 || x > sizeof(rules) ) {
        if( member_array(str, rules) == -1 ) {
            if( !str || str == "" ) {
                MainMenu();
                return;
            }
            if( str[0] == 'q' ) {
                return;
            }
            else if( str[0] == 'e' ) {
                EditErrorMessage(emote);
                return;
            }
            else if( str[0] == 'a' ) {
                this_player()->eventPrint("Enter verb rule: ", MSG_PROMPT);
                input_to((: AddRule :), emote);
                return;
            }
            else {
                ShowEmote(emote);
                return;
            }
        }
        AddRule(str, emote);
    }
    else {
        AddRule(rules[x-1], emote);
    }
}

static void AddAdverbs(string adv, string emote, string array rules,
        string array verbs, string msg) {
    string array adverbs;
    validate();
    if( !adv || adv == "" ) {
        adverbs = ({});
    }
    else {
        adverbs = map(explode(adv, ","), (: trim :));
    }
    foreach(string rule in rules) {
        SOUL_D->AddRule(emote, rule, ({ verbs, msg }), adverbs);
    }
    this_player()->eventPrint("Emote '" + emote + "' added.");
}

static void AddMessage(string msg, string emote, string array rules,
        string array verbs) {
    validate();
    if( !msg || msg == "" ) {
        this_player()->eventPrint("Which message? [q to quit] ", MSG_PROMPT);
        input_to((: AddMessage :), emote, rules, verbs);
        return;
    }
    if( lower_case(msg) == "q" ) {
        this_player()->eventPrint("Addition of rule aborted.");
        return;
    }
    this_player()->eventPrint("Enter adverbs: ", MSG_PROMPT);
    input_to((: AddAdverbs :), emote, rules, verbs, msg);
}

static void AddVerbs(string list, string emote, string array rules) {
    string array verbs = map(explode(list, ","), (: trim :));
    validate();

    this_player()->eventPrint("Enter message: ", MSG_PROMPT);
    input_to((: AddMessage :), emote, rules, verbs);
}

static void AddRule(string rule, string emote) {
    string array rules = map(explode(rule, ","), (: trim :));
    validate();

    if( !sizeof(rules) ) {
        rules = ({ "" });
    }
    this_player()->eventPrint("Enter the verbs: ", MSG_PROMPT);
    input_to((: AddVerbs :), emote, rules);
}

static void AddErrorMessage(string msg, string emote) {
    validate();
    if( !msg || msg == "" ) {
        this_player()->eventPrint("Which message? [q to quit] ", MSG_PROMPT);
        input_to((: AddErrorMessage :), emote);
        return;
    }
    if( !emote || emote == "" ) {
        this_player()->eventPrint("Which emote? [q to quit] ", MSG_PROMPT);
        input_to((: AddEmote :));
        return;
    }	
    emote = lower_case(emote);
    if( lower_case(msg) == "q" ) {
        this_player()->eventPrint("Addition of emote aborted.");
        return;
    }
    SOUL_D->AddVerb(emote, msg);
    this_player()->eventPrint("Enter a parser rule for " + emote + ": ",
            MSG_PROMPT);
    input_to((: AddRule :), emote);
}

static void AddEmote(string emote) {
    validate();
    if( !emote || emote == "" ) {
        this_player()->eventPrint("Which emote? [q to quit] ", MSG_PROMPT);
        input_to((: AddEmote :));
        return;
    }
    emote = lower_case(emote);
    if( emote == "q" ) {
        this_player()->eventPrint("Addition of emote aborted.");
        return;
    }
    this_player()->eventPrint("Enter error message: ", MSG_PROMPT);
    input_to((: AddErrorMessage :), emote);
}

static void MainMenu() {
    string array emotes = SOUL_D->GetEmotes();
    string array display = allocate(sizeof(emotes));
    int array screen = this_player()->GetScreen() || ({ 80, 25 });
    string tmp;
    int i;
    validate();

    tmp = center("Dead Souls Emote Editor", screen[0]) + "\n";
    for(i=0; i<sizeof(display); i++) {
        display[i] = "[" + (i+1) + "] " + emotes[i];
    }
    tmp += format_page(display, screen[0]/17) + "\n";
    this_player()->eventPrint(tmp, MSG_SYSTEM);
    this_player()->eventPrint("Enter an emote or 'q' to quit: ", MSG_PROMPT);
    input_to((: EnterEmote :), emotes);
}

static void EditErrorMessage(string emote) {
    validate();
    this_player()->eventPrint("Enter new error message: ", MSG_PROMPT);
    input_to(function(string str, string emote) {
            if( str && str != "" ) {
            SOUL_D->SetErrorMessage(emote, str);
            }
            ShowEmote(emote);
            }, emote);
}

static void ShowEmote(string emote) {
    string err = SOUL_D->GetErrorMessage(emote);
    mapping rules = SOUL_D->GetRules(emote);
    int array screen = this_player()->GetScreen() || ({ 80, 25 });
    string tmp = center("Dead Souls Emote Editor", screen[0]) + "\n\n";
    string tmp2 = "";
    string array rule_array = allocate(sizeof(rules));
    int i = 0;
    validate();

    tmp += "%^GREEN%^Emote%^RESET%^: " + emote + "\n";
    tmp += "%^GREEN%^Error Message%^RESET%^: " + err + "\n";
    tmp += "%^GREEN%^Rules%^RESET%^:\n";
    foreach(string rule, mixed array data in rules) {
        rule_array[i] = rule;
        tmp += "[" + (i+1) + "] \"" + rule + "\": " + data[1][1] + "\n";
        tmp += "  Adverbs: " + wrap(item_list(data[0]), screen[0]) + "\n";
        i++;
    }
    //Following fix courtesy of Alecksy
    this_player()->eventPage(explode(tmp,"\n"), MSG_SYSTEM);
    tmp2 = "Enter rule to edit, 'a' to add rule, 'e' to edit error msg, or 'q' to quit: ";
    this_player()->eventPrint(tmp2,MSG_PROMPT);
    input_to( (: EnterEditChoice :), rule_array, emote );
}

mixed cmd(string args) {
    if( !(master()->valid_apply(({ "ASSIST" }))) &&
            !member_group(this_player(), "EMOTES") ){
        write("You are not admin, nor a member of the EMOTES group.");
        return 1;
    }

    if( !args || args == "" ) {
        this_player()->eventPrint("Enter emote name: ", MSG_PROMPT);
        input_to((: AddEmote :));
    }
    else if( args[0] == '-' ) {
        if( args == "-edit" ) {
            MainMenu();
        }
        else if( args == "-add") {
            this_player()->eventPrint("Enter emote name: ", MSG_PROMPT);
            input_to((: AddEmote :));
        }
        else {
            MainMenu();
        }
    }
    else {
        if( member_array(args, SOUL_D->GetEmotes()) == -1 ) {
            AddEmote(args);
        }
        else {
            ShowEmote(args);
        }
    }
    return 1;
}

string GetHelp(){
    return ("Syntax: <addemote>\n"
            "        <addemote EMOTE>\n"
            "        <addemote -edit>\n"
            "        <addemote -add>\n\n"
            "You must be admin or member of the EMOTES group to use this command.\n\n"
            "Used to add and edit emotes in the soul daemon using complex "
            "rules and the Dead Souls messaging system.  In order to add "
            "a new emote using this command, you need to know the following "
            "information:\n"
            "\t* Verb parse rule\n"
            "\t* Verbs to be conjugated in the message\n"
            "\t* The messaging system generic format for the message\n"
            "\t* Any adverbs supported specially for the message\n\n"
            "The verb parse rule is a set of tokens governing how the "
            "command should be entered. The only tokens supported by the "
            "soul are LIV (for one living thing), LVS (for one to many living "
        "things), and STR (for any arbitrary string).  In addition, the "
            "rule can contains prepositions like to, at, on, about, etc.  "
            "For example, to allow a player to do <smile at descartes>, you "
            "need the parse rule <at LIV> or <at LVS>.  <smile oddly at "
            "descartes> would be <STR at LIV> or <STR at LVS>.\n"
            "In general, you should allow players to enter in commands using "
            "correct English and a syntax without prepositions.  For "
            "example, since we have <at LVS>, we should also allow "
            "<LVS>.  To support identical rules like this, when the "
            "<addemote> command asks for a parser rule, you can enter in "
            "multiple identical rules on the same line, separated by "
            "commas:\n"
            "Enter parser rule: at LVS,LVS\n\n"
            "The next step is defining which verbs need conjugating in your "
            "message for the emote.  With the smile emote, the only verb is "
            "\"smile\".  However, for more complex emotes, you may have "
            "multiple verbs which need conjugating.  Just enter them as a "
            "comma separated list.  For example, if you have an emote that "
            "should print the message \"Descartes rants and raves.\", then "
            "you will need to enter the verbs rant and rave:\n"
            "Enter verbs: rant,rave\n\n"
            "The next step is specifying the message that gets shown.  Your "
            "message uses place holders, also called tokens, to stand in "
            "for bits of the message that change depending on point of "
            "view.  In the rant and rave example, Descartes would see:\n"
            "You rant and rave.\n"
            "Everyone else sees:\n"
            "Descartes rants and raves.\n"
            "The only thing that stays the same is the word \"and\".  You "
            "need tokens to stand for the rest.  A full list of tokens is "
            "specified in <help messaging> and they all begin with a $ sign.  "
            "One extremely important thing to remember is that you need "
            "the exact same number of $agent_verb or $target_verb tokens in "
            "your message as the number of verbs you specified for "
            "conjugation.  In the rant and rave example, I need two verb "
            "tokens to match up with my two verbs I am conjugating.  They "
            "will be handled in the order they appear.  In other words, the "
            "rant verb will match to the first verb token, and the rave "
            "verb will match to the second verb token.  Verb tokens count "
            "as any combination of $agent_verb and $target_verb:\n"
            "Enter message: $agent_name $agent_verb and $agent_verb.\n\n"
            "The last thing you need to enter is a list of adverbs.  "
            "As with other lists, this list is comma separated.  And as with "
            "other bits of this system, it has a little complexity to it.  "
            "If you do not enter anything, then no adverbs are used for this "
            "rule.  In fact, you must specify a STR token in the rule for "
            "adverbs to be relevant.  If you do specify an STR rule, you "
            "should specify something on the adverb line.  Any adverbs you "
            "enter are considered special adverbs just for this rule.  If "
            "you wish the general list of adverbs to be available as well, "
            "you can enter a - as one of the adverbs.  If you wish the "
            "player to be able to add anything that comes to mind, enter "
            "a *:\n"
            "Enter adverbs: -");
}