Chaturbate

Bots Home | Create an App
testtest
Author: zerobug
Description Source Code Launch Bot Current Users
Created by: Zerobug
There are 50 other versions of this script.
// Bot: Super Watchdog
// ---------------
// Bot Class Constants
Bot.BOT_NAME = "Super Watchdog";
Bot.BOT_VERSION = "4.0.2";
// ---------------
// Convert true/false to on/off
Boolean.prototype.toOnOff = function () {
    return (this == true ? "ON" : "OFF");
};

// Convert true/false to yes/no
Boolean.prototype.toYesNo = function () {
    return (this == true ? "YES" : "NO");
};

// ---------------
// Convert true/false to enabled/disabled
Boolean.prototype.toEnDis = function () {
    return (this == true ? "ENABLED" : "DISABLED");
};

// Check if two dates match
Date.prototype.match = function (dDate) {
    return this.getTime() == dDate.getTime();
};

// Format date
Date.prototype.toDTString = function () {
    var minute = this.getMinutes(),
        hour = this.getHours();
    return "<@>-<@>-<@> <@>:<@><@>".mReplace(
        this.getDate(),
        ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][this.getMonth()],
        this.getFullYear(),
        hour % 12 || 12,
        minute < 10 ? "0" + minute : minute,
        hour < 12 ? "am" : "pm");
};

// Join array elements with comma, with last one by 'and'
Array.prototype.engJoin = function () {
    var outStr = this.join(", ");
    var idx = outStr.lastIndexOf(",");
    if (idx > -1) // Replace last comma with 'and'
        outStr = outStr.substring(0, idx) + " and" + outStr.substring(idx + 1);
    return outStr;
};

// Array minus - Remove matching items in aRemove
Array.prototype.minus = function (aRemove) {
    var outArray = this.slice();
    if (this.length > 0) {
        aRemove.forEach(function (sElement) {
            var idx = outArray.indexOf(sElement);
            if (idx > -1) outArray.splice(idx, 1);
        });
    }
    return outArray;
};

// Shrink an array to at most nMaxEntry entries
Array.prototype.shrink = function (nMaxEntry) {
    while (this.length > nMaxEntry) {
        this.shift();
    }
    return this;
};

// Toggle sElement into / out of aList. Return true if added, false if removed
Array.prototype.toggleEntry = function (sElement) {
    var idx = this.indexOf(sElement);
    if (idx > -1) { // Located
        this.splice(idx, 1); // Remove from list
        return false;
    } else { // Not found
        this.push(sElement); // Add to list
        return true;
    }
};

// Check if sEntry is in the array
Array.prototype.contains = function (sElement) {
    return this.indexOf(sElement) > -1;
};

// Replace each <@> with params, one at a time
String.prototype.mReplace = function (/* , replacing params expected */) {
    var outStr = this;
    for (var i = 0; i < arguments.length; i++)
        outStr = outStr.replace(/<@>/, arguments[i]);
    return outStr;
};

// ---------------
// Util Class
function Util() {
}

// Extend a class
Util.extend = function (subClass, superClass) {
    var F = function () {
    };
    F.prototype = superClass.prototype;
    subClass.prototype = new F();
    subClass.prototype.constructor = subClass;
    subClass.superclass = superClass.prototype;
    if (superClass.prototype.constructor == Object.prototype.constructor) {
        superClass.prototype.constructor = superClass;
    }
};

// Elapsed from dSinceTime in minutes
Util.toArray = function (asObject) {
    if (asObject != undefined) {
        return Array.isArray(asObject) ? asObject : [asObject];
    }
    else return [];
};

// Elapsed from dSinceTime in minutes
Util.elapsed = function (dSinceDT) {
    if (dSinceDT)
        return (new Date() - dSinceDT) / 60000;
    else return Number.MAX_VALUE;
};

// Format date with elapsed minutes
Util.toDTMinString = function (dDate) {
    var _date = "-", _min = "-";
    if (dDate) {
        _date = dDate.toDTString();
        _min = Util.elapsed(dDate).toFixed(2);
    }
    return "<@> (<@> mins)".mReplace(_date, _min);
};

// For debugging: Display the label and content
Util.dumpVar = function (sLabel, oContent) {
    cb.log("<<" + sLabel + ">>.....[" + oContent + "]");
};

// For debugging: Print out variable as object breakdown
Util.printObj = function (oContent) {
    var outStr = '[';
    // If the object has a constructor and the constructor has a name,
    // use that class name as part of the returned string. Note that
    // the name property of functions is nonstandard and not supported
    // everywhere.
    if (oContent.constructor && oContent.constructor.name)
        outStr += oContent.constructor.name + ": ";
    // Now enumerate all noninherited, nonfunction properties
    var n = 0;
    for (var name in oContent) {
        if (!oContent.hasOwnProperty(name)) continue; // skip inherited props
        var value = oContent[name];
        if (typeof value === "function") continue; // skip methods
        if (n++) outStr += "; ";
        outStr += name + '=' + value;
    }
    return outStr + ']';
};

// For debugging: Print out variable
Util.printVar = function (oContent, bByObj) {
    var outStr = "Debug: ";
    if (bByObj === true)
        outStr += Util.printObj(oContent);
    else outStr += oContent;
    return outStr;
};

// Report Time (late hour warning)
function ReportTime(bot, uName) {
    this.bot = bot;
    this.lastRptHour = 99;
    this.lastRptMin = 99;
    this.toUser = uName;
}

ReportTime.prototype.check = function () {
    var now = new Date();
    var nowHour = now.getHours(), nowMin = now.getMinutes();

    if ((nowMin % 30 == 0 && (nowHour >= 22 || nowHour <= 6)) && // Half hour mark and from 10pm-6am
        (this.lastRptHour * 100 + this.lastRptMin) != (nowHour * 100 + nowMin)) {
        this.bot.systemBM(":night83 The current time is " + now.toTimeString().substring(0, 5)).send(this.toUser);
        this.lastRptHour = nowHour;
        this.lastRptMin = nowMin;
    }
    return this;
};

// Class Validation
function Validation(bot, oValParam) {
    this.bot = bot;
    this.valParam = oValParam;
    this.testCase = [];
}

// Add validation case(s)
// aCase: {testFn, errorMsg}
Validation.prototype.addCase = function (aCase) {
    var self = this;
    Util.toArray(aCase).forEach(function (oEntry) {
        self.testCase.push({testFn: oEntry.testFn, errorMsg: oEntry.errorMsg});
    });
    return this;
};

// Check all test cases
Validation.prototype.check = function (byUName, fPass) {
    var self = this;
    if (!this.testCase.some(function (oEntry) {
            var errMsg = oEntry.testFn(self.valParam);
            if (errMsg) { // Failed validation
                self.bot.alertBM(oEntry.errorMsg || errMsg).send(byUName);
                return true;
            }
            else return false;
        })) fPass && fPass();
    return this;
};

// ---------------
// Command Class
function Command(bot, aCmdMatrix) {
    this.bot = bot;

    var self = this;
    this.cmdMatrix = [
        {
            cmd: "cmds", param: "[search-pattern]>", access: "*", desc: "List all available commands",
            callback: function (oParsed) {
                self.cmds(oParsed);
            }
        }
    ].concat(aCmdMatrix).sort(function (a, b) { // Sort and place 'cmds' always at the end
        if (b.cmd == "cmds") return -1;
        if (a.cmd == "cmds") return 1;
        if (a.cmd < b.cmd) return -1;
        if (a.cmd > b.cmd) return 1;
        return 0;
    });
}

// Show available commands
Command.prototype.cmds = function (oParsed) {
    var role = oParsed.byURec.getRole();

    var bm = this.bot.normalBM().setHeader("Commands");
    this.cmdMatrix.filter(function (oEntry) { // Wildcard filtering
        return oEntry.cmd.search(oParsed.param1) > -1;
    }).forEach(function (oEntry) {
        if (Command.access(role, oEntry.access))
            bm.line("/<@><@> --- '<@>'",
                oEntry.cmd,
                oEntry.param ? " " + oEntry.param : "",
                oEntry.desc
            );
    });
    bm.send(oParsed.byUName);
    return this;
};

// Parse text for command and params
Command.parse = function (sText) {
    var _cmd = "", _paramFull = "", _param1 = "", _param2 = "", _paramRest = "";
    var tokens = sText.match(/^[ ]*\/(\w+)[\s,]*((\w*)[\s,]*(\w*)[\s,]*(.*))/);
    if (tokens) {
        _cmd = tokens[1].toLowerCase();
        _paramFull = tokens[2] || "";
        _param1 = tokens[3] || "";
        _param2 = tokens[4] || "";
        _paramRest = tokens[5] || "";
    }
    return {
        cmd: _cmd,
        param1: _param1,
        param2: _param2,
        paramRest: _paramRest,
        paramFull: _paramFull,
        byURec: undefined,
        msgCB: undefined
    };
};

// Check if aRole (e.g. "H", "M", "F") has the sAccess rights
Command.access = function (aRole, sAccess) {
    if (sAccess == "*") return true;
    return aRole.some(function (sElement) {
        return sAccess.indexOf(sElement) > -1;
    });
};

// Can aRole run command sCmd?
Command.prototype.authCmd = function (aRole, sCmd) {
    for (var i = 0; i < this.cmdMatrix.length; i++) {
        if (this.cmdMatrix[i].cmd == sCmd) {
            if (Command.access(aRole, this.cmdMatrix[i].access)) {
                return this.cmdMatrix[i];
            }
            else return;
        }
    }
};

// Execute the command (return true if completed)
Command.prototype.execCmd = function (oParsed) {
    var cmdEntry = this.authCmd(oParsed.byURec.getRole(), oParsed.cmd);
    if (cmdEntry) {
        if (cmdEntry.callback) {
            cmdEntry.callback(oParsed);
        } else {
            this.bot.alertBM().line("Command /<@> is under construction.", cmdEntry.cmd).send(oParsed.byUName);
        }
        return true;
    }
    return false;
};

// ---------------
// Cam Class
// param: {mode, peekShowMin, peekHideMin, roomStatusCycleMin, getHiddenCamViewerFn}
function Cam(bot, oParam) {
    this.bot = bot;
    this.mode = "";
    this.getHiddenCamViewer = oParam.getHiddenCamViewerFn; // Func to get hidden cam viewers
    this.peekShowMin = oParam.peekShowMin || 10; // Peek mode show minutes
    this.peekHideMin = oParam.peekHideMin || 20; // Peek mode hide minutes
    this.roomStatusCycleMin = oParam.roomStatusCycleMin;

    this.initBuzz();
    this.setMode(bot.getHost(), oParam.mode || "peek");
}

// Initialize buzz
Cam.prototype.initBuzz = function () {
    function buildBuzzMap(aBuzzMap, nTotalMin, nNonZoneMin, aZoneMin, fBuzz) {
        var remainMin = nTotalMin;
        aZoneMin.forEach(function (oEntry) {
            var zoneTotal = 0;
            while (remainMin >= oEntry.zoneCycleMin && zoneTotal < oEntry.zoneMaxMin) {
                aBuzzMap.unshift({duration: oEntry.zoneCycleMin, times: 1, buzzFn: fBuzz});
                remainMin -= oEntry.zoneCycleMin;
                zoneTotal += oEntry.zoneCycleMin;
            }
        });
        while (remainMin >= nNonZoneMin) {
            aBuzzMap.unshift({duration: nNonZoneMin, times: 1, buzzFn: fBuzz});
            remainMin -= nNonZoneMin;
        }
        if (remainMin > 0) {
            aBuzzMap.unshift({duration: remainMin, times: 1, buzzFn: fBuzz});
        }
        aBuzzMap.pop(); // Tick out the last entry
        return aBuzzMap;
    }

    var self = this;
    var fRoomStatus = function () {
        self.printMode(self.bot.getHost());
    };

    var zoneMin = [
        {zoneCycleMin: 0.5, zoneMaxMin: 2},
        {zoneCycleMin: 2, zoneMaxMin: 4}
    ];
    this.peekShowBuzzMap = buildBuzzMap([], this.peekShowMin, this.roomStatusCycleMin, zoneMin, fRoomStatus);
    this.peekHideBuzzMap = buildBuzzMap([], this.peekHideMin, this.roomStatusCycleMin, zoneMin, fRoomStatus);
    this.defaultBuzzMap = [{duration: this.roomStatusCycleMin, buzzFn: fRoomStatus}];

    // Create room status message
    this.roomModeBuzz = new Buzz(this.defaultBuzzMap, "Room Mode").on();
    this.bot.registerBuzz(this.roomModeBuzz);
    return this;
};

// List CB cam viewer list
Cam.prototype.listCamViewer = function (byUName) {
    if (cb.limitCam_isRunning()) {
        var board = [
            ["G", "[<@>]", cb.limitCam_allUsersWithAccess().sort(),
                "Users to CB Hidden Cam (subject to CB promptly execution which could take 30s to become effective)",
                4]
        ];
        this.bot.systemBM().build(board).send(byUName);
    } else {
        this.bot.systemBM("The cam is not hidden.").send(byUName);
    }
    return this;
};

// Get room mode
Cam.prototype.getMode = function () {
    return this.mode;
};

// Change room mode
Cam.prototype.setMode = function (byUName, sMode) {
    var _upperMode = sMode.toUpperCase();
    // sMode values: public, peek, talk, show, vip
    if (this.mode == sMode) {
        this.bot.alertBM().line("The room is already in <@> mode.", _upperMode).send(byUName);
    } else {
        var _extraMsg = "", _secondMsg = "";
        switch (sMode) {
            case "public":
                this.roomModeBuzz.remap(this.defaultBuzzMap).on();
                break;
            case "talk":
                this.roomModeBuzz.remap(this.defaultBuzzMap).on();
                _secondMsg = "You must start/continue to chat to view the cam.";
                break;
            case "show":
                this.roomModeBuzz.remap(this.defaultBuzzMap).on();
                this.bot.listVipUser(this.bot.getHost(), true);
                break;
            case "vip":
                this.roomModeBuzz.remap(this.defaultBuzzMap).on();
                this.bot.listVipUser(this.bot.getHost(), true);
                _extraMsg = "Only VIP users can view the cam and chat in the room.";
                break;
            case "peek":
                this.initPeekShow();
                _extraMsg = "You may view the cam once in a while.";
                _secondMsg = "You must start/continue to chat to view the cam when the cam is hidden.";
                break;
            default:
                return this;
                break;
        }
        this.mode = sMode;
        this.update();
        this.bot.alertBM().line("The room is switched to <@> mode.<@>", _upperMode, " " + _extraMsg).line(_secondMsg).send();
    }
    return this;
};

// Initialize peek showing
Cam.prototype.initPeekShow = function () {
    this.peekStartTime = new Date();
    this.roomModeBuzz.remap(this.peekShowBuzzMap).on();
    this.peekShow = true;
    this.bot.warningBM().line("The cam is now PEEK SHOWING for <@> min(s).", this.peekShowMin).send(this.bot.getHost());
    return this;
};

// Initialize peek hiding
Cam.prototype.initPeekHide = function () {
    this.peekStartTime = new Date();
    this.roomModeBuzz.remap(this.peekHideBuzzMap).on();
    this.peekShow = false;
    this.bot.warningBM().line("The cam is now PEEK HIDING for <@> min(s).", this.peekHideMin).send(this.bot.getHost());
    return this;
};

// Update cam status
Cam.prototype.update = function () {
    // Alternate PEEK show/hide periods
    if (this.mode == "peek") {
        var peekActiveMin = Util.elapsed(this.peekStartTime);

        if (this.peekShow) {
            if (peekActiveMin > this.peekShowMin) {
                this.initPeekHide();
                this.bot.systemBM("You must start/continue to chat to be able to view this cam.").send();
            }
        } else {
            if (peekActiveMin > this.peekHideMin) {
                this.initPeekShow();
            }
        }
    }
    // Determine whether cam should be hidden
    if ((this.mode == "peek" && this.peekShow) || this.mode == "public") { // Stop hidden cam
        if (cb.limitCam_isRunning()) {
            cb.limitCam_stop();
        }
    }
    else { // Start hidden cam
        if (!cb.limitCam_isRunning()) {
            var aCamMessage = "\nEngage in chat to view the cam.\n\nTalk!!!";
            cb.limitCam_start(aCamMessage);
        }
        this.updateHiddenCamViewer(); // Update hidden cam viewers
    }
    return this;
};

// Update hidden cam viewers
Cam.prototype.updateHiddenCamViewer = function () {
    var viewer = this.getHiddenCamViewer(this.mode);
    var cbAccessList = cb.limitCam_allUsersWithAccess();
    var addUserList = viewer.minus(cbAccessList);
    var delUserList = cbAccessList.minus(viewer);
    var bot = this.bot;
    var self = this;

    // Add users to view cam list
    addUserList.forEach(function (uName) {
        cb.limitCam_addUsers([uName]);
        if (bot.bms.isTrace) {
            bot.bms.traceLog(bot.debugBM().line("[<@>] added to view cam list.", uName));
        }

        var uRec = bot.getUser(uName);
        if (uRec && !uRec.isVip) {
            uRec.resetWarnCamHide();
        }
    });
    // Remove users from view cam list
    delUserList.forEach(function (uName) {
        cb.limitCam_removeUsers([uName]);
        if (bot.bms.isTrace) {
            bot.bms.traceLog(bot.debugBM().line("[<@>] removed from view cam list.", uName));
        }

        if (!(["show", "vip"].contains(self.mode))) {
            bot.alertBM("The cam will now be hidden until you CONTINUOUSLY talk again.").send(uName);
            if (self.mode == "peek") {
                bot.normalBM("You might have a peek once in a while.").send(uName);
            }
        }
    });
    return this;
};

// Return the room mode status text
Cam.prototype.modeStatus = function () {
    var _ext = "", _min = "";
    if (this.mode == "peek") {
        _ext = this.peekShow ? " SHOWING" : " HIDING";
        _min = " (<@> minutes remaining)".mReplace(Math.max((this.peekShow ? this.peekShowMin : this.peekHideMin) - Util.elapsed(this.peekStartTime), 0).toFixed(2));
    }
    return "In <@><@> mode<@>".mReplace(this.mode.toUpperCase(), _ext, _min);
};

// Display the room mode status to sByUser
Cam.prototype.printMode = function (byUName) {
    this.bot.systemBM(this.modeStatus()).send(byUName);
    return this;
};

// ---------------
// Buzz Class
function Buzz(aBuzzMap, sDesc, fInit) {
    this.buzzMap = aBuzzMap;
    this.desc = sDesc;
    if (fInit) fInit();
    this.enabled = false;
    this.resetMap();
}

// Reset the buzz map
Buzz.prototype.resetMap = function () {
    this.mapIdx = 0;
    this.nextBuzz();
    return this;
};

// Set up next buzz
Buzz.prototype.nextBuzz = function () {
    // Buzz road map
    // duration:10 (min), times:3 (t0=repeatedly), buzzFn:xx (callback), testFn:yy (callback)
    if (this.mapIdx < this.buzzMap.length) {
        this.buzzMin = this.buzzMap[this.mapIdx].duration;
        var times = this.buzzMap[this.mapIdx].times;
        this.times = times && times > 0 ? times : Number.MAX_VALUE;
        this.buzzFn = this.buzzMap[this.mapIdx].buzzFn;
        this.testFn = this.buzzMap[this.mapIdx].testFn;
        this.mapIdx++;
    }
    else {
        this.enabled = false;
    }
    this.restart();
    return this;
};

// Restart the timer
Buzz.prototype.restart = function () {
    this.startTime = new Date();
    return this;
};

// Remap buzz map
Buzz.prototype.remap = function (aBuzzMap) {
    this.buzzMap = aBuzzMap;
    this.resetMap();
    return this;
};

// Text representation of Buzz
Buzz.prototype.toString = function () {
    var remainMin = this.remainBuzzMin();
    if (this.enabled && this.times > 0 && remainMin > 0 && (!this.testFn || this.testFn())) {
        return "Will be fired in <@> minute(s).".mReplace(remainMin.toFixed(2));
    } else {
        return "Will not be fired.";
    }
};

// Return remaining minutes to buzz
Buzz.prototype.remainBuzzMin = function () {
    return Math.max(0, this.buzzMin - Util.elapsed(this.startTime));
};

// Check if alarm reached
Buzz.prototype.check = function () {
//    cb.log(this.desc);
    if (this.enabled && this.times > 0 && this.remainBuzzMin() == 0 && (!this.testFn || this.testFn())) {
        if (this.buzzFn) this.buzzFn();
        this.times--;
        if (this.times <= 0) {
            this.nextBuzz();
        } else {
            this.restart();
        }
    }
    return this;
};

// Turn off alarm
Buzz.prototype.off = function () {
    this.enabled = false;
    return this;
};

// Turn on alarm
Buzz.prototype.on = function () {
    this.enabled = true;
    return this;
};

// ---------------
// NotifierBuzz Class
// oParam: {cycleMin, delayMin, msgList, toUser, byURec, times, msgType, testFn, desc}
function NotifierBuzz(bot, oParam) {
    var self = this;
    this.msgList = Util.toArray(oParam.msgList);
    this.msgIdx = 0;
    this.toUser = oParam.toUser || "";

    var fNotifier = function () {
        if (self.msgList.length > 0) {
            bot.bm(oParam.msgType, self.msgList[self.msgIdx]).send(self.toUser);
            if (oParam.byURec) {
                bot.alertBM().line("Scheduled message(s) delivered to [<@>].", self.toUser).send(oParam.byURec.getName());
            }
            self.nextMsgIdx();
        }
    };

    var buzzMap = [{duration: oParam.cycleMin, times: oParam.times, buzzFn: fNotifier, testFn: oParam.testFn}];
    if (oParam.delayMin) {
        buzzMap.unshift({duration: oParam.delayMin, times: 1});
    }
    NotifierBuzz.superclass.constructor.call(this, buzzMap, oParam.desc);
}
// Subclass from Buzz
Util.extend(NotifierBuzz, Buzz);

// Next message index
NotifierBuzz.prototype.nextMsgIdx = function () {
    this.msgIdx++;
    if (this.msgIdx >= this.msgList.length) {
        this.msgIdx = 0;
    }
    return this;
};

// Text representation of buzz
NotifierBuzz.prototype.toString = function () {
    var remainMin = this.remainBuzzMin();
    return "'<@>' to [<@>] will<@> be fired<@>.".mReplace(
        this.msgList[this.msgIdx],
        this.toUser,
        remainMin > 0 ? "" : " not",
        remainMin > 0 ? " in <@> minute(s)".mReplace(remainMin.toFixed(2)) : "");
};

// ---------------
// SimpleBuzz Class
function SimpleBuzz(nCycleMin, nTimes, fFire, fTest, fInit) {
    var buzzMap = [{duration: nCycleMin, times: nTimes, buzzFn: fFire, testFn: fTest}];
    SimpleBuzz.superclass.constructor.call(this, buzzMap, fInit);
}
// Subclass from Buzz
Util.extend(SimpleBuzz, Buzz);

// ---------------
// AlarmSystem Class
function AlarmSystem(bot) {
    this.alarms = [];
    this.bot = bot;
}

// Add alarm
AlarmSystem.prototype.add = function (buzz, byUName) {
    this.alarms.push({username: byUName, buzz: buzz});
    return this;
};

// Check if alarms reached
AlarmSystem.prototype.check = function () {
    this.alarms.forEach(function (oEntry) {
        oEntry.buzz.check();
    });
    return this;
};

// List alarms by sByUser
AlarmSystem.prototype.list = function (byUName) {
    var bm = this.bot.systemBM().setHeader("Scheduled messages");
    this.alarms.forEach(function (oEntry) {
        if (oEntry.username == byUName && oEntry.buzz.remainBuzzMin() > 0) {
            bm.line(oEntry.buzz);
        }
    });
    if (bm.isEmpty) {
        this.bot.systemBM("No scheduled message.").send(byUName);
    }
    else {
        bm.send(byUName);
    }
    return this;
};

// ---------------
// UserPrefix Class
function UserPrefix(sPrefix) {
    this.prefix = sPrefix; // Username prefix
    this.matchedUser = []; // matched username
    this.numBan = 0; // # of bans triggered

    var self = this;
    Object.defineProperties(this, {
        isActivated: {
            get: function () {
                return self.matchedUser.length > 0;
            }
        }
    });
}

// Order by prefix
UserPrefix.orderByPrefix = function (a, b) {
    if (a.prefix < b.prefix) return -1;
    if (a.prefix > b.prefix) return 1;
    return 0;
};

// Name Hit
UserPrefix.prototype.nameHit = function (uName) {
    if (uName.startsWith(this.prefix)) {
        this.matchedUser.push(uName);
        this.numBan++;
        return this;
    }
};

// Build a string
UserPrefix.prototype.toString = function () {
    return "[<@>]____[Last Matched User]....'<@>'____[#Triggered]....<@>".mReplace(
        this.prefix,
        this.matchedUser[this.matchedUser.length - 1] || "",
        this.numBan
    );
};

// Get Prefix
UserPrefix.prototype.getPrefix = function () {
    return this.prefix;
};

// ---------------
// BanWord Class
function BanWord(sBanWord, bStrict) {
    this.strict = bStrict;
    var words = sBanWord.match(/(\*?\b[\w']+\b\*?)/g);
    this.word = words.join(" ");

    var parse = words.map(function (sWord) {
        var leftIdx = 0;
        var leftText = "\\b";
        if (sWord[0] == "*") {
            leftIdx += 1;
            leftText = "";
        }
        var rightIdx = sWord.length;
        var rightText = "\\b";
        if (sWord[sWord.length - 1] == "*") {
            rightIdx -= 1;
            rightText = "";
        }
        var sortWord = sWord.slice(leftIdx, rightIdx);
        return {sort: sortWord, reStr: leftText + sortWord + rightText};
    });
    this.sortWord = parse.map(function (oEntry) {
        return oEntry.sort;
    }).join(" ");
    this.reStr = parse.map(function (oEntry) {
        return oEntry.reStr;
    }).join(" +");
    this.numHit = 0;
    this.hitUser = []; // hit username

    var self = this;
    Object.defineProperties(this, {
        isStrict: {
            get: function () {
                return self.strict;
            }
        }
    });
}

// Order by word
BanWord.orderByWord = function (a, b) {
    if (a.sortWord < b.sortWord) return -1;
    if (a.sortWord > b.sortWord) return 1;
    return 0;
};

// Convert array to RE
BanWord.toRE = function (aBanWord) {
    return new RegExp("(?:<@>)".mReplace(
        aBanWord.map(function (oEntry) {
            return "(<@>)".mReplace(oEntry.reStr);
        }).join("|")), "gi");
};

// Word Hit
BanWord.prototype.wordHit = function (uName) {
    this.hitUser.push(uName);
    this.numHit++;
    return this;
};

// Word Hit
BanWord.prototype.getWord = function () {
    return this.word;
};

// Build a string
BanWord.prototype.toString = function () {
    return "[<@>]____[Last Hit By User]....'<@>'____[#Hit]....<@>".mReplace(
        this.word,
        this.hitUser[this.hitUser.length - 1] || "",
        this.numHit
    );
};

// ---------------
// User Class
// oParam: {name, pfTriggerMin, pfCycleMin}
function User(bot, oParam) {
    this.bot = bot;
    this.username = oParam.name;
    this.pfTriggerMin = oParam.pfTriggerMin;
    this.pfCycleMin = oParam.pfCycleMin;

    this.lastActiveDt = undefined; // Last active datetime
    this.lastChatActiveDt = undefined; // Last chat active datetime
    this.secLastChatActiveDt = undefined; // 2nd to last chat active datetime
    this.initEntryDt = undefined; // Initial entry datetime
    this.lastEntryDt = undefined; // Last entry datetime
    this.lastExitDt = undefined; // Last exit datetime
    this.graceStartDt = undefined; // Grace start datetime
    this.muteLevel = 0; // mute level (0=no mute, 1=restricted chat, 2=full mute)
    this.numEntry = 0; // # of room entries
    this.numChat = 0; // # of chats
    this.numBanWord = 0; // # of ban word attempts
    this.lastBanWord = "";

    this.warnCamHideFlag = false; // one min cam hide warned flag
    this.inactiveWarnFlag = false; // Inactive warned flag
    this.newLifeFlag = true; // New life flag (init to true so that a reset will be triggered for 1st entrance)
    this.hereFlag = false; // Here flag
    this.freezeFlag = false; // Freeze flag
    this.activeFlag = false; // Active flag
    this.autobanFlag = false; // Auto ban flag
    this.banFlag = false; // Banned flag
    this.pfFlag = false; // PF user flag
    this.pfModeFlag = false; // User in PF mode flag
    this.whitelistFlag = false; // Whistlist flag
    this.vipFlag = false; // VIP flag
    this.modFlag = false; // Mod flag
    this.hostFlag = false; // Host flag

    var self = this;
    Object.defineProperties(this, {
        isPF: {
            get: function () {
                return self.pfFlag;
            }
        },
        isPFMode: {
            get: function () {
                return self.pfModeFlag;
            }
        },
        isMod: {
            get: function () {
                return self.modFlag;
            }
        },
        isHost: {
            get: function () {
                return self.hostFlag;
            }
        },
        isVip: {
            get: function () {
                return self.vipFlag;
            }
        },
        isBan: {
            get: function () {
                return self.banFlag;
            }
        },
        isAutoBan: {
            get: function () {
                return self.autobanFlag;
            }
        },
        isWL: {
            get: function () {
                return self.whitelistFlag;
            }
        },
        isHere: {
            get: function () {
                return self.hereFlag;
            }
        },
        isFrozen: {
            get: function () {
                return self.freezeFlag;
            }
        },
        isActive: {
            get: function () {
                return self.activeFlag;
            }
        },
        isWarnCamHide: {
            get: function () {
                return self.warnCamHideFlag;
            }
        },
        isInactiveWarn: {
            get: function () {
                return self.inactiveWarnFlag;
            }
        },
        isPartialMute: {
            get: function () {
                return self.muteLevel == 1;
            }
        },
        isFullMute: {
            get: function () {
                return self.muteLevel > 1;
            }
        },
        isMute: {
            get: function () {
                return self.muteLevel > 0;
            }
        },
        isNewLife: {
            get: function () {
                return self.newLifeFlag;
            }
        }
    });
}

// Get entry count
User.prototype.getEntryCount = function () {
    return this.numEntry;
};

// Get chat count
User.prototype.getChatCount = function () {
    return this.numChat;
};

// Get ban word attempt count
User.prototype.getBanWordCount = function () {
    return this.numBanWord;
};

// Get username
User.prototype.getName = function () {
    return this.username;
};

// Get initial entry date
User.prototype.getInitEntryDt = function () {
    return this.initEntryDt;
};

// Build the toString text
User.prototype.toString = function () {
    return [
        "[Last/2nd To Last Chat Active Time]....<@>/<@>".mReplace(
            Util.toDTMinString(this.lastChatActiveDt),
            Util.toDTMinString(this.secLastChatActiveDt)),
        "[Last Active Datetime]....<@>".mReplace(
            Util.toDTMinString(this.lastActiveDt)),
        "[Initial/Last Entry Datetime]....<@>/<@>".mReplace(
            Util.toDTMinString(this.initEntryDt),
            Util.toDTMinString(this.lastEntryDt)),
        "[Last Exit Datetime]....<@>____[Grace Start Datetime]....<@>".mReplace(
            Util.toDTMinString(this.lastExitDt),
            Util.toDTMinString(this.graceStartDt)),
        "[PF]....<@>____[PF Mode]....<@>____[Banned]....<@>____[Auto Banned]....<@>____[#Ban Words]....<@>".mReplace(
            this.pfFlag.toYesNo(),
            this.pfModeFlag.toYesNo(),
            this.banFlag.toYesNo(),
            this.autobanFlag.toYesNo(),
            this.numBanWord),
        "[Mod]....<@>____[VIP]....<@>____[Whitelist]....<@>____[Host]....<@>____[Last Ban Word]....'<@>'".mReplace(
            this.modFlag.toYesNo(),
            this.vipFlag.toYesNo(),
            this.whitelistFlag.toYesNo(),
            this.hostFlag.toYesNo(),
            this.lastBanWord),
        "[Inactive Warned]...<@>____[Cam Hide Warned]....<@>____[Frozen]....<@>____[New Life]....<@>".mReplace(
            this.inactiveWarnFlag.toYesNo(),
            this.warnCamHideFlag.toYesNo(),
            this.freezeFlag.toYesNo(),
            this.newLifeFlag.toYesNo()),
        "[In Room]....<@>____[#Entries]....<@>____[#Chats]....<@>____[Mute]....<@>____[Active]....<@>".mReplace(
            this.hereFlag.toYesNo(),
            this.numEntry,
            this.numChat,
            this.muteLevel > 1 ? "Full" : (this.muteLevel == 0 ? "NO" : "PARTIAL"),
            this.activeFlag.toYesNo())
    ].join("\n");
};

// Order by username
User.orderByName = function (a, b) {
    if (a.getName() < b.getName()) return -1;
    if (a.getName() > b.getName()) return 1;
    return 0;
};

// Generate room privileges string
User.prototype.privilegeStr = function () {
    var outStr = [];
    if (this.isHost) outStr.push("the host"); // Host
    if (this.isMod) outStr.push("a mod of the bot"); // Mod user
    if (this.isVip) outStr.push("a VIP user"); // VIP user
    if (this.isPF) outStr.push("a PF user"); // PF user
    if (outStr.length > 0) {
        return "You are <@>.".mReplace(outStr.engJoin());
    }
};

// Return user's role array
User.prototype.getRole = function () {
    var role = [];
    if (this.isMod) role.push("M");
    if (this.isHost) role.push("H");
    if (this.isPF) role.push("F");
    return role;
};

// Ban Word
User.prototype.wordBan = function (sBanWord) {
    this.numBanWord++;
    this.lastBanWord = sBanWord;
    return this;
};

// User interact in the room
User.prototype.interact = function () {
    this.lastActiveDt = new Date();
    this.inactiveWarnFlag = false; // Clear inactive warned flag
    return this;
};

// Reborn
User.prototype.reborn = function () {
    this.interact(); // Give away the 1st interact for 1st entrance
    this.graceStartDt = new Date();
    this.newLifeFlag = false;	// Clear new life flag
    return this;
};

// Enter the room
User.prototype.enter = function () {
    this.here().unFreeze();

    if (!this.initEntryDt) { // Initial entry datetime
        this.initEntryDt = new Date();
    }
    this.lastEntryDt = new Date(); // Last entry datetime
    this.numEntry++;

    // Reborn for new life
    if (this.newLifeFlag) {
        this.reborn();
    }
    return this;
};

// Leave the room
User.prototype.leave = function () {
    this.gone().unFreeze();
    this.lastExitDt = new Date(); // Last exit datetime

    // Rare case: exit without entry record
    if (!this.initEntryDt) { // Initial entry datetime
        this.initEntryDt = new Date();
    }
    if (!this.lastEntryDt) { // Last last entry datetime
        this.lastEntryDt = new Date();
    }
    return this;
};

// Message in the room
User.prototype.message = function () {
    this.here().unFreeze();

    // Rare case: chat without entry record
    if (this.initEntryDt == undefined) // Initial entry datetime
        this.initEntryDt = new Date();
    if (this.lastEntryDt == undefined) // Last last entry datetime
        this.lastEntryDt = new Date();
    return this;
};

// Valid chat in the room
User.prototype.chat = function () {
    if (!this.isPFMode)
        this.numChat++;
    this.secLastChatActiveDt = this.lastChatActiveDt; // Escalate chat active datetime
    this.lastChatActiveDt = new Date();

    return this;
};

// PF Chat
User.prototype.pfChat = function () {
    this.pfRemindAlarm && this.pfRemindAlarm.restart();
    return this;
};

// Set PF mode on
User.prototype.setPFModeOn = function () {
    this.pfModeFlag = true;
    this.pfRemindAlarm && this.pfRemindAlarm.restart().on();
    return this;
};

// Set PF mode off
User.prototype.setPFModeOff = function () {
    this.pfModeFlag = false;
    this.pfRemindAlarm && this.pfRemindAlarm.off();
    return this;
};

// Mark active user record
User.prototype.markActive = function () {
    this.activeFlag = true;
    return this;
};

// Warn cam hide
User.prototype.warnCamHide = function () {
    this.warnCamHideFlag = true;
    this.bot.alertBM("The cam will be hidden in 1 min. You need to keep talking to keep the cam open.").send(this.username);
    return this;
};

// Reset cam hide warning
User.prototype.resetWarnCamHide = function () {
    this.warnCamHideFlag = false;
    this.bot.systemBM("You may now view the cam. You need to keep talking to keep the cam open.").send(this.username);
    return this;
};

// Grant whitelist
User.prototype.grantWL = function () {
    this.whitelistFlag = true;
    return this;
};

// Revoke whitelist
User.prototype.revokeWL = function () {
    this.whitelistFlag = false;
    return this;
};

// Grant VIP
User.prototype.grantVip = function () {
    this.vipFlag = true;
    return this;
};

// Revoke VIP
User.prototype.revokeVip = function () {
    this.vipFlag = false;
    return this;
};

// Grant PF
User.prototype.grantPF = function () {
    this.pfFlag = true;
    this.pfModeFlag = false;
    this.pfRemindAlarm = new NotifierBuzz(this.bot, {
        delayMin: this.pfTriggerMin,
        cycleMin: this.pfCycleMin,
        msgList: "You are still in PF mode.",
        toUser: this.username,
        desc: "PF Reminder - [<@>]".mReplace(this.username)
    }).off();
    return this;
};

// Revoke PF
User.prototype.revokePF = function () {
    this.pfFlag = false;
    this.pfModeFlag = false;
    this.pfRemindAlarm = undefined;
    return this;
};

// Grant Host
User.prototype.grantHost = function () {
    this.hostFlag = true;
    return this;
};

// Grant Mod
User.prototype.grantMod = function () {
    this.modFlag = true;
    return this;
};

// Inactive warn
User.prototype.warn = function () {
    this.inactiveWarnFlag = true;
    return this;
};

// Reset Inactive warn
User.prototype.resetWarn = function () {
    this.inactiveWarnFlag = false;
    return this;
};

// Grant new life for next entrance
User.prototype.grantNewLife = function () {
    this.newLifeFlag = true;
    return this;
};

// Handle auto-ban
User.prototype.handleAutoBan = function () {
    this.autobanFlag = false;
    return this;
};

// Auto-ban
User.prototype.autoBan = function () {
    this.autobanFlag = true;
    this.ban();
    return this;
};

// Ban user
User.prototype.ban = function () {
    this.banFlag = true;
    return this;
};

// Unban user
User.prototype.unban = function () {
    this.banFlag = false;
    this.autobanFlag = false; // Clear auto ban flag
    this.numBanWord = 0;
    this.interact();
    return this;
};

// Mute user
User.prototype.mute = function () {
    this.muteLevel++;
    return this;
};

// Un-mute user
User.prototype.unmute = function () {
    this.muteLevel = 0;
    return this;
};

// Check alarm
User.prototype.checkAlarm = function () {
    this.pfRemindAlarm && this.pfRemindAlarm.check();
    return this;
};

// User in room
User.prototype.here = function () {
    this.hereFlag = true;
    this.markActive();
    return this;
};

// User NOT in room
User.prototype.gone = function () {
    this.hereFlag = false;
    this.markActive();
    return this;
};

// Freeze user
User.prototype.freeze = function () {
    this.freezeFlag = true;
    return this;
};

// Un-freeze user
User.prototype.unFreeze = function () {
    this.freezeFlag = false;
    return this;
};

// ---------------
// Bot Class
function Bot(oCBParam) {
    cb.log("##################################################");
    cb.log(Bot.BOT_NAME + " bot running ...");
    var self = this;
    this.host = oCBParam.host;
    // Check if broadcaster is authorized to run bot
    this.auth = ["lvbgtts", "lvbgtts2", "zerobug", "cacheme"].indexOf(this.host) > -1;

    if (!this.auth) return;

    this.users = [];
    this.userPrefix = [];
    this.vip = oCBParam.vip || [];
    this.pfUser = oCBParam.pfUser || [];
    this.modUser = oCBParam.modUser || [];
    this.wlUser = oCBParam.wlUser || [];
    this.banUser = oCBParam.banUser || [];
    this.banUserPrefix = oCBParam.banUserPrefix || [];
    this.noSneak = true;
    this.gender = true;
    this.chatNum = true;

    this.notifierModMsg = [];
//    this.lateTimeReport = new ReportTime(this, this.host);

    // Set up once params
    this.notifierMsg = oCBParam.notifierMsg || [];
    this.welcomeMsg = oCBParam.welcomeMsg || [];
    this.warnMsg = oCBParam.warnMsg || "";
    this.banMsg = oCBParam.banMsg;
    this.warnMin = oCBParam.warnMin || 15;
    this.banMin = oCBParam.banMin || 25;
    this.notifierCycleMin = oCBParam.notifierCycleMin || 5;
    this.roomStatusCycleMin = 5;
    this.checkCycleSec = 10000; // Cycle time for time loop (1000 => 1 sec)
    this.muteChatLength = 15; // # of characters allowed in 1st level mute
    this.chatNumGoal = 10; // Goal # of chat lines
    this.offlineNewLifeMin = 60; // Offline new life minutes
    this.pfCycleMin = 2; // PF reminder cycle minutes
    this.pfTriggerMin = 1; // PF reminder trigger minutes
    this.maxChatInactiveMin = oCBParam.maxChatInactiveMin || 10;
    this.histMaxMin = 10; // Max minutes to PF/VIP history dump
    this.graceMin = 3; // Grace period for free cam view in minute
    this.maxChatHist = 10; // Max PF/Vip chat histories to be retained

    this.bms = new BotMessageSystem(this.host, this.histMaxMin, this.maxChatHist);
    this.systemBM().line("<@> Bot (<@>) Enabled.",
        Bot.BOT_NAME,
        Bot.BOT_VERSION
    ).line("Type '/cmds' to list commands available to you.").send(this.host);

    this.alarmSystem = new AlarmSystem(this);

    this.cam = new Cam(this, {
        mode: "peek", peekShowMin: oCBParam.peekShowMin, peekHideMin: oCBParam.peekHideMin,
        roomStatusCycleMin: this.roomStatusCycleMin,
        getHiddenCamViewerFn: function (camMode) {
            return self.getHiddenCamViewer(camMode);
        }
    });

    var cmdMatrix = [
        {
            cmd: "camviewer", access: "HM", desc: "Display users with access to hidden cam",
            callback: function (oParsed) {
                self.camViewer(oParsed);
            }
        },
        {
            cmd: "alarm", param: "touser minutes-later text", access: "HM",
            desc: "Set a delayed message to user",
            callback: function (oParsed) {
                self.alarm(oParsed);
            }
        },
        {
            cmd: "modlist", access: "HM", desc: "Display all mods users",
            callback: function (oParsed) {
                self.modList(oParsed);
            }
        },
        {
            cmd: "whitelist", access: "HM", desc: "Display all whitelist users",
            callback: function (oParsed) {
                self.whiteList(oParsed);
            }
        },
        {
            cmd: "grantwl", param: "username", access: "H", desc: "Grant whitelist user",
            callback: function (oParsed) {
                self.grantWL(oParsed);
            }
        },
        {
            cmd: "revokewl", param: "username", access: "H", desc: "Revoke whitelist user",
            callback: function (oParsed) {
                self.revokeWL(oParsed);
            }
        },
        {
            cmd: "pflist", access: "F", desc: "List all PF users",
            callback: function (oParsed) {
                self.pfList(oParsed);
            }
        },
        {
            cmd: "pf", param: "[text]", access: "F",
            desc: "Toggle PF mode ON/OFF if no param, send direct PF otherwise",
            callback: function (oParsed) {
                self.pf(oParsed);
            }
        },
        {
            cmd: "pfon", access: "F", desc: "Set PF mode ON",
            callback: function (oParsed) {
                self.pfOn(oParsed);
            }
        },
        {
            cmd: "pfoff", access: "F", desc: "Set PF mode OFF",
            callback: function (oParsed) {
                self.pfOff(oParsed);
            }
        },
        {
            cmd: "grantpf", param: "username", access: "H", desc: "Grant PF user",
            callback: function (oParsed) {
                self.grantPF(oParsed);
            }
        },
        {
            cmd: "revokepf", param: "username", access: "H", desc: "Revoke PF user",
            callback: function (oParsed) {
                self.revokePF(oParsed);
            }
        },
        {
            cmd: "viplist", access: "HM", desc: "Display all VIP users",
            callback: function (oParsed) {
                self.vipList(oParsed);
            }
        },
        {
            cmd: "grantvip", param: "username", access: "H", desc: "Grant VIP user",
            callback: function (oParsed) {
                self.grantVip(oParsed);
            }
        },
        {
            cmd: "revokevip", param: "username", access: "H", desc: "Revoke VIP user",
            callback: function (oParsed) {
                self.revokeVip(oParsed);
            }
        },
        {
            cmd: "banword", access: "MH", desc: "Display all ban words",
            callback: function (oParsed) {
                self.listBanWord(oParsed);
            }
        },
        {
            cmd: "banlist", access: "HM", desc: "Display all banned users",
            callback: function (oParsed) {
                self.banList(oParsed);
            }
        },
        {
            cmd: "banplist", access: "HM", desc: "Display all triggered banned prefixes",
            callback: function (oParsed) {
                self.triggeredBanPreList(oParsed);
            }
        },
        {
            cmd: "dbanplist", access: "M", desc: "Display all banned prefixes",
            callback: function (oParsed) {
                self.banPreList(oParsed);
            }
        },
        {
            cmd: "ban", param: "username", access: "HM", desc: "Ban user",
            callback: function (oParsed) {
                self.ban(oParsed);
            }
        },
        {
            cmd: "unban", param: "username", access: "HM", desc: "Unban user",
            callback: function (oParsed) {
                self.unban(oParsed);
            }
        },
        {
            cmd: "handle", param: "username", access: "HM",
            desc: "Tell the system you have handled auto banned user",
            callback: function (oParsed) {
                self.handle(oParsed);
            }
        },
        {
            cmd: "freeze", param: "username", access: "HM",
            desc: "Freeze a user record from further monitoring",
            callback: function (oParsed) {
                self.freeze(oParsed);
            }
        },
        {
            cmd: "here", param: "username", access: "HM", desc: "Emulate a mobile entrance for a user",
            callback: function (oParsed) {
                self.here(oParsed);
            }
        },
        {
            cmd: "gone", param: "username", access: "HM", desc: "Emulate a mobile exit for a user",
            callback: function (oParsed) {
                self.gone(oParsed);
            }
        },
        {
            cmd: "mode", access: "HM", desc: "Display the mode the room is in",
            callback: function (oParsed) {
                self.camMode(oParsed);
            }
        },
        {
            cmd: "vipmode", access: "H", desc: "Switch to VIP mode",
            callback: function (oParsed) {
                self.vipMode(oParsed);
            }
        },
        {
            cmd: "showmode", access: "H", desc: "Switch to SHOW mode",
            callback: function (oParsed) {
                self.showMode(oParsed);
            }
        },
        {
            cmd: "talkmode", access: "H", desc: "Switch to TALK mode",
            callback: function (oParsed) {
                self.talkMode(oParsed);
            }
        },
        {
            cmd: "peekmode", access: "H", desc: "Switch to PEEK mode",
            callback: function (oParsed) {
                self.peekMode(oParsed);
            }
        },
        {
            cmd: "public", access: "H", desc: "Switch to PUBLIC mode",
            callback: function (oParsed) {
                self.publicMode(oParsed);
            }
        },
        {
            cmd: "who", param: "username", access: "HM", desc: "Display info about user",
            callback: function (oParsed) {
                self.who(oParsed);
            }
        },
        {
            cmd: "duser", access: "M", desc: "Dump all user records",
            callback: function (oParsed) {
                self.userRecList(oParsed);
            }
        },
        {
            cmd: "alluser", access: "HM", desc: "List all users records",
            callback: function (oParsed) {
                self.allUserList(oParsed);
            }
        },
        {
            cmd: "hereuser", access: "HM", desc: "List users in the room",
            callback: function (oParsed) {
                self.hereUserList(oParsed);
            }
        },
        {
            cmd: "warneduser", access: "HM", desc: "List users on the warning list",
            callback: function (oParsed) {
                self.warnedUserList(oParsed);
            }
        },
        {
            cmd: "sneak", access: "HM", desc: "Toggle on/off 'No Sneak' mode",
            callback: function (oParsed) {
                self.toggleSneak(oParsed);
            }
        },
        {
            cmd: "gender", access: "HM", desc: "Toggle on/off 'Gender' mode",
            callback: function (oParsed) {
                self.toggleGender(oParsed);
            }
        },
        {
            cmd: "mute", param: "username", access: "HM", desc: "Mute user",
            callback: function (oParsed) {
                self.mute(oParsed);
            }
        },
        {
            cmd: "unmute", param: "username", access: "HM", desc: "Unmute user",
            callback: function (oParsed) {
                self.unmute(oParsed);
            }
        },
        {
            cmd: "mutelist", access: "HM", desc: "Display all banned users",
            callback: function (oParsed) {
                self.muteList(oParsed);
            }
        },
        {
            cmd: "chatnum", access: "HM", desc: "Toggle on/off chat # from chat line",
            callback: function (oParsed) {
                self.toggleChatNum(oParsed);
            }
        },
        {
            cmd: "spy", access: "M", desc: "Toggle spy mode",
            callback: function (oParsed) {
                self.spy(oParsed);
            }
        },
        {
            cmd: "trace", access: "M", desc: "Toggle trace mode",
            callback: function (oParsed) {
                self.trace(oParsed);
            }
        },
        {
            cmd: "panic", access: "M", desc: "Trigger panic mode",
            callback: function (oParsed) {
                self.panic(oParsed);
            }
        },
        {
            cmd: "modmsg", param: "text", access: "M", desc: "Update notifier mod message",
            callback: function (oParsed) {
                self.modMsg(oParsed);
            }
        },
        {
            cmd: "parms", access: "HM", desc: "Display parameters passed to the bot",
            callback: function (oParsed) {
                self.parms(oParsed);
            }
        },
        {
            cmd: "stat", access: "HM", desc: "Display room status",
            callback: function (oParsed) {
                self.stat(oParsed);
            }
        },
        {
            cmd: "strict", access: "HM", desc: "Switch to strict ban word mode",
            callback: function (oParsed) {
                self.strictBanWord(oParsed);
            }
        },
        {
            cmd: "loose", access: "HM", desc: "Switch to loose ban word mode",
            callback: function (oParsed) {
                self.looseBanWord(oParsed);
            }
        },
        {
            cmd: "none", access: "HM", desc: "Switch off ban word mode",
            callback: function (oParsed) {
                self.noBanWord(oParsed);
            }
        }
    ];
    this.cmd = new Command(this, cmdMatrix);

    // Ban word related
    this.maxBanWord = oCBParam.maxBanWord || 5; // Max ban word attempts
    this.banWordPool = []; // Ban Word pool
    oCBParam.banWordStrict.map(function (sWord) {
        return self.getBanWord(sWord, true, true);
    });
    oCBParam.banWord.map(function (sWord) {
        return self.getBanWord(sWord, false, true);
    });
    this.banWordPool.sort(BanWord.orderByWord);
    var banWordLoose = this.banWordPool.filter(function (bw) {
        return !bw.isStrict;
    });

    // Ban modes
    this.BAN_WORD = {
        strict: {wordList: this.banWordPool, re: BanWord.toRE(this.banWordPool), desc: "STRICT"},
        loose: {wordList: banWordLoose, re: BanWord.toRE(banWordLoose), desc: "LOOSE"},
        none: {wordList: [], re: new RegExp(""), desc: "NONE"}
    };

    this.banWordMode = "";
    this.setBanWordMode(this.host, "loose");

    this.init();

    // Validation Test callbacks
    this.val = {
        // Test: No text input
        noText: function (oValParam) {
            if (!oValParam.text)
                return "No text message input.";
        },
        // Test: Invalid minute
        invalidMinute: function (oValParam) {
            if (isNaN(oValParam.minLater))
                return "Invalid minute.";
        },
        // Test: Username parameter missing
        userParamMissing: function (oValParam) {
            if (!oValParam.uName)
                return "username is missing.";
        },
        // Test: User not found
        userNotFound: function (oValParam) {
            oValParam.uRec = self.getUser(oValParam.uName);
            if (!oValParam.uRec)
                return "[<@>] is not yet an active user.".mReplace(oValParam.uName);
        },
        // Test: Username is host
        userIsHost: function (oValParam) {
            if (oValParam.uName == self.host)
                return "[<@>] is the broadcaster.".mReplace(oValParam.uName);
        },
        // Test: User is already muted
        alreadyMuted: function (oValParam) {
            if (oValParam.uRec.isFullMute)
                return "[<@>] is already muted.".mReplace(oValParam.uRec.getName());
        },
        // Test: User is not muted
        notMuted: function (oValParam) {
            if (!oValParam.uRec.isMute)
                return "[<@>] is not muted".mReplace(oValParam.uRec.getName());
        },
        // Test: User already banned
        alreadyBanned: function (oValParam) {
            if (oValParam.uRec.isBan)
                return "[<@>] is already a banned user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User not banned
        notBanned: function (oValParam) {
            if (!oValParam.uRec.isBan)
                return "[<@>] is not a banned user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User already is white-listed
        alreadyWL: function (oValParam) {
            if (oValParam.uRec.isWL)
                return "[<@>] is already a whitelist user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User not white-listed
        notWL: function (oValParam) {
            if (!oValParam.uRec.isWL)
                return "[<@>] is not a whitelist user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User already is VIP
        alreadyVip: function (oValParam) {
            if (oValParam.uRec.isVip)
                return "[<@>] is already a VIP user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User not VIP
        notVip: function (oValParam) {
            if (!oValParam.uRec.isVip)
                return "[<@>] is not a VIP user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User already is PF user
        alreadyPF: function (oValParam) {
            if (oValParam.uRec.isPF)
                return "[<@>] is already a PF user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User not PF user
        notPF: function (oValParam) {
            if (!oValParam.uRec.isPF)
                return "[<@>] is not a PF user.".mReplace(oValParam.uRec.getName());
        },
        // Test: User not auto-banned
        notAutoban: function (oValParam) {
            if (!oValParam.uRec.isAutoBan)
                return "[<@>] is not auto banned.".mReplace(oValParam.uRec.getName());
        },
        // Test: User is frozen
        alreadyFrozen: function (oValParam) {
            if (oValParam.uRec.isFrozen)
                return "[<@>] is already frozen.".mReplace(oValParam.uRec.getName());
        },
        // Test: User with PF mode on
        alreadyPFMode: function (oValParam) {
            if (oValParam.uRec.isPFMode)
                return "PF mode is already ON.";
        },
        // Test: User with PF mode off
        notPFMode: function (oValParam) {
            if (!oValParam.uRec.isPFMode)
                return "PF mode is already OFF.";
        }
    }
}

// Get Ban Word Record, create if bCreate = true
Bot.prototype.getBanWord = function (sBanWord, bStrict, bCreate /* create record if not found */) {
    if (!sBanWord) return;
    for (var i = 0; i < this.banWordPool.length; i++) {
        if (this.banWordPool[i].getWord() == sBanWord) {
            return this.banWordPool[i];
        }
    }
    if (bCreate) {
        var bw = new BanWord(sBanWord, bStrict);
        this.banWordPool.push(bw);
        return bw;
    }
};

// Register buzz
Bot.prototype.registerBuzz = function (buzz) {
    this.alarmSystem.add(buzz);
    return this;
};

// Get cam mode
Bot.prototype.getCamMode = function () {
    return this.cam.getMode();
};

// Dump PF and VIP chat histories
Bot.prototype.dumpPFAndVipHist = function (uRec) {
    this.bms.dumpHist("pf", uRec).dumpHist("vip", uRec);
    return this;
};

// Build cam viewer list
Bot.prototype.getHiddenCamViewer = function (sCamMode) {
    var self = this;
    var viewCamList = [];
    this.users.forEach(function (uRec) {
        var uName = uRec.getName();
        if (uName != self.host) {
            // Check hidden cam
            if (uRec.isVip) {
//                cb.log("In VIP branch");
                viewCamList.push(uName);
            }
            else if (uRec.isBan || uRec.isFrozen) {
//                cb.log("In Banned / Frozen branch");
            }
            else {
//                cb.log("In Talk branch");
                if (!(["show", "vip"].contains(sCamMode))) { // Not in SHOW/VIP mode
                    var lastChatElapseMin = Util.elapsed(uRec.lastChatActiveDt); // Last active minutes
                    var secLastChatElapseMin = Util.elapsed(uRec.secLastChatActiveDt); // 2nd last inactive minutes
                    var graceElapseMin = Util.elapsed(uRec.graceStartDt); // Grace minutes

                    // And talk within max inactive minutes or grace period
                    if ((graceElapseMin < self.graceMin) ||
                        (lastChatElapseMin < self.maxChatInactiveMin &&
                        secLastChatElapseMin < self.maxChatInactiveMin)) {
                        viewCamList.push(uName);
                    }
                    // Warn if cam will be hidden in one min's time
                    if (!uRec.isWarnCamHide) {
                        if (!((graceElapseMin + 1 < self.graceMin) ||
                            (lastChatElapseMin + 1 < self.maxChatInactiveMin &&
                            secLastChatElapseMin + 1 < self.maxChatInactiveMin))) {
                            uRec.warnCamHide();
                        }
                    }
                }
            }
        }
    });
    return viewCamList;
};

// Dump bot params
Bot.prototype.parms = function (oParsed) {
    var boardMsg = [
        ["S", "Peek Show/Hide Period..........<@>/<@> mins", this.cam.peekShowMin, this.cam.peekHideMin],
        ["S", "Max Chat Inactive Period..........<@> mins", this.maxChatInactiveMin],
        ["S", "Max Warning/Ban Inactive Period..........<@>/<@> mins", this.warnMin, this.banMin],
        ["S", "Warning Message..........<@>", this.warnMsg ? "'" + this.warnMsg + "'" : "(EMPTY)"],
        ["S", "Ban Message..........<@>", this.banMsg ? "'" + this.banMsg + "'" : "(EMPTY)"],
        ["S", "Notifier Cycle Period..........<@> mins", this.notifierCycleMin],
        ["M", "'<@>'", this.notifierMsg, "Notifier Messages"],
        ["M", "'<@>'", this.notifierModMsg, "Mod Notifier Message"],
        ["M", "'<@>'", this.welcomeMsg, "Welcome Messages"],
        ["M", "[<@>]", this.wlUser.sort(), "Whitelist Users", 4],
        ["M", "[<@>]", this.vip.sort(), "VIP Users", 4],
        ["M", "[<@>]", this.pfUser.sort(), "PF Users", 4],
        ["M", "[<@>]", this.modUser.sort(), "Mod Users", 4],
        ["M", "[<@>]", this.banUser.sort(), "Banned Users", 4],
        ["M", "[<@>]", this.banUserPrefix.sort(), "Banned Users Prefix", 4]
    ];
    this.normalBM().setHeader("'<@>' Bot Params", Bot.BOT_NAME).build(boardMsg).send(oParsed.byUName);
    return this;
};

// Grant white-list users
Bot.prototype.grantWL = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.alreadyWL}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.grantWL();
        self.announce(oParsed.byUName, "granted whitelist privilege to [<@>].", uName);
    });
    return this;
};

// Revoke white-list users
Bot.prototype.revokeWL = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.notWL}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.revokeWL();
        self.announce(oParsed.byUName, "revoked whitelist privilege from [<@>].", uName);
    });
    return this;
};

// Grant VIP privilege
Bot.prototype.grantVip = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.alreadyVip}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.grantVip();
        self.alertBM("You have been granted VIP privilege and the cam will not be hidden anymore.").send(uName);
        self.announce(oParsed.byUName, "granted VIP privilege to [<@>].", uName);
    });
    return this;
};

// Revoke VIP privilege
Bot.prototype.revokeVip = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.notVip}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.revokeVip();
        self.alertBM("You have been revoked VIP privilege and the cam will be hidden as normal.").send(uName);
        self.announce(oParsed.byUName, "revoked VIP privilege from [<@>].", uName);
    });
    return this;
};

// Grant PF rights
Bot.prototype.grantPF = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.alreadyPF}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.grantPF();
        self.systemBM("You have been granted access to Private Forum.").send(uName);
        self.announce(oParsed.byUName, "granted Private Forum access to [<@>].", uName);

        self.greetPF(valParam.uRec, true);
        self.systemBM("Type '/cmds' to list commands available to you.").send(uName);
    });
    return this;
};

// Revoke PF rights
Bot.prototype.revokePF = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.notPF}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.revokePF();
        self.alertBM("You have been revoked access to Private Forum.").send(uName);
        self.announce(oParsed.byUName, "revoked Private Forum access from [<@>].", uName);

        // Acknowledge other PF users
        var bm = self.systemBM().line("[<@>] has left the Private Forum.", uName);
        self.users.forEach(function (oURec) {
            var oURecName = oURec.getName();
            if (oURec.isPF && oURecName != uName && oURecName != oParsed.byUName) {
                bm.send(oURecName);
            }
        });
    });
    return this;
};

// Toggle PF mode on/off; if with param, send a direct PF
Bot.prototype.pf = function (oParsed) {
    var valParam = {uRec: oParsed.byURec};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.notPF, errorMsg: "You are not a PF user."}
    ]).check(oParsed.byUName, function () {
        if (oParsed.paramFull) { // Send PF message
            oParsed.msgCB["m"] = oParsed.paramFull;
            self.sendPF(oParsed.byURec, oParsed.msgCB, true);
        }
        else { // Toggle PF mode
            oParsed.byURec.isPFMode ? oParsed.byURec.setPFModeOff() : oParsed.byURec.setPFModeOn();
            self.systemBM().line("PF mode is <@>.", oParsed.byURec.isPFMode.toOnOff()).send(oParsed.byUName);
        }
    });
    return this;
};

// Set PF On
Bot.prototype.pfOn = function (oParsed) {
    var valParam = {uRec: oParsed.byURec};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.notPF, errorMsg: "You are not a PF user."},
        {testFn: this.val.alreadyPFMode}
    ]).check(oParsed.byUName, function () {
        oParsed.byURec.setPFModeOn();
        self.systemBM("PF mode is ON.").send(oParsed.byUName);
    });
    return this;
};

// Set PF Off
Bot.prototype.pfOff = function (oParsed) {
    var valParam = {uRec: oParsed.byURec};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.notPF, errorMsg: "You are not a PF user."},
        {testFn: this.val.notPFMode}
    ]).check(oParsed.byUName, function () {
        oParsed.byURec.setPFModeOff();
        self.systemBM("PF mode is OFF.").send(oParsed.byUName);
    });
    return this;
};

// Display room status
Bot.prototype.stat = function (oParsed) {
    var visitCount = 0,
        banCount = 0,
        autoBanCount = 0,
        vipCount = 0,
        pfCount = 0,
        wlCount = 0,
        muteCount = 0;

    this.users.forEach(function (uRec) {
        if (uRec.getName() != this.host) {
            if (uRec.isActive) visitCount++;
            if (uRec.isBan) banCount++;
            if (uRec.isAutoBan) autoBanCount++;
            if (uRec.isMute) muteCount++;
            if (uRec.isPF) pfCount++;
            if (uRec.isVip) vipCount++;
            if (uRec.isWL) wlCount++;
        }
    });

    var boardMsg = [
        ["S", "[No Sneak]....<@>____[Gender]....<@>____[Chat#]....<@>____[Spy]....<@>____[Trace]....<@>",
            this.noSneak.toYesNo(),
            this.gender.toYesNo(),
            this.chatNum.toYesNo(),
            this.bms.isSpy.toYesNo(),
            this.bms.isTrace.toYesNo()
        ],
        ["S", "[#Visited]....<@>____[#Ban]....<@>____[#O/s Autoban]....<@>____[#Mute]....<@>",
            visitCount,
            banCount,
            autoBanCount,
            muteCount
        ],
        ["S", "[#PF]....<@>____[#VIP]....<@>____[#Whitelist]....<@>____[Ban Word Mode]....<@>",
            pfCount,
            vipCount,
            wlCount,
            this.BAN_WORD[this.banWordMode].desc || ""
        ]
    ];
    this.normalBM().setHeader("Room Status").build(boardMsg).send(oParsed.byUName);
    return this;
};

// Display info about user
Bot.prototype.who = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userNotFound, errorMsg: "No information about [<@>].".mReplace(uName)}
    ]).check(oParsed.byUName, function () {
        self.normalBM().setHeader("User [<@>]", uName).line(valParam.uRec.toString().split("\n")).send(oParsed.byUName);
    });
    return this;
};

// List all user records
Bot.prototype.userRecList = function (oParsed) {
    this.listDumpUser(oParsed.byUName);
    return this;
};

// List users who had visited
Bot.prototype.allUserList = function (oParsed) {
    this.listAllUser(oParsed.byUName, false);
    return this;
};

// List users still in the room
Bot.prototype.hereUserList = function (oParsed) {
    this.listAllUser(oParsed.byUName, true);
    return this;
};

// List users currently under warning
Bot.prototype.warnedUserList = function (oParsed) {
    this.listWarnUser(oParsed.byUName, true);
    return this;
};

// List vip users
Bot.prototype.vipList = function (oParsed) {
    this.listVipUser(oParsed.byUName);
    return this;
};

// List PF users
Bot.prototype.pfList = function (oParsed) {
    this.listPFUser(oParsed.byUName);
    return this;
};

// List banned users
Bot.prototype.banList = function (oParsed) {
    this.listBanUser(oParsed.byUName);
    return this;
};

// List muted users
Bot.prototype.muteList = function (oParsed) {
    this.listMuteUser(oParsed.byUName);
    return this;
};

// List mod users
Bot.prototype.modList = function (oParsed) {
    this.listModUser(oParsed.byUName);
    return this;
};

// List WL users
Bot.prototype.whiteList = function (oParsed) {
    this.listWLUser(oParsed.byUName);
    return this;
};

// Create a text alarm
Bot.prototype.alarm = function (oParsed) {
    var uName = oParsed.param1;
    var minLater = parseInt(oParsed.param2);
    var msgText = oParsed.paramRest;
    var valParam = {uName: uName, minLater: minLater, text: msgText};

    if (uName) {
        var self = this;
        new Validation(this, valParam).addCase([
            {testFn: this.val.invalidMinute},
            {testFn: this.val.noText}
        ]).check(oParsed.byUName, function () {
            msgText = "Message from [<@>]: <@>".mReplace(oParsed.byUName, msgText);
            var userMsgAlarm = new NotifierBuzz(self, {
                cycleMin: minLater, msgList: msgText, toUser: uName, byURec: oParsed.byURec,
                times: 1, msgType: "alarm", desc: "User Message"
            }).on();
            self.alarmSystem.add(userMsgAlarm, oParsed.byUName);
            self.systemBM().line("You have scheduled a message to [<@>] in <@> minute(s)", uName, minLater).send(oParsed.byUName);
        });
    }
    else {
        this.alarmSystem.list(oParsed.byUName);
    }
    return this;
};

// List all triggered Ban prefixes
Bot.prototype.triggeredBanPreList = function (oParsed) {
    this.listBanPrefix(oParsed.byURec.getName(), true);
    return this;
};

// List all Ban prefixes
Bot.prototype.banPreList = function (oParsed) {
    this.listBanPrefix(oParsed.byURec.getName(), false);
    return this;
};

// Mute user
Bot.prototype.mute = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.alreadyMuted}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.mute();
        var _partial;
        if (valParam.uRec.isPartialMute) {
            self.warningBM().line("You are about to be muted. Your chat line is now limited to <@> characters.", self.muteChatLength).send(uName);
            _partial = "partially ";
        }
        else {
            self.warningBM("You have been muted.").send(uName);
            _partial = "";
        }
        self.announce(oParsed.byUName, "<@>muted [<@>].", _partial, uName);
    });
    return this;
};

// Un-mute user
Bot.prototype.unmute = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.notMuted}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.unmute();
        self.alertBM("You have been un-muted.").send(uName);
        self.announce(oParsed.byUName, "un-muted [<@>].", uName);
    });
    return this;
};

// Mark a user to be here
Bot.prototype.here = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost}
    ]).check(oParsed.byUName, function () {
        self.onEnter({user: uName});
        self.announce(oParsed.byUName, "emulated a mobile entrance for [<@>].", uName);
    });
    return this;
};

// Emulate a room exit
Bot.prototype.gone = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound}
    ]).check(oParsed.byUName, function () {
        self.onLeave({user: uName});
        self.announce(oParsed.byUName, "emulated a mobile exit for [<@>].", uName);
    });
    return this;
};

// Handle auto banned user
Bot.prototype.handle = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.notAutoban}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.handleAutoBan();
        self.announce(oParsed.byUName, "handled [<@>].", uName);
    });
    return this;
};

// Freeze a user record
Bot.prototype.freeze = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.alreadyFrozen}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.freeze();
        self.announce(oParsed.byUName, "frozen [<@>].", uName);
    });
    return this;
};

// Ban user
Bot.prototype.ban = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.alreadyBanned}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.ban();
        self.warningBM("You have been banned from the room.").send(uName);
        self.announce(oParsed.byUName, "banned [<@>].", uName);
    });
    return this;
};

// Unban user
Bot.prototype.unban = function (oParsed) {
    var uName = oParsed.param1.toLowerCase();
    var valParam = {uName: uName, uRec: undefined};

    var self = this;
    new Validation(this, valParam).addCase([
        {testFn: this.val.userParamMissing},
        {testFn: this.val.userIsHost},
        {testFn: this.val.userNotFound},
        {testFn: this.val.notBanned}
    ]).check(oParsed.byUName, function () {
        valParam.uRec.unban();
        self.alertBM("You have been unbanned from the room.").send(uName);
        self.announce(oParsed.byUName, "unbanned [<@>].", uName);
    });
    return this;
};

// Update mod notifier message
Bot.prototype.modMsg = function (oParsed) {
    this.notifierModMsg.splice(0, 1);
    if (oParsed.paramFull) {
        this.notifierModMsg.push(oParsed.paramFull.trim());
    }
    return this;
};

// Toggle chat# on/off
Bot.prototype.toggleChatNum = function (oParsed) {
    this.chatNum = !this.chatNum;
    this.announce(oParsed.byUName, "<@> 'Chat#'.", this.chatNum.toEnDis());
    return this;
};

// Toggle no sneak on/off
Bot.prototype.toggleSneak = function (oParsed) {
    this.noSneak = !this.noSneak;
    this.announce(oParsed.byUName, "<@> 'No Sneak-In'.", this.noSneak.toEnDis());
    return this;
};

// Toggle gender on/off
Bot.prototype.toggleGender = function (oParsed) {
    this.gender = !this.gender;
    this.announce(oParsed.byUName, "<@> 'Gender'.", this.gender.toEnDis());
    return this;
};

// Press the panic button
Bot.prototype.panic = function (oParsed) {
    var camMode = this.getCamMode();
    if (["show", "vip"].contains(camMode)) {
        this.alertBM().line("The room is already in <@> mode.", camMode.toUpperCase()).send(oParsed.byUName);
    } else {
        this.announce(oParsed.byUName, "pressed the panic button.");
        this.cam.setMode(this.host, "show");
    }
    return this;
};

// List CB cam viewer list
Bot.prototype.camViewer = function (oParsed) {
    this.cam.listCamViewer(oParsed.byUName);
    return this;
};

// Display the room mode status
Bot.prototype.camMode = function (oParsed) {
    this.cam.printMode(oParsed.byUName);
    return this;
};

// Switch to VIP mode
Bot.prototype.vipMode = function (oParsed) {
    this.cam.setMode(oParsed.byUName, "vip");
    return this;
};

// Switch to SHOW mode
Bot.prototype.showMode = function (oParsed) {
    this.cam.setMode(oParsed.byUName, "show");
    return this;
};

// Switch to TALK mode
Bot.prototype.talkMode = function (oParsed) {
    this.cam.setMode(oParsed.byUName, "talk");
    return this;
};

// Switch to PEEK mode
Bot.prototype.peekMode = function (oParsed) {
    this.cam.setMode(oParsed.byUName, "peek");
    return this;
};

// Switch to PUBLIC mode
Bot.prototype.publicMode = function (oParsed) {
    this.cam.setMode(oParsed.byUName, "public");
    return this;
};

// Switch to Strict Ban Word mode
Bot.prototype.strictBanWord = function (oParsed) {
    this.setBanWordMode(oParsed.byUName, "strict");
    return this;
};

// Switch to Loose Ban Word mode
Bot.prototype.looseBanWord = function (oParsed) {
    this.setBanWordMode(oParsed.byUName, "loose");
    return this;
};

// Switch off Ban Word mode
Bot.prototype.noBanWord = function (oParsed) {
    this.setBanWordMode(oParsed.byUName, "none");
    return this;
};

// Set ban word mode
Bot.prototype.setBanWordMode = function (byUName, sMode) {
    var _upperMode = sMode.toUpperCase();
    // sMode values: strict, loose, none
    if (this.banWordMode == sMode) {
        this.alertBM().line("The ban word mode is already set to <@>.", _upperMode).send(byUName);
    } else {
        var banSet = this.BAN_WORD[sMode] || this.BAN_WORD.none;
        this.banWordRE = banSet.re;
        this.banWordList = banSet.wordList;
        this.banWordMode = sMode;
        this.announce(byUName, "switched ban word mode to [<@>].", _upperMode);
    }
    return this;
};

// Toggle Spy mode on/off
Bot.prototype.spy = function (oParsed) {
    this.systemBM().line("Spy mode is <@>.", this.bms.toggleSpy(oParsed.byUName).toOnOff()).send(oParsed.byUName);
    return this;
};

// Toggle Trace mode on/off
Bot.prototype.trace = function (oParsed) {
    this.systemBM().line("Trace mode is <@>.", this.bms.toggleTrace(oParsed.byUName).toOnOff()).send(oParsed.byUName);
    return this;
};

// Perform ban words check (return ban word if hit)
Bot.prototype.banWordCheck = function (uName, sMsg) {
    var self = this;

    function updateHit(match) {
        for (var i = 0; i < self.banWordList.length; i++) {
            if (arguments[i + 1]) {
                self.banWordList[i].wordHit(uName);
                hits.push("'<@>'".mReplace(match));
                return;
            }
        }
    }

    var hits = [];
    sMsg.replace(this.banWordRE, updateHit);
    if (hits.length > 0) {
        this.warningBM().line("You have entered ban word(s) <@>.", hits.engJoin()).send(uName);
        return true;
    }
};

// Perform ban and ban prefix check (return true if ban found)
Bot.prototype.banCheck = function (uRec, bEnter) {
    var uName = uRec.getName();
    if (uRec.isBan) { // Ban check
        var bm = this.warningBM("You are banned in this room.");
        if (this.banMsg) {
            bm.line(this.banMsg).send(uName);
        }
        bm.send(uName);

        if (bEnter) {
            this.alertBM().line("Banned user [<@>] just entered the room.", uName).send(this.host);
        }
        return true;
    }
    else { // Ban prefix check
        return this.userPrefixCheck(uName, bEnter);
    }
};

// On users entering the room
Bot.prototype.onEnter = function (userCB) {
    if (this.auth) { // Quit if not authorized
        var uName = userCB["user"];
        var uRec = this.getUser(uName, true).enter();
        if (!uRec.isHost) {
            this.sneakCheck(uRec, userCB, true).vipEnter(uRec).banCheck(uRec, true);
        }

        if (!uRec.isBan) { // No more processing for banned user
            // Build up the greet messages
            // Welcome messages and user privileges
            var bm = this.normalBM();
            if (!uRec.isHost) {
                bm.line(this.welcomeMsg);
            }
            bm.line(uRec.privilegeStr());

            // Command info for host, Mod and PF users
            if (uRec.isMod || uRec.isPF || uRec.isHost) {
                bm.line("Type '/cmds' to list commands available to you.");
            }
            // Final send here
            bm.send(uName);

            // Message for SHOW/VIP mode
            var camMode = this.getCamMode();
            if ((["show", "vip"].contains(camMode)) && !uRec.isVip) {
                bm = this.alertBM().line("The room is in <@> mode. Only VIP users will see the cam.", camMode.toUpperCase());
                if (camMode == "vip") {
                    bm.line("Currently only VIP users can chat in this room.");
                }
                bm.send(uName);
            }

            this.greetPF(uRec, false);

            // Show PF and VIP chat histories
            this.dumpPFAndVipHist(uRec);
        }
    }
    return this;
};

// On users leaving the room
Bot.prototype.onLeave = function (userCB) {
    var uName = userCB["user"];
    if (this.auth && uName != this.host) {
        var uRec = this.getUser(uName, true).leave();

        // Inform on sneak in greys
        if (!uRec.isHost) {
            this.sneakCheck(uRec, userCB, false);
        }
    }
    return this;
};

// On users typing a message
Bot.prototype.onMessage = function (msgCB) {
    if (this.auth) { // Quit if not authorized
        var uName = msgCB["user"];
        var uRec = this.getUser(uName, true).message();

        var oParsed = Command.parse(msgCB["m"]);
        oParsed.msgCB = msgCB;
        oParsed.byURec = uRec;
        oParsed.byUName = uName;

        if (uName != this.host) { // Checking for non-broadcaster
            if (this.banCheck(uRec, false)) {
                msgCB["X-Spam"] = true;
                msgCB["m"] = ""; // Clear the message
                return this;
            }

            if (this.getCamMode() == "vip" && !uRec.isVip) {
                this.alertBM("Currently only VIP users can chat in this room.").send(uName);
                msgCB["X-Spam"] = true;
                msgCB["m"] = ""; // Clear the message
                return this;
            }

            if (uRec.isFullMute) {
                this.alertBM("You have been muted.").send(uName);
                msgCB["X-Spam"] = true;
                msgCB["m"] = ""; // Clear the message
                return this;
            }
            else if (uRec.isPartialMute) {
                msgCB["m"] = msgCB["m"].slice(0, this.muteChatLength).replace(/:/g, ""); // Cut the length and disable gif
                msgCB["c"] = "#E6E6E6"; // Dim the text
            }

            if (!uRec.isVip) { // Ban word check
                var hitWord = this.banWordCheck(uName, msgCB["m"]);
                if (hitWord) {
                    uRec.wordBan(hitWord);
                    msgCB["X-Spam"] = true;
                    msgCB["m"] = ""; // Clear the message
                }
            }
        }

        uRec.interact();
        if (this.cmd.execCmd(oParsed)) {
            msgCB["X-Spam"] = true;
        }
        else { // Non-commands
            if (msgCB["m"].length > 1) uRec.chat();
            if (uRec.isPFMode) {
                this.sendPF(uRec, msgCB, false); // Send PF message
            }
            else if (uRec.isVip && this.getCamMode() == "vip") {
                this.sendVip(uRec, msgCB); // Send VIP message
            }
        }

        // Handle gender mode
        if (this.gender && !msgCB["X-Spam"]) {
            var gif = Bot.GENDER_GIF_MAP[msgCB["gender"]];
            if (uRec.isHost) {
                gif = Bot.GENDER_GIF_MAP.host;
            }
            else if (["squeak2596", "nomorelonelynight"].indexOf(uName) > -1) {
                gif = Bot.GENDER_GIF_MAP.queen;
            }
            msgCB["m"] = (gif + " " || "") + msgCB["m"];
        }
        // prepend chat# to chat line
        if (this.chatNum && uName != this.host && !msgCB["X-Spam"] && uRec.numChat < this.chatNumGoal) {
            msgCB["m"] = "[<@>] ".replace(/<@>/g, String(uRec.numChat)) + msgCB["m"];
        }
    }
    return this;
};

// Parse CB params
Bot.parseCbParam = function (cbHost, oCBSetting) {
    // Convert delimited string to array
    function csvToArray(sList) {
        return (String(sList).toLowerCase().match(/(\*?\b[\w\d_ ']+\b\*?)/g) || []).sort();
    }

    // Trim a text string
    function trimStr(sText) {
        return String(sText).trim();
    }

    // Filter empty strings from array
    function filterEmptyArray(asText) {
        return Util.toArray(asText).filter(function (sElement) {
            return Boolean(sElement);
        });
    }

    return {
        host: cbHost, // Host
        vip: csvToArray(oCBSetting.vip_list), // VIP user
        banUser: csvToArray(oCBSetting.ban_list), // Ban user
        banUserPrefix: csvToArray(oCBSetting.ban_prefix_list), // Ban user prefix
        pfUser: csvToArray(oCBSetting.pf_list), // PF user
        modUser: csvToArray(oCBSetting.mod_list), // Mod user
        wlUser: csvToArray(oCBSetting.warning_whitelist), // Whitelist user
        maxChatInactiveMin: parseInt(oCBSetting.chat_inactive_time),
        peekShowMin: parseInt(oCBSetting.peek_show_min),
        peekHideMin: parseInt(oCBSetting.peek_hide_min),
        banMsg: trimStr(oCBSetting.ban_msg),
        banMin: parseInt(oCBSetting.ban_inactive_time),
        warnMsg: trimStr(oCBSetting.warning_msg),
        warnMin: parseInt(oCBSetting.warning_inactive_time),
        welcomeMsg: filterEmptyArray([
            trimStr(oCBSetting.welcome_msg1),
            trimStr(oCBSetting.welcome_msg2),
            trimStr(oCBSetting.welcome_msg3),
            trimStr(oCBSetting.welcome_msg4),
            trimStr(oCBSetting.welcome_msg5)
        ]),
        notifierCycleMin: parseInt(oCBSetting.notify_cycletime),
        notifierMsg: filterEmptyArray([
            trimStr(oCBSetting.notify_msg1),
            trimStr(oCBSetting.notify_msg2),
            trimStr(oCBSetting.notify_msg3),
            trimStr(oCBSetting.notify_msg4),
            trimStr(oCBSetting.notify_msg5)
        ]),
        banWord: csvToArray(oCBSetting.ban_word_list),
        banWordStrict: csvToArray(oCBSetting.strict_ban_word_list),
        maxBanWord: parseInt(oCBSetting.max_ban_word)
    };
};

// Gif maps for gender
Bot.GENDER_GIF_MAP = {
    m: ":kittensclub",
    f: ":unicorn2",
    s: ":angel",
    c: ":beardancing",
    host: ":king4",
    queen: ":crownprincess"
};

// Create a BotMessage
Bot.prototype.createUser = function (sUserType, asNameList) {
    var self = this;

    Util.toArray(asNameList).forEach(function (uName) {
        var uRec = self.getUser(uName, true);
        switch (sUserType) {
            case "host":
                uRec.grantHost().grantPF().grantVip().grantWL().enter();
                break;
            case "mod":
                uRec.grantMod().grantPF().grantVip().grantWL();
                break;
            case "pf":
                uRec.grantPF().grantVip().grantWL();
                break;
            case "vip":
                uRec.grantVip().grantWL();
                break;
            case "whitelist":
                uRec.grantWL();
                break;
            case "ban":
                uRec.ban();
                break;
        }
    });
    return this;
};

// Create a BotMessage
Bot.prototype.bm = function (sMsgType, sLine, sLineType) {
    return this.bms.bm(sMsgType, sLine, sLineType);
};

// Create a normal BotMessage
Bot.prototype.normalBM = function (sLine, sLineType) {
    return this.bms.bm("normal", sLine, sLineType);
};

// Create an alert BotMessage
Bot.prototype.alertBM = function (sLine, sLineType) {
    return this.bms.bm("alert", sLine, sLineType);
};

// Create a system BotMessage
Bot.prototype.systemBM = function (sLine, sLineType) {
    return this.bms.bm("system", sLine, sLineType);
};

// Create a warning BotMessage
Bot.prototype.warningBM = function (sLine, sLineType) {
    return this.bms.bm("warning", sLine, sLineType);
};

// Create a debug BotMessage
Bot.prototype.debugBM = function (sLine, sLineType) {
    return this.bms.bm("debug", sLine, sLineType);
};

// Create a PF BotMessage
Bot.prototype.pfBM = function (sLine, sLineType) {
    return this.bms.bm("pf", sLine, sLineType);
};

// Create a VIP BotMessage
Bot.prototype.vipBM = function (sLine, sLineType) {
    return this.bms.bm("vip", sLine, sLineType);
};

// Get host name
Bot.prototype.getHost = function () {
    return this.host;
};

// Greetings to granted PF user
Bot.prototype.greetPF = function (uRec, bSkipSelf) {
    if (uRec.isPF) {
        var uName = uRec.getName();
        // Display existing active PF users to newly joined PF user
        this.listPFUser(uName, true);

        // Acknowledge existing PF users
        var bm = this.systemBM().line("[<@>] has joined the Private Forum.", uName);
        this.users.forEach(function (oURec) {
            var oURecName = oURec.getName();
            if (oURec.isPF && (!bSkipSelf || oURecName != uName))
                bm.send(oURecName);
        });
    }
    return this;
};

// Announce message
Bot.prototype.announce = function (byUName, sTemplate /* actionText with replace-params */) {
    var actionText = String.prototype.mReplace.apply(sTemplate, Array.prototype.slice.call(arguments, 2));

    this.systemBM().line("You have <@>", actionText).send(byUName);
    if (byUName != this.host) {
        this.alertBM().line("[<@>] has <@>", byUName, actionText).send(this.host);
    }
    return this;
};

// Send a PF message for byUser
Bot.prototype.sendPF = function (uRec, msgCB, bSkipModeCheck) {
    if (uRec.isPF && (bSkipModeCheck || uRec.isPFMode)) {
        uRec.pfChat();

        var bm = this.pfBM().line("[<@>]: <@>", uRec.getName(), msgCB["m"]);
        this.users.forEach(function (oURec) {
            if (oURec.isPF)
                bm.send(oURec.getName());
        });

        this.bms.logHist("pf", bm);

        msgCB["X-Spam"] = true;
        msgCB["m"] = ""; // Remove the whole message on normal chat
    }
    return this;
};

// Send a VIP message for byURec
Bot.prototype.sendVip = function (uRec, msgCB) {
    if (uRec.isVip && this.getCamMode() == "vip") {
        var bm = this.vipBM().line("[<@>]: <@>", uRec.getName(), msgCB["m"]);
        this.users.forEach(function (oURec) {
            if (oURec.isVip)
                bm.send(oURec.getName());
        });

        this.bms.logHist("vip", bm);

        msgCB["X-Spam"] = true;
        msgCB["m"] = ""; // Remove the whole message on normal chat
    }
    return this;
};

// List all ban words
Bot.prototype.listBanWord = function (oParsed) {
    var bm = this.normalBM().setHeader("Ban Words");
    this.banWordList.forEach(function (bw) {
        bm.line(bw);
    });

    if (bm.isEmpty) {
        bm = this.systemBM("There is no ban words.");
    }
    bm.send(oParsed.byUName);
    return this;
};

// List all ban prefixes
Bot.prototype.listBanPrefix = function (byUName, bTrigger) {
    var bm = this.normalBM().setHeader("Banned Prefix");
    this.userPrefix.sort(UserPrefix.orderByPrefix).forEach(function (uPreRec) {
        if ((bTrigger && uPreRec.isActivated) || !bTrigger) {
            bm.line(uPreRec);
        }
    });

    if (bm.isEmpty) {
        bm = this.systemBM("There is no triggered banned prefix.");
    }
    bm.send(byUName);
    return this;
};

// List Vip users
Bot.prototype.listVipUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isVip && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "VIP", byUName, bHere);
    return this;
};

// List PF users
Bot.prototype.listPFUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isPF && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "PF", byUName, bHere);
    return this;
};

// List banned users
Bot.prototype.listBanUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isBan && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "Banned", byUName, bHere);
    return this;
};

// List muted users
Bot.prototype.listMuteUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isMute && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "Muted", byUName, bHere);
    return this;
};

// List mod users
Bot.prototype.listModUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isMod && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "Mod", byUName, bHere);
    return this;
};

// List white-list users
Bot.prototype.listWLUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isWL && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "Whitelist", byUName, bHere);
    return this;
};

// List in-record users
Bot.prototype.listDumpUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return (bHere && uRec.isHere) || !bHere;
    };
    this.listUser(filterFn, "In Record", byUName, bHere);
    return this;
};

// List all users
Bot.prototype.listAllUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isActive && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "All", byUName, bHere);
    return this;
};

// List warned users
Bot.prototype.listWarnUser = function (byUName, bHere) {
    bHere = bHere || false;
    var filterFn = function (uRec) {
        return uRec.isInactiveWarn && ((bHere && uRec.isHere) || !bHere);
    };
    this.listUser(filterFn, "Warned", byUName, bHere);
    return this;
};

// List users (bHere to select only viewers in the room)
Bot.prototype.listUser = function (fFilter, sLabel, byUName, bHere) {
    var bm = this.normalBM().setHeader("<@> Users<@>", sLabel, bHere ? " in the room" : "");
    this.users.filter(fFilter).sort(User.orderByName).forEach(function (uRec) {
        var tag = [];
        if (uRec.lastActiveDt) tag.push("[" + Util.elapsed(uRec.lastActiveDt).toFixed(2) + " min(s)]");
        if (uRec.isHere) tag.push("[here]");
        if (!uRec.isActive) tag.push("[inactive]");
        if (uRec.isInactiveWarn) tag.push("[warned]");
        if (uRec.isMute) tag.push((uRec.isPartialMute ? "[p-mute]" : "[mute]"));
        if (uRec.isFrozen) tag.push("[frozen]");

        bm.line("[<@>]<@>", uRec.getName(), tag.length > 0 ? "---" + tag.join(" ") : "");
    });

    if (bm.isEmpty) {
        bm = this.systemBM().line("There is no matched user<@>.", bHere ? " in the room" : "");
    }
    bm.send(byUName);
    return this;
};

// Check if matched banned user prefix
Bot.prototype.userPrefixCheck = function (uName, bEnter) {
    var uPreRec = undefined;
    for (var i = 0; !uPreRec && i < this.userPrefix.length; i++) {
        if (this.userPrefix[i].nameHit(uName)) {
            uPreRec = this.userPrefix[i];
        }
    }
    if (uPreRec) {
        var bm = this.warningBM("You are banned in this room.");
        if (this.banMsg) {
            bm.line(this.banMsg);
        }
        bm.send(uName);

        if (bEnter) {
            this.alertBM().line("User [<@>] matching ban prefix [<@>] just entered the room.",
                uName,
                uPreRec.getPrefix()
            ).send(this.host);
        }
        uRec.ban();
        return true;
    }
    else return false;
};

// Sneak-in check
Bot.prototype.sneakCheck = function (uRec, userCB, bEnter) {
    if (this.noSneak && !userCB["is_mod"]) { // Handle all except mods
        var uName = userCB["user"];

        var bm = this.bm(bEnter ? "entrance" : "exit").line("<@> [<@>] has <@> the room<@>.",
            uRec.isHost ? Bot.GENDER_GIF_MAP.host : Bot.GENDER_GIF_MAP[userCB["gender"]] || "",
            uName,
            bEnter ? "entered" : "left",
            bEnter ? " [<@> time(s), <@> chat(s)]<@><@><@>".mReplace(
                uRec.getEntryCount(),
                uRec.getChatCount(),
                uRec.isVip ? " [Vip]" : "",
                uRec.isBan ? " [Banned]" : "",
                uRec.isInactiveWarn ? " [Warned]" : ""
            ) : ""
        ).send(this.host);
        this.modUser.forEach(function (sName) { // Only mods, not including itself
            if (sName != uName) bm.send(sName);
        });
    }
    return this;
};

// VIP entrance
Bot.prototype.vipEnter = function (uRec) {
    // Notify host on entry of VIPs
    if (uRec.isVip && (["show", "vip"].contains(this.getCamMode()))) {
        this.systemBM().line("VIP user [<@>] just entered the room.", uRec.getName()).send(this.host);
    }
    return this;
};

// Regular check for user
Bot.prototype.regularCheck = function () {
    var self = this;
    this.users.forEach(function (uRec) {
        // Handle PF reminder
        if (!uRec.isFrozen) { // Not frozen
            if (uRec.isHere) {
                uRec.checkAlarm();
            }

            var uName = uRec.getName();
            if (!uRec.isHost) { // Not broadcaster
                // Keep messaging broadcaster for auto banned users
                if (uRec.isAutoBan) {
                    self.warningBM().line("You need to handle the auto banned [<@>].", uName).send(self.host);
                }

                // Keep messaging banned users
                if (uRec.isBan && uRec.isHere) {
                    var bm = self.warningBM("You are banned in this room.");
                    if (self.banMsg) {
                        bm.line(self.banMsg);
                    }
                    bm.send(uName);
                }

                // Max ban words attempts ban
                if (!uRec.isBan && uRec.getBanWordCount() > self.maxBanWord) {
                    self.warningBM("You have been banned from the room.").send(uName);
                    uRec.autoBan();
                }

                // If gone for certain minutes
                if (!uRec.isHere && Util.elapsed(uRec.lastExitDt) > self.offlineNewLifeMin && !uRec.isNewLife) {
                    uRec.grantNewLife();
                }

                // Handle auto ban for inactive viewers
                if (uRec.isHere && !uRec.isWL && !uRec.isBan) { // In the room, not in whitelist, not banned
                    var lastActiveMin = Util.elapsed(uRec.lastActiveDt);
                    if (lastActiveMin >= self.banMin) {
                        self.warningBM("You have been banned from the room.").send(uName);
                        uRec.autoBan();
                    }
                    // Handle warnings for inactive viewers
                    else if (lastActiveMin >= self.warnMin) {
                        if (!uRec.isInactiveWarn) {
                            self.alertBM().line("[<@>] had been inactive for over <@> minute(s).",
                                uName,
                                self.warnMin
                            ).send(self.host);
                            uRec.warn();
                        }
                        if (self.warnMsg) {
                            self.alertBM().line("ATTENTION [<@>] <@>", uName, self.warnMsg).send(uName);
                        }
                    }
                    else {
                        uRec.resetWarn();
                    }
                }
            }
        }
    });
};

// Reassess active users for cam viewing
Bot.prototype.reassess = function () {
    // Late hour warning (disabled)
    //    this.lateTimeReport.check();

    // Handle trace mode
    if (this.bms.isTrace) {
        var boardMsg = [
            ["G", "[<@>]", cb.limitCam_allUsersWithAccess(), "Users in View Cam List", 4]
        ];
        this.bms.traceLog(this.debugBM(this.cam.modeStatus()));
        this.bms.traceLog(this.debugBM().build(boardMsg));
    }

    // Check the alarms
    this.alarmSystem.check();

    this.regularCheck();

    this.cam.update();
    return this;
};

// Bot initialization
Bot.prototype.init = function () {
    var self = this;

    // Create/update records for host, white-list, VIP, PF, mod and banned users
    this.createUser("host", this.host).createUser("whitelist", this.wlUser).createUser("vip", this.vip).createUser("pf", this.pfUser).createUser("mod", this.modUser).createUser("ban", this.banUser);

    // Create banned user prefixes
    this.userPrefix = [];
    var prevPrefix = "";
    this.banUserPrefix.sort().forEach(function (sPrefix) {
        if (prevPrefix != sPrefix) { // Checking to bypass duplicate entries
            self.userPrefix.push(new UserPrefix(sPrefix));
        }
        prevPrefix = sPrefix;
    });

    // Initialize for alarms and alarm system
    var notifierMsgBuzz = new NotifierBuzz(this, {
        cycleMin: this.notifierCycleMin, msgList: this.notifierMsg, desc: "Notifier Message"
    }).on();
    var notifierModMsgBuzz = new NotifierBuzz(this, {
        cycleMin: this.notifierCycleMin, msgList: this.notifierModMsg, desc: "Notifier Mod Message"
    }).on();
    this.alarmSystem.add(notifierMsgBuzz).add(notifierModMsgBuzz);

    // Recursive timeout Loop
    function timeoutLoop() {
        self.reassess();
        cb.setTimeout(timeoutLoop, self.checkCycleSec);
    }

    timeoutLoop();
    return this;
};

// Retrieve user record by name
Bot.prototype.getUser = function (sName, bCreate /* create record if not found */) {
    if (!sName) return;
    for (var i = 0; i < this.users.length; i++) {
        if (this.users[i].getName() == sName) {
            return this.users[i];
        }
    }
    if (bCreate) {
        var uRec = new User(this, {name: sName, pfTriggerMin: this.pfTriggerMin, pfCycleMin: this.pfCycleMin});
        this.users.push(uRec);
        return uRec;
    }
};

// ---------------
// Bot Message Class
function BotMessage(bms, sMsgType, sLine, sLineType) {
    this.msgType = sMsgType || "normal";
    this.message = [];
    this.header = undefined;
    this.trailer = undefined;
    this.bms = bms;
    var self = this;
    Object.defineProperties(this, {
        isFramed: {
            get: function () {
                return Boolean(self.header);
            }
        },
        isEmpty: {
            get: function () {
                return self.message.length == 0;
            }
        }
    });

    if (sLine) this.addLine(sLine, sLineType || "D");
}

// Convert to string
BotMessage.prototype.toString = function () {
    return this.message.map(function (oEntry) {
        return oEntry.line;
    }).join("\n");
};

// send the message
BotMessage.prototype.send = function (uName) {
    this.bms.send(this, uName);
    return this;
};

// Add one line to message
BotMessage.prototype.addLine = function (sLine, sLineType) {
    if (sLine) this.message.push({line: sLine, lineType: sLineType || "D"});
    return this;
};

// Set frame header
BotMessage.prototype.setHeader = function (sHeader) {
    this.header = sHeader && String.prototype.mReplace.apply(sHeader, Array.prototype.slice.call(arguments, 1)) || "START";
    this.trailer = this.trailer || "END";
    return this;
};

// Add a formatted template (array for multiple lines) with replacing strings
BotMessage.prototype.line = function (asTemplate /* , replacing strings if any */) {
    var self = this;
    if (asTemplate) {
        var param = Array.prototype.slice.call(arguments, 1);
        Util.toArray(asTemplate).forEach(function (sTemplate) {
            self.addLine(String.prototype.mReplace.apply(sTemplate, param));
        });
    }
    return this;
};

// Build multiple items per row
BotMessage.prototype.buildRow = function (sTemplate, aList, itemCount) {
    var self = this;
    itemCount = itemCount || 1;

    var aTemp = [];
    aList.map(function (sParam) {
        return sTemplate.mReplace(sParam);
    }).forEach(function (sEntry, idx) {
        aTemp.push(sEntry);
        if ((idx + 1) % itemCount == 0) {
            self.line(aTemp.join(" "));
            aTemp = [];
        }
    });
    if (aTemp.length > 0) {
        this.line(aTemp.join(" "));
    }
    return this;
};

// Build the messages from the board template
BotMessage.prototype.build = function (aBoardMsg) {
    var self = this;
    aBoardMsg.forEach(function (oBoardLine) {
        var template = oBoardLine[1];
        switch (oBoardLine[0]) {
            case "S": // Format is ["S", template, replacing-params]
                self.line.apply(self, [template].concat(oBoardLine.slice(2)));
                break;
            case "M": // Format is ["M", template (singular param), replacing-param-array, title, item-per-row]
                if (Array.isArray(oBoardLine[2])) {
                    if (oBoardLine[2].length > 0) {
                        self.addLine(oBoardLine[3], "B");
                        self.buildRow(template, oBoardLine[2], oBoardLine[4]);
                    }
                    else self.line(oBoardLine[3] + " (EMPTY)", "B");
                }
                else self.line("ERROR");
                break;
            case "G": // Format is ["G", template (singular param), replacing-param-array, title, item-per-row]
                if (Array.isArray(oBoardLine[2])) {
                    if (oBoardLine[2].length > 0) {
                        self.setHeader(oBoardLine[3]);
                        self.buildRow(template, oBoardLine[2], oBoardLine[4]);
                    }
                    else self.line(oBoardLine[3] + " (EMPTY)");
                }
                else self.line("ERROR");
                break;
        }
    });
    return this;
};

// Bot Message System Class
function BotMessageSystem(sHost, nHistMaxMin, nMaxChatHist) {
    this.host = sHost;
    this.histMaxMin = nHistMaxMin;
    this.maxChatHist = nMaxChatHist;
    this.spyUser = [];
    this.traceUser = [];
    this.pfHist = [];
    this.vipHist = [];

    // Canvases
    this.HEADER_CANVAS = "\u250C" + new Array(41).join("\u2500");
    this.BREAKER_CANVAS = "\u251C" + new Array(41).join("\u2500");
    this.TRAILER_CANVAS = "\u2514" + new Array(41).join("\u2500");
    this.BULLET = "\u25CF";
    this.LIST = "\u251C";

    var self = this;
    Object.defineProperties(this, {
        isSpy: {
            get: function () {
                return self.spyUser.length > 0;
            }
        },
        isTrace: {
            get: function () {
                return self.traceUser.length > 0;
            }
        }
    });
}

// ---------------
// Bot Message Class
BotMessageSystem.prototype.bm = function (sMsgType, sLine, sLineType) {
    return new BotMessage(this, sMsgType, sLine, sLineType);
};

// Overlay text on a canvas string
BotMessageSystem.overlay = function (sCanvas, nPos, sOverText) {
    sOverText = sOverText || "";
    return sCanvas.substr(0, nPos) + sOverText + sCanvas.substr(nPos + sOverText.length);
};

// Toggle trace user (return true if added, false if removed)
BotMessageSystem.prototype.toggleTrace = function (uName) {
    return this.traceUser.toggleEntry(uName);
};

// Toggle spy user (return true if added, false if removed)
BotMessageSystem.prototype.toggleSpy = function (uName) {
    return this.spyUser.toggleEntry(uName);
};

// Log chat lines
BotMessageSystem.prototype.logHist = function (sType, botMsg) {
    var hist = [];
    if (sType == "pf") hist = this.pfHist;
    if (sType == "vip") hist = this.vipHist;
    hist.shrink(this.maxChatHist - 1).push({logDate: new Date(), msg: botMsg});
    return this;
};

// Dump all logged chat lines
BotMessageSystem.prototype.dumpHist = function (sType, uRec) {
    var self = this;

    var initEntryDt = uRec.getInitEntryDt();
    if (initEntryDt) {
        var hist = [];
        if (sType == "pf" && uRec.isPF) hist = this.pfHist;
        if (sType == "vip" && uRec.isVip) hist = this.vipHist;

        var log = hist.filter(function (oEntry) {
            return oEntry.logDate >= initEntryDt && Util.elapsed(oEntry.logDate) < self.histMaxMin;
        }).map(function (oEntry) {
            return oEntry.msg;
        }).join("\n");
        if (log)
            this.bm(sType, log).send(uRec.getName());
    }
    return this;
};

// Send a message to all trace users
BotMessageSystem.prototype.traceLog = function (botMsg) {
    botMsg.send(this.traceUser);
    return this;
};

// Send a message to chat room (blank asToUser implies all)
BotMessageSystem.prototype.send = function (botMsg, asToUser /* blank = all */) {
    var self = this;

    var msgStyle = {
        alarm: {
            textColor: "",
            textBackColor: "#FA5858",
            spy: true
        },
        alert: {
            textColor: "#CC0000",
            textBackColor: "",
            spy: true
        },
        system: {
            textColor: "#08088A",
            textBackColor: "",
            spy: true
        },
        warning: {
            textColor: "",
            textBackColor: "#FE642E",
            spy: true
        },
        pf: {
            textColor: "",
            textBackColor: "#BCF5A9",
            spy: false
        },
        vip: {
            textColor: "",
            textBackColor: "#F8E0F7",
            spy: false
        },
        debug: {
            textColor: "",
            textBackColor: "#F2F5A9",
            spy: false
        },
        spy: {
            textColor: "",
            textBackColor: "#A9E2F3",
            spy: false
        },
        entrance: {
            textColor: "",
            textBackColor: "#FADBD8",
            spy: true
        },
        exit: {
            textColor: "",
            textBackColor: "#FCF3CF",
            spy: true
        },
        default: {
            textColor: "",
            textBackColor: "",
            spy: true
        }
    };

    var tmpMsg = botMsg.message.slice();
    var msgText;

    if (botMsg.isFramed) {
        if (tmpMsg.length == 0) {
            tmpMsg.push({line: "<EMPTY>", lineType: "D"});
        }
        tmpMsg.unshift({line: botMsg.header, lineType: "H"});
        tmpMsg.push({line: botMsg.trailer, lineType: "T"});
        msgText = tmpMsg.map(function (oMsg) {
            switch (oMsg.lineType) {
                case "H":
                    return BotMessageSystem.overlay(self.HEADER_CANVAS, 3, oMsg.line);
                case "B":
                    return BotMessageSystem.overlay(self.BREAKER_CANVAS, 3, oMsg.line);
                case "T":
                    return BotMessageSystem.overlay(self.TRAILER_CANVAS, 3, oMsg.line);
                default:
                    return self.LIST + " " + oMsg.line;
            }
        }).join("\n");
    }
    else {
        msgText = tmpMsg.map(function (oMsg) {
            if (["alert", "system", "warning"].indexOf(botMsg.msgType) > -1) {
                return self.BULLET + " " + oMsg.line + " " + self.BULLET;
            }
            else {
                return oMsg.line;
            }
        }).join("\n");
    }
    if (msgText) {
        var style = msgStyle[botMsg.msgType] || msgStyle.default;
        Util.toArray(asToUser || "").forEach(function (uName) {
            cb.sendNotice(msgText, uName, style.textBackColor, style.textColor, "bold");
            if (style.spy && uName == self.host) { // Spy on host message
                var spyText = msgText.split("\n").map(function (sTextLine) {
                    return "<SPY> " + sTextLine;
                }).join("\n");
                self.spyUser.forEach(function (spyUName) {
                        cb.sendNotice(spyText, spyUName, msgStyle.spy.textBackColor, msgStyle.spy.textColor, "bold");
                    }
                );
            }
        });
    }
    return this;
};

// ---------------
cb.settings_choices = [
    // Max Chat Inactive Time (in min)
    {
        name: "chat_inactive_time",
        type: "int",
        label: "How many minutes within which 2 chat lines must be made to view cam?",
        defaultValue: "10",
        minValue: "1",
        required: true
    },
    // Peek Show Time (in min)
    {
        name: "peek_show_min",
        type: "int",
        label: "How many minutes to show in PEEK mode?",
        defaultValue: "10",
        minValue: "5",
        required: true
    },
    // Peek Hide Time (in min)
    {
        name: "peek_hide_min",
        type: "int",
        label: "How many minutes to hide in PEEK mode?",
        defaultValue: "20",
        minValue: "5",
        required: true
    },
    // VIP user list (comma separated)
    {
        name: "vip_list",
        type: "str",
        label: "List users who will be granted VIP automatically (separated with comma)",
        minLength: 0,
        maxLength: 2048,
        defaultValue: "",
        required: false
    },
    // Ban user list (comma separated)
    {
        name: "ban_list",
        type: "str",
        label: "List users who will be banned from viewing the cam (separated with comma)",
        minLength: 0,
        maxLength: 4096,
        defaultValue: "",
        required: false
    },
    // Ban user prefix list (comma separated)
    {
        name: "ban_prefix_list",
        type: "str",
        label: "List user prefix that will be banned from viewing the cam (separated with comma)",
        minLength: 0,
        maxLength: 2048,
        defaultValue: "",
        required: false
    },
    // Message for banned user
    {
        name: "ban_msg",
        type: "str",
        label: "What message will be displayed to banned user (blank implies no message will be sent)?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Mod user list (comma separated)
    {
        name: "mod_list",
        type: "str",
        label: "List users who will be mods (separated with comma)",
        minLength: 0,
        maxLength: 2048,
        defaultValue: "",
        required: false
    },
    // Default PF user list (comma separated)
    {
        name: "pf_list",
        type: "str",
        label: "List users who will be granted PF automatically (separated with comma)",
        minLength: 0,
        maxLength: 2048,
        defaultValue: "",
        required: false
    },
    // Welcome message line 1
    {
        name: "welcome_msg1",
        type: "str",
        label: "What is the welcome message to the viewers (1st)?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Welcome message line 2
    {
        name: "welcome_msg2",
        type: "str",
        label: "(max 5 lines)(2nd)",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Welcome message line 3
    {
        name: "welcome_msg3",
        type: "str",
        label: "(blank line will be ignored)(3rd)",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Welcome message line 4
    {
        name: "welcome_msg4",
        type: "str",
        label: "(gif code like :welcomew is supported)(4th)",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Welcome message line 5
    {
        name: "welcome_msg5",
        type: "str",
        label: "(5th)",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Notifying message cycle time
    {
        name: "notify_cycletime",
        type: "int",
        label: "What is the notifier cycle time (in min)?",
        defaultValue: "10",
        minValue: "1",
        required: true
    },
    // Notifying message 1
    {
        name: "notify_msg1",
        type: "str",
        label: "What is the 1st notifier?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Notifying message 2
    {
        name: "notify_msg2",
        type: "str",
        label: "2nd notifier?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Notifying message 3
    {
        name: "notify_msg3",
        type: "str",
        label: "3rd notifier?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Notifying message 4
    {
        name: "notify_msg4",
        type: "str",
        label: "4th notifier?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Notifying message 5
    {
        name: "notify_msg5",
        type: "str",
        label: "5th notifier?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Max Warning Inactive Time (in min)
    {
        name: "warning_inactive_time",
        type: "int",
        label: "How many minutes inactive will the user be warned?",
        defaultValue: "15",
        minValue: "1",
        required: true
    },
    // Warning Message
    {
        name: "warning_msg",
        type: "str",
        label: "What will be displayed as warning to inactive user (blank implies no warning will be sent to inactive user)?",
        minLength: 0,
        maxLength: 255,
        defaultValue: "",
        required: false
    },
    // Max Banned Inactive Time (in min)
    {
        name: "ban_inactive_time",
        type: "int",
        label: "How many minutes inactive will the user be banned?",
        defaultValue: "30",
        minValue: "1",
        required: true
    },
    // Whitelist for warning (comma separated)
    {
        name: "warning_whitelist",
        type: "str",
        label: "List users who will not be warned, i.e. whitelisted (separated with comma)",
        minLength: 0,
        maxLength: 2048,
        defaultValue: "",
        required: false
    },
    // Ban words (comma separated)
    {
        name: "ban_word_list",
        type: "str",
        label: "List ban words (separated with comma)",
        minLength: 0,
        maxLength: 2048,
        defaultValue: "",
        required: false
    },
    // Strict ban words (comma separated)
    {
        name: "strict_ban_word_list",
        type: "str",
        label: "List strict ban words (separated with comma)",
        minLength: 0,
        maxLength: 2048,
        defaultValue: "",
        required: false
    },
    // Max ban words attempts allowed
    {
        name: "max_ban_word",
        type: "int",
        label: "How many ban words attempts allowed before being banned?",
        defaultValue: "5",
        minValue: "1",
        required: true
    }
];

// On users entering the room
cb.onEnter(function (userCB) {
    myBot.onEnter(userCB);
});

// On users leaving the room
cb.onLeave(function (userCB) {
    myBot.onLeave(userCB);
});

// On users typing a message
cb.onMessage(function (msgCB) {
    myBot.onMessage(msgCB);
});
var myBot = new Bot(Bot.parseCbParam(cb.room_slug, cb.settings));