/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * This contains the implementation for the basic Internet Relay Chat (IRC)
 * protocol covered by RFCs 2810, 2811, 2812 and 2813 (which obsoletes RFC
 * 1459). RFC 2812 covers the client commands and protocol.
 *   RFC 2810: Internet Relay Chat: Architecture
 *     http://tools.ietf.org/html/rfc2810
 *   RFC 2811: Internet Relay Chat: Channel Management
 *     http://tools.ietf.org/html/rfc2811
 *   RFC 2812: Internet Relay Chat: Client Protocol
 *     http://tools.ietf.org/html/rfc2812
 *   RFC 2813: Internet Relay Chat: Server Protocol
 *     http://tools.ietf.org/html/rfc2813
 *   RFC 1459: Internet Relay Chat Protocol
 *     http://tools.ietf.org/html/rfc1459
 */
import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
import {
  l10nHelper,
  nsSimpleEnumerator,
} from "resource:///modules/imXPCOMUtils.sys.mjs";
import { clearTimeout, setTimeout } from "resource://gre/modules/Timer.sys.mjs";
import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
import {
  ctcpFormatToText,
  conversationErrorMessage,
  displayMessage,
  kListRefreshInterval,
} from "resource:///modules/ircUtils.sys.mjs";

const lazy = {};
XPCOMUtils.defineLazyGetter(lazy, "_", () =>
  l10nHelper("chrome://chat/locale/irc.properties")
);

// Display the message and remove them from the rooms they're in.
function leftRoom(aAccount, aNicks, aChannels, aSource, aReason, aKicked) {
  let msgId = "message." + (aKicked ? "kicked" : "parted");
  // If a part message was included, include it.
  let reason = aReason ? lazy._(msgId + ".reason", aReason) : "";
  function __(aNick, aYou) {
    // If the user is kicked, we need to say who kicked them.
    let msgId2 = msgId + (aYou ? ".you" : "");
    if (aKicked) {
      if (aYou) {
        return lazy._(msgId2, aSource, reason);
      }
      return lazy._(msgId2, aNick, aSource, reason);
    }
    if (aYou) {
      return lazy._(msgId2, reason);
    }
    return lazy._(msgId2, aNick, reason);
  }

  for (let channelName of aChannels) {
    if (!aAccount.conversations.has(channelName)) {
      // Handle when we closed the window.
      continue;
    }
    let conversation = aAccount.getConversation(channelName);
    for (let nick of aNicks) {
      let msg;
      if (aAccount.normalize(nick) == aAccount.normalize(aAccount._nickname)) {
        msg = __(nick, true);
        // If the user left, mark the conversation as no longer being active.
        conversation.left = true;
      } else {
        msg = __(nick);
      }

      conversation.writeMessage(aSource, msg, { system: true });
      conversation.removeParticipant(nick);
    }
  }
  return true;
}

function writeMessage(aAccount, aMessage, aString, aType) {
  let type = {};
  type[aType] = true;
  type.tags = aMessage.tags;
  aAccount
    .getConversation(aMessage.origin)
    .writeMessage(aMessage.origin, aString, type);
  return true;
}

// If aNoLastParam is true, the last parameter is not printed out.
function serverMessage(aAccount, aMsg, aNoLastParam) {
  // If we don't want to show messages from the server, just mark it as handled.
  if (!aAccount._showServerTab) {
    return true;
  }

  return writeMessage(
    aAccount,
    aMsg,
    aMsg.params.slice(1, aNoLastParam ? -1 : undefined).join(" "),
    "system"
  );
}

function serverErrorMessage(aAccount, aMessage, aError) {
  // If we don't want to show messages from the server, just mark it as handled.
  if (!aAccount._showServerTab) {
    return true;
  }

  return writeMessage(aAccount, aMessage, aError, "error");
}

function addMotd(aAccount, aMessage) {
  // If there is no current MOTD to append to, start a new one.
  if (!aAccount._motd) {
    aAccount._motd = [];
  }

  // Traditionally, MOTD messages start with "- ", but this is not always
  // true, try to handle that sanely.
  let message = aMessage.params[1];
  if (message.startsWith("-")) {
    message = message.slice(1).trim();
  }
  // And traditionally, the initial message ends in " -", remove that.
  if (message.endsWith("-")) {
    message = message.slice(0, -1).trim();
  }

  // Actually add the message (if it still exists).
  if (message) {
    aAccount._motd.push(message);
  }

  // Oh, also some servers don't send a RPL_ENDOFMOTD (e.g. irc.ppy.sh), so if
  // we don't receive another MOTD message after 1 second, consider it to be
  // RPL_ENDOFMOTD.
  clearTimeout(aAccount._motdTimer);
  aAccount._motdTimer = setTimeout(
    ircBase.commands["376"].bind(aAccount),
    1000,
    aMessage
  );

  return true;
}

// See RFCs 2811 & 2812 (which obsoletes RFC 1459) for a description of these
// commands.
export var ircBase = {
  // Parameters
  name: "RFC 2812", // Name identifier
  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
  isEnabled: () => true,

  // The IRC commands that can be handled.
  commands: {
    ERROR(aMessage) {
      // ERROR <error message>
      // Client connection has been terminated.
      if (!this.disconnecting) {
        // We received an ERROR message when we weren't expecting it, this is
        // probably the server giving us a ping timeout.
        this.WARN("Received unexpected ERROR response:\n" + aMessage.params[0]);
        this.gotDisconnected(
          Ci.prplIAccount.ERROR_NETWORK_ERROR,
          lazy._("connection.error.lost")
        );
      } else {
        // We received an ERROR message when expecting it (i.e. we've sent a
        // QUIT command). Notify account manager.
        this.gotDisconnected();
      }
      return true;
    },
    INVITE(aMessage) {
      // INVITE <nickname> <channel>
      let channel = aMessage.params[1];
      this.addChatRequest(
        channel,
        () => {
          this.joinChat(this.getChatRoomDefaultFieldValues(channel));
        },
        request => {
          // Inform the user when an invitation was automatically ignored.
          if (!request) {
            // Otherwise just notify the user.
            this.getConversation(channel).writeMessage(
              aMessage.origin,
              lazy._("message.inviteReceived", aMessage.origin, channel),
              { system: true }
            );
          }
        }
      );
      return true;
    },
    JOIN(aMessage) {
      // JOIN ( <channel> *( "," <channel> ) [ <key> *( "," <key> ) ] ) / "0"
      // Iterate over each channel.
      for (let channelName of aMessage.params[0].split(",")) {
        let conversation = this.getConversation(channelName);

        // Check whether we joined the channel or if someone else did.
        if (
          this.normalize(aMessage.origin, this.userPrefixes) ==
          this.normalize(this._nickname)
        ) {
          // If we join, clear the participants list to avoid errors with
          // repeated participants.
          conversation.removeAllParticipants();
          conversation.left = false;
          conversation.joining = false;

          // Update the channel name if it has improper capitalization.
          if (channelName != conversation.name) {
            conversation._name = channelName;
            conversation.notifyObservers(null, "update-conv-title");
          }

          // If the user parted from this room earlier, confirm the rejoin.
          if (conversation._rejoined) {
            conversation.writeMessage(
              aMessage.origin,
              lazy._("message.rejoined"),
              {
                system: true,
              }
            );
            delete conversation._rejoined;
          }

          // Ensure chatRoomFields information is available for reconnection.
          if (!conversation.chatRoomFields) {
            this.WARN(
              "Opening a MUC without storing its " +
                "prplIChatRoomFieldValues first."
            );
            conversation.chatRoomFields =
              this.getChatRoomDefaultFieldValues(channelName);
          }
        } else {
          // Don't worry about adding ourself, RPL_NAMREPLY takes care of that
          // case.
          conversation.getParticipant(aMessage.origin, true);
          let msg = lazy._("message.join", aMessage.origin, aMessage.source);
          conversation.writeMessage(aMessage.origin, msg, {
            system: true,
            noLinkification: true,
          });
        }
      }
      // If the joiner is a buddy, mark as online.
      let buddy = this.buddies.get(aMessage.origin);
      if (buddy) {
        buddy.setStatus(Ci.imIStatusInfo.STATUS_AVAILABLE, "");
      }
      return true;
    },
    KICK(aMessage) {
      // KICK <channel> *( "," <channel> ) <user> *( "," <user> ) [<comment>]
      let comment = aMessage.params.length == 3 ? aMessage.params[2] : null;
      // Some servers (moznet) send the kicker as the comment.
      if (comment == aMessage.origin) {
        comment = null;
      }
      return leftRoom(
        this,
        aMessage.params[1].split(","),
        aMessage.params[0].split(","),
        aMessage.origin,
        comment,
        true
      );
    },
    MODE(aMessage) {
      // MODE <nickname> *( ( "+" / "-") *( "i" / "w" / "o" / "O" / "r" ) )
      // MODE <channel> *( ( "-" / "+" ) *<modes> *<modeparams> )
      if (this.isMUCName(aMessage.params[0])) {
        // If the first parameter is a channel name, a channel/participant mode
        // was updated.
        this.getConversation(aMessage.params[0]).setMode(
          aMessage.params[1],
          aMessage.params.slice(2),
          aMessage.origin
        );

        return true;
      }

      // Otherwise the user's own mode is being returned to them.
      return this.setUserMode(
        aMessage.params[0],
        aMessage.params[1],
        aMessage.origin,
        !this._userModeReceived
      );
    },
    NICK(aMessage) {
      // NICK <nickname>
      this.changeBuddyNick(aMessage.origin, aMessage.params[0]);
      return true;
    },
    NOTICE(aMessage) {
      // NOTICE <msgtarget> <text>
      // If the message is from the server, don't show it unless the user wants
      // to see it.
      if (!this.connected || aMessage.origin == this._currentServerName) {
        return serverMessage(this, aMessage);
      }
      return displayMessage(this, aMessage, { notification: true });
    },
    PART(aMessage) {
      // PART <channel> *( "," <channel> ) [ <Part Message> ]
      return leftRoom(
        this,
        [aMessage.origin],
        aMessage.params[0].split(","),
        aMessage.source,
        aMessage.params.length == 2 ? aMessage.params[1] : null
      );
    },
    PING(aMessage) {
      // PING <server1> [ <server2> ]
      // Keep the connection alive.
      this.sendMessage("PONG", aMessage.params[0]);
      return true;
    },
    PONG(aMessage) {
      // PONG <server> [ <server2> ]
      let pongTime = aMessage.params[1];

      // Ping to keep the connection alive.
      if (pongTime.startsWith("_")) {
        this._socket.cancelDisconnectTimer();
        return true;
      }
      // Otherwise, the ping was from a user command.
      return this.handlePingReply(aMessage.origin, pongTime);
    },
    PRIVMSG(aMessage) {
      // PRIVMSG <msgtarget> <text to be sent>
      // Display message in conversation
      return displayMessage(this, aMessage);
    },
    QUIT(aMessage) {
      // QUIT [ < Quit Message> ]
      // Some IRC servers automatically prefix a "Quit: " string. Remove the
      // duplication and use a localized version.
      let quitMsg = aMessage.params[0] || "";
      if (quitMsg.startsWith("Quit: ")) {
        quitMsg = quitMsg.slice(6); // "Quit: ".length
      }
      // If a quit message was included, show it.
      let nick = aMessage.origin;
      let msg = lazy._(
        "message.quit",
        nick,
        quitMsg.length ? lazy._("message.quit2", quitMsg) : ""
      );
      // Loop over every conversation with the user and display that they quit.
      this.conversations.forEach(conversation => {
        if (conversation.isChat && conversation._participants.has(nick)) {
          conversation.writeMessage(nick, msg, { system: true });
          conversation.removeParticipant(nick);
        }
      });

      // Remove from the whois table.
      this.removeBuddyInfo(nick);

      // If the leaver is a buddy, mark as offline.
      let buddy = this.buddies.get(nick);
      if (buddy) {
        buddy.setStatus(Ci.imIStatusInfo.STATUS_OFFLINE, "");
      }

      // If we wanted this nickname, grab it.
      if (nick == this._requestedNickname && nick != this._nickname) {
        this.changeNick(this._requestedNickname);
        clearTimeout(this._nickInUseTimeout);
        delete this._nickInUseTimeout;
      }
      return true;
    },
    SQUIT(aMessage) {
      // <server> <comment>
      return true;
    },
    TOPIC(aMessage) {
      // TOPIC <channel> [ <topic> ]
      // Show topic as a message.
      let conversation = this.getConversation(aMessage.params[0]);
      let topic = aMessage.params[1];
      // Set the topic in the conversation and update the UI.
      conversation.setTopic(
        topic ? ctcpFormatToText(topic) : "",
        aMessage.origin
      );
      return true;
    },
    "001": function (aMessage) {
      // RPL_WELCOME
      // Welcome to the Internet Relay Network <nick>!<user>@<host>
      this._socket.resetPingTimer();
      // This seems a little strange, but we don't differentiate between a
      // nickname and the servername since it can be ambiguous.
      this._currentServerName = aMessage.origin;

      // Clear user mode.
      this._modes = new Set();
      this._userModeReceived = false;

      // Check if autoUserMode is set in the account preferences. If it is set,
      // then notify the server that the user wants a specific mode.
      if (this.prefs.prefHasUserValue("autoUserMode")) {
        this.sendMessage("MODE", [
          this._nickname,
          this.getString("autoUserMode"),
        ]);
      }

      // Check if our nick has changed.
      if (aMessage.params[0] != this._nickname) {
        this.changeBuddyNick(this._nickname, aMessage.params[0]);
      }

      // Request our own whois entry so we can set the prefix.
      this.requestCurrentWhois(this._nickname);

      // If our status is Unavailable, tell the server.
      if (
        this.imAccount.statusInfo.statusType < Ci.imIStatusInfo.STATUS_AVAILABLE
      ) {
        this.observe(null, "status-changed");
      }

      // Check if any of our buddies are online!
      const kInitialIsOnDelay = 1000;
      this._isOnTimer = setTimeout(this.sendIsOn.bind(this), kInitialIsOnDelay);

      // If we didn't handle all the CAPs we added, something is wrong.
      if (this._requestedCAPs.size) {
        this.ERROR(
          "Connected without removing CAPs: " + [...this._requestedCAPs]
        );
      }

      // Done!
      this.reportConnected();
      return serverMessage(this, aMessage);
    },
    "002": function (aMessage) {
      // RPL_YOURHOST
      // Your host is <servername>, running version <ver>
      return serverMessage(this, aMessage);
    },
    "003": function (aMessage) {
      // RPL_CREATED
      // This server was created <date>
      // TODO parse this date and keep it for some reason? Do we care?
      return serverMessage(this, aMessage);
    },
    "004": function (aMessage) {
      // RPL_MYINFO
      // <servername> <version> <available user modes> <available channel modes>
      // TODO parse the available modes, let the UI respond and inform the user
      return serverMessage(this, aMessage);
    },
    "005": function (aMessage) {
      // RPL_BOUNCE
      // Try server <server name>, port <port number>
      return serverMessage(this, aMessage);
    },

    /*
     * Handle response to TRACE message
     */
    200(aMessage) {
      // RPL_TRACELINK
      // Link <version & debug level> <destination> <next server>
      // V<protocol version> <link updateime in seconds> <backstream sendq>
      // <upstream sendq>
      return serverMessage(this, aMessage);
    },
    201(aMessage) {
      // RPL_TRACECONNECTING
      // Try. <class> <server>
      return serverMessage(this, aMessage);
    },
    202(aMessage) {
      // RPL_TRACEHANDSHAKE
      // H.S. <class> <server>
      return serverMessage(this, aMessage);
    },
    203(aMessage) {
      // RPL_TRACEUNKNOWN
      // ???? <class> [<client IP address in dot form>]
      return serverMessage(this, aMessage);
    },
    204(aMessage) {
      // RPL_TRACEOPERATOR
      // Oper <class> <nick>
      return serverMessage(this, aMessage);
    },
    205(aMessage) {
      // RPL_TRACEUSER
      // User <class> <nick>
      return serverMessage(this, aMessage);
    },
    206(aMessage) {
      // RPL_TRACESERVER
      // Serv <class> <int>S <int>C <server> <nick!user|*!*>@<host|server>
      // V<protocol version>
      return serverMessage(this, aMessage);
    },
    207(aMessage) {
      // RPL_TRACESERVICE
      // Service <class> <name> <type> <active type>
      return serverMessage(this, aMessage);
    },
    208(aMessage) {
      // RPL_TRACENEWTYPE
      // <newtype> 0 <client name>
      return serverMessage(this, aMessage);
    },
    209(aMessage) {
      // RPL_TRACECLASS
      // Class <class> <count>
      return serverMessage(this, aMessage);
    },
    210(aMessage) {
      // RPL_TRACERECONNECTION
      // Unused.
      return serverMessage(this, aMessage);
    },

    /*
     * Handle stats messages.
     **/
    211(aMessage) {
      // RPL_STATSLINKINFO
      // <linkname> <sendq> <sent messages> <sent Kbytes> <received messages>
      // <received Kbytes> <time open>
      return serverMessage(this, aMessage);
    },
    212(aMessage) {
      // RPL_STATSCOMMAND
      // <command> <count> <byte count> <remote count>
      return serverMessage(this, aMessage);
    },
    213(aMessage) {
      // RPL_STATSCLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    214(aMessage) {
      // RPL_STATSNLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    215(aMessage) {
      // RPL_STATSILINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    216(aMessage) {
      // RPL_STATSKLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    217(aMessage) {
      // RPL_STATSQLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    218(aMessage) {
      // RPL_STATSYLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    219(aMessage) {
      // RPL_ENDOFSTATS
      // <stats letter> :End of STATS report
      return serverMessage(this, aMessage);
    },

    221(aMessage) {
      // RPL_UMODEIS
      // <user mode string>
      return this.setUserMode(
        aMessage.params[0],
        aMessage.params[1],
        aMessage.origin,
        true
      );
    },

    /*
     * Services
     */
    231(aMessage) {
      // RPL_SERVICEINFO
      // Non-generic
      return serverMessage(this, aMessage);
    },
    232(aMessage) {
      // RPL_ENDOFSERVICES
      // Non-generic
      return serverMessage(this, aMessage);
    },
    233(aMessage) {
      // RPL_SERVICE
      // Non-generic
      return serverMessage(this, aMessage);
    },

    /*
     * Server
     */
    234(aMessage) {
      // RPL_SERVLIST
      // <name> <server> <mask> <type> <hopcount> <info>
      return serverMessage(this, aMessage);
    },
    235(aMessage) {
      // RPL_SERVLISTEND
      // <mask> <type> :End of service listing
      return serverMessage(this, aMessage, true);
    },

    /*
     * Stats
     * TODO some of these have real information we could try to parse.
     */
    240(aMessage) {
      // RPL_STATSVLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    241(aMessage) {
      // RPL_STATSLLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    242(aMessage) {
      // RPL_STATSUPTIME
      // :Server Up %d days %d:%02d:%02d
      return serverMessage(this, aMessage);
    },
    243(aMessage) {
      // RPL_STATSOLINE
      // O <hostmask> * <name>
      return serverMessage(this, aMessage);
    },
    244(aMessage) {
      // RPL_STATSHLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    245(aMessage) {
      // RPL_STATSSLINE
      // Non-generic
      // Note that this is given as 244 in RFC 2812, this seems to be incorrect.
      return serverMessage(this, aMessage);
    },
    246(aMessage) {
      // RPL_STATSPING
      // Non-generic
      return serverMessage(this, aMessage);
    },
    247(aMessage) {
      // RPL_STATSBLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },
    250(aMessage) {
      // RPL_STATSDLINE
      // Non-generic
      return serverMessage(this, aMessage);
    },

    /*
     * LUSER messages
     */
    251(aMessage) {
      // RPL_LUSERCLIENT
      // :There are <integer> users and <integer> services on <integer> servers
      return serverMessage(this, aMessage);
    },
    252(aMessage) {
      // RPL_LUSEROP, 0 if not sent
      // <integer> :operator(s) online
      return serverMessage(this, aMessage);
    },
    253(aMessage) {
      // RPL_LUSERUNKNOWN, 0 if not sent
      // <integer> :unknown connection(s)
      return serverMessage(this, aMessage);
    },
    254(aMessage) {
      // RPL_LUSERCHANNELS, 0 if not sent
      // <integer> :channels formed
      return serverMessage(this, aMessage);
    },
    255(aMessage) {
      // RPL_LUSERME
      // :I have <integer> clients and <integer> servers
      return serverMessage(this, aMessage);
    },

    /*
     * ADMIN messages
     */
    256(aMessage) {
      // RPL_ADMINME
      // <server> :Administrative info
      return serverMessage(this, aMessage);
    },
    257(aMessage) {
      // RPL_ADMINLOC1
      // :<admin info>
      // City, state & country
      return serverMessage(this, aMessage);
    },
    258(aMessage) {
      // RPL_ADMINLOC2
      // :<admin info>
      // Institution details
      return serverMessage(this, aMessage);
    },
    259(aMessage) {
      // RPL_ADMINEMAIL
      // :<admin info>
      // TODO We could parse this for a contact email.
      return serverMessage(this, aMessage);
    },

    /*
     * TRACELOG
     */
    261(aMessage) {
      // RPL_TRACELOG
      // File <logfile> <debug level>
      return serverMessage(this, aMessage);
    },
    262(aMessage) {
      // RPL_TRACEEND
      // <server name> <version & debug level> :End of TRACE
      return serverMessage(this, aMessage, true);
    },

    /*
     * Try again.
     */
    263(aMessage) {
      // RPL_TRYAGAIN
      // <command> :Please wait a while and try again.
      if (aMessage.params[1] == "LIST" && this._pendingList) {
        // We may receive this from servers which rate-limit LIST if the
        // server believes us to be asking for LIST data too soon after the
        // previous request.
        // Tidy up as we won't be receiving any more channels.
        this._sendRemainingRoomInfo();
        // Fake the last LIST time so that we may try again in one hour.
        const kHour = 60 * 60 * 1000;
        this._lastListTime = Date.now() - kListRefreshInterval + kHour;
        return true;
      }
      return serverMessage(this, aMessage);
    },

    265(aMessage) {
      // nonstandard
      // :Current Local Users: <integer>  Max: <integer>
      return serverMessage(this, aMessage);
    },
    266(aMessage) {
      // nonstandard
      // :Current Global Users: <integer>  Max: <integer>
      return serverMessage(this, aMessage);
    },
    300(aMessage) {
      // RPL_NONE
      // Non-generic
      return serverMessage(this, aMessage);
    },

    /*
     * Status messages
     */
    301(aMessage) {
      // RPL_AWAY
      // <nick> :<away message>
      // TODO set user as away on buddy list / conversation lists
      // TODO Display an autoResponse if this is after sending a private message
      // If the conversation is waiting for a response, it's received one.
      if (this.conversations.has(aMessage.params[1])) {
        delete this.getConversation(aMessage.params[1])._pendingMessage;
      }
      return this.setWhois(aMessage.params[1], { away: aMessage.params[2] });
    },
    302(aMessage) {
      // RPL_USERHOST
      // :*1<reply> *( " " <reply )"
      // reply = nickname [ "*" ] "=" ( "+" / "-" ) hostname
      // TODO Can tell op / away from this
      return false;
    },
    303(aMessage) {
      // RPL_ISON
      // :*1<nick> *( " " <nick> )"
      // Set the status of the buddies based the latest ISON response.
      let receivedBuddyNames = [];
      // The buddy names as returned by the server.
      if (aMessage.params.length > 1) {
        receivedBuddyNames = aMessage.params[1].trim().split(" ");
      }

      // This was received in response to the last ISON message sent.
      for (let buddyName of this.pendingIsOnQueue) {
        // If the buddy name is in the list returned from the server, they're
        // online.
        let status = !receivedBuddyNames.includes(buddyName)
          ? Ci.imIStatusInfo.STATUS_OFFLINE
          : Ci.imIStatusInfo.STATUS_AVAILABLE;

        // Set the status with no status message, only if the buddy actually
        // exists in the buddy list.
        let buddy = this.buddies.get(buddyName);
        if (buddy) {
          buddy.setStatus(status, "");
        }
      }
      return true;
    },
    305(aMessage) {
      // RPL_UNAWAY
      // :You are no longer marked as being away
      this.isAway = false;
      return true;
    },
    306(aMessage) {
      // RPL_NOWAWAY
      // :You have been marked as away
      this.isAway = true;
      return true;
    },

    /*
     * WHOIS
     */
    311(aMessage) {
      // RPL_WHOISUSER
      // <nick> <user> <host> * :<real name>
      // <username>@<hostname>
      let nick = aMessage.params[1];
      let source = aMessage.params[2] + "@" + aMessage.params[3];
      // Some servers obfuscate the host when sending messages. Therefore,
      // we set the account prefix by using the host from this response.
      // We store it separately to avoid glitches due to the whois entry
      // being temporarily deleted during future updates of the entry.
      if (this.normalize(nick) == this.normalize(this._nickname)) {
        this.prefix = "!" + source;
      }
      return this.setWhois(nick, {
        realname: aMessage.params[5],
        connectedFrom: source,
      });
    },
    312(aMessage) {
      // RPL_WHOISSERVER
      // <nick> <server> :<server info>
      return this.setWhois(aMessage.params[1], {
        serverName: aMessage.params[2],
        serverInfo: aMessage.params[3],
      });
    },
    313(aMessage) {
      // RPL_WHOISOPERATOR
      // <nick> :is an IRC operator
      return this.setWhois(aMessage.params[1], { ircOp: true });
    },
    314(aMessage) {
      // RPL_WHOWASUSER
      // <nick> <user> <host> * :<real name>
      let source = aMessage.params[2] + "@" + aMessage.params[3];
      return this.setWhois(aMessage.params[1], {
        offline: true,
        realname: aMessage.params[5],
        connectedFrom: source,
      });
    },
    315(aMessage) {
      // RPL_ENDOFWHO
      // <name> :End of WHO list
      return false;
    },
    316(aMessage) {
      // RPL_WHOISCHANOP
      // Non-generic
      return false;
    },
    317(aMessage) {
      // RPL_WHOISIDLE
      // <nick> <integer> :seconds idle
      return this.setWhois(aMessage.params[1], {
        lastActivity: parseInt(aMessage.params[2]),
      });
    },
    318(aMessage) {
      // RPL_ENDOFWHOIS
      // <nick> :End of WHOIS list
      // We've received everything about WHOIS, tell the tooltip that is waiting
      // for this information.
      let nick = aMessage.params[1];

      if (this.whoisInformation.has(nick)) {
        this.notifyWhois(nick);
      } else {
        // If there is no whois information stored at this point, the nick
        // is either offline or does not exist, so we run WHOWAS.
        this.requestOfflineBuddyInfo(nick);
      }
      return true;
    },
    319(aMessage) {
      // RPL_WHOISCHANNELS
      // <nick> :*( ( "@" / "+" ) <channel> " " )
      return this.setWhois(aMessage.params[1], {
        channels: aMessage.params[2],
      });
    },

    /*
     * LIST
     */
    321(aMessage) {
      // RPL_LISTSTART
      // Channel :Users Name
      // Obsolete. Not used.
      return true;
    },
    322(aMessage) {
      // RPL_LIST
      // <channel> <# visible> :<topic>
      let name = aMessage.params[1];
      let participantCount = aMessage.params[2];
      let topic = aMessage.params[3];
      // Some servers (e.g. Unreal) include the channel's modes before the topic.
      // Omit this.
      topic = topic.replace(/^\[\+[a-zA-Z]*\] /, "");
      // Force the allocation of a new copy of the string so as to prevent
      // the JS engine from retaining the whole original socket string. See bug
      // 1058584. This hack can be removed when bug 1058653 is fixed.
      topic = topic ? topic.normalize() : "";

      this._channelList.set(name, { topic, participantCount });
      this._currentBatch.push(name);
      // Give callbacks a batch of channels of length _channelsPerBatch.
      if (this._currentBatch.length == this._channelsPerBatch) {
        for (let callback of this._roomInfoCallbacks) {
          callback.onRoomInfoAvailable(this._currentBatch, false);
        }
        this._currentBatch = [];
      }
      return true;
    },
    323(aMessage) {
      // RPL_LISTEND
      // :End of LIST
      this._sendRemainingRoomInfo();
      return true;
    },

    /*
     * Channel functions
     */
    324(aMessage) {
      // RPL_CHANNELMODEIS
      // <channel> <mode> <mode params>
      this.getConversation(aMessage.params[1]).setMode(
        aMessage.params[2],
        aMessage.params.slice(3),
        aMessage.origin
      );

      return true;
    },
    325(aMessage) {
      // RPL_UNIQOPIS
      // <channel> <nickname>
      // TODO parse this and have the UI respond accordingly.
      return false;
    },
    331(aMessage) {
      // RPL_NOTOPIC
      // <channel> :No topic is set
      let conversation = this.getConversation(aMessage.params[1]);
      // Clear the topic.
      conversation.setTopic("");
      return true;
    },
    332(aMessage) {
      // RPL_TOPIC
      // <channel> :<topic>
      // Update the topic UI
      let conversation = this.getConversation(aMessage.params[1]);
      let topic = aMessage.params[2];
      conversation.setTopic(topic ? ctcpFormatToText(topic) : "");
      return true;
    },
    333(aMessage) {
      // nonstandard
      // <channel> <nickname> <time>
      return true;
    },

    /*
     * Invitations
     */
    341(aMessage) {
      // RPL_INVITING
      // <channel> <nick>
      // Note that servers reply with parameters in the reverse order from the
      // above (which is as specified by RFC 2812).
      this.getConversation(aMessage.params[2]).writeMessage(
        aMessage.origin,
        lazy._("message.invited", aMessage.params[1], aMessage.params[2]),
        { system: true }
      );
      return true;
    },
    342(aMessage) {
      // RPL_SUMMONING
      // <user> :Summoning user to IRC
      return writeMessage(
        this,
        aMessage,
        lazy._("message.summoned", aMessage.params[0])
      );
    },
    346(aMessage) {
      // RPL_INVITELIST
      // <channel> <invitemask>
      // TODO what do we do?
      return false;
    },
    347(aMessage) {
      // RPL_ENDOFINVITELIST
      // <channel> :End of channel invite list
      // TODO what do we do?
      return false;
    },
    348(aMessage) {
      // RPL_EXCEPTLIST
      // <channel> <exceptionmask>
      // TODO what do we do?
      return false;
    },
    349(aMessage) {
      // RPL_ENDOFEXCEPTIONLIST
      // <channel> :End of channel exception list
      // TODO update UI?
      return false;
    },

    /*
     * Version
     */
    351(aMessage) {
      // RPL_VERSION
      // <version>.<debuglevel> <server> :<comments>
      return serverMessage(this, aMessage);
    },

    /*
     * WHO
     */
    352(aMessage) {
      // RPL_WHOREPLY
      // <channel> <user> <host> <server> <nick> ( "H" / "G" ) ["*"] [ ("@" / "+" ) ] :<hopcount> <real name>
      // TODO parse and display this?
      return false;
    },

    /*
     * NAMREPLY
     */
    353(aMessage) {
      // RPL_NAMREPLY
      // <target> ( "=" / "*" / "@" ) <channel> :[ "@" / "+" ] <nick> *( " " [ "@" / "+" ] <nick> )
      let conversation = this.getConversation(aMessage.params[2]);
      // Keep if this is secret (@), private (*) or public (=).
      conversation.setModesFromRestriction(aMessage.params[1]);
      // Add the participants.
      let newParticipants = [];
      aMessage.params[3]
        .trim()
        .split(" ")
        .forEach(aNick =>
          newParticipants.push(conversation.getParticipant(aNick, false))
        );
      conversation.notifyObservers(
        new nsSimpleEnumerator(newParticipants),
        "chat-buddy-add"
      );
      return true;
    },

    361(aMessage) {
      // RPL_KILLDONE
      // Non-generic
      // TODO What is this?
      return false;
    },
    362(aMessage) {
      // RPL_CLOSING
      // Non-generic
      // TODO What is this?
      return false;
    },
    363(aMessage) {
      // RPL_CLOSEEND
      // Non-generic
      // TODO What is this?
      return false;
    },

    /*
     * Links.
     */
    364(aMessage) {
      // RPL_LINKS
      // <mask> <server> :<hopcount> <server info>
      return serverMessage(this, aMessage);
    },
    365(aMessage) {
      // RPL_ENDOFLINKS
      // <mask> :End of LINKS list
      return true;
    },

    /*
     * Names
     */
    366(aMessage) {
      // RPL_ENDOFNAMES
      // <target> <channel> :End of NAMES list
      // All participants have already been added by the 353 handler.

      // This assumes that this is the last message received when joining a
      // channel, so a few "clean up" tasks are done here.
      let conversation = this.getConversation(aMessage.params[1]);

      // Update the topic as we may have added the participant for
      // the user after the mode message was handled, and so
      // topicSettable may have changed.
      conversation.notifyObservers(this, "chat-update-topic");

      // If we haven't received the MODE yet, request it.
      if (!conversation._receivedInitialMode) {
        this.sendMessage("MODE", aMessage.params[1]);
      }

      return true;
    },
    /*
     * End of a bunch of lists
     */
    367(aMessage) {
      // RPL_BANLIST
      // <channel> <banmask>
      let conv = this.getConversation(aMessage.params[1]);
      if (!conv.banMasks.includes(aMessage.params[2])) {
        conv.banMasks.push(aMessage.params[2]);
      }
      return true;
    },
    368(aMessage) {
      // RPL_ENDOFBANLIST
      // <channel> :End of channel ban list
      let conv = this.getConversation(aMessage.params[1]);
      let msg;
      if (conv.banMasks.length) {
        msg = [lazy._("message.banMasks", aMessage.params[1])]
          .concat(conv.banMasks)
          .join("\n");
      } else {
        msg = lazy._("message.noBanMasks", aMessage.params[1]);
      }
      conv.writeMessage(aMessage.origin, msg, { system: true });
      return true;
    },
    369(aMessage) {
      // RPL_ENDOFWHOWAS
      // <nick> :End of WHOWAS
      // We've received everything about WHOWAS, tell the tooltip that is waiting
      // for this information.
      this.notifyWhois(aMessage.params[1]);
      return true;
    },

    /*
     * Server info
     */
    371(aMessage) {
      // RPL_INFO
      // :<string>
      return serverMessage(this, aMessage);
    },
    372(aMessage) {
      // RPL_MOTD
      // :- <text>
      return addMotd(this, aMessage);
    },
    373(aMessage) {
      // RPL_INFOSTART
      // Non-generic
      // This is unnecessary and servers just send RPL_INFO.
      return true;
    },
    374(aMessage) {
      // RPL_ENDOFINFO
      // :End of INFO list
      return true;
    },
    375(aMessage) {
      // RPL_MOTDSTART
      // :- <server> Message of the day -
      return addMotd(this, aMessage);
    },
    376(aMessage) {
      // RPL_ENDOFMOTD
      // :End of MOTD command
      // Show the MOTD if the user wants to see server messages or if
      // RPL_WELCOME has not been received since some servers (e.g. irc.ppy.sh)
      // use this as a CAPTCHA like mechanism before login can occur.
      if (this._showServerTab || !this.connected) {
        writeMessage(this, aMessage, this._motd.join("\n"), "incoming");
      }
      // No reason to keep the MOTD in memory.
      delete this._motd;
      // Clear the MOTD timer.
      clearTimeout(this._motdTimer);
      delete this._motdTimer;

      return true;
    },

    /*
     * OPER
     */
    381(aMessage) {
      // RPL_YOUREOPER
      // :You are now an IRC operator
      // TODO update UI accordingly to show oper status
      return serverMessage(this, aMessage);
    },
    382(aMessage) {
      // RPL_REHASHING
      // <config file> :Rehashing
      return serverMessage(this, aMessage);
    },
    383(aMessage) {
      // RPL_YOURESERVICE
      // You are service <servicename>
      this.WARN('Received "You are a service" message.');
      return true;
    },

    /*
     * Info
     */
    384(aMessage) {
      // RPL_MYPORTIS
      // Non-generic
      // TODO Parse and display?
      return false;
    },
    391(aMessage) {
      // RPL_TIME
      // <server> :<string showing server's local time>

      let msg = lazy._("ctcp.time", aMessage.params[1], aMessage.params[2]);
      // Show the date returned from the server, note that this doesn't use
      // the serverMessage function: since this is in response to a command, it
      // should always be shown.
      return writeMessage(this, aMessage, msg, "system");
    },
    392(aMessage) {
      // RPL_USERSSTART
      // :UserID   Terminal  Host
      // TODO
      return false;
    },
    393(aMessage) {
      // RPL_USERS
      // :<username> <ttyline> <hostname>
      // TODO store into buddy list? List out?
      return false;
    },
    394(aMessage) {
      // RPL_ENDOFUSERS
      // :End of users
      // TODO Notify observers of the buddy list?
      return false;
    },
    395(aMessage) {
      // RPL_NOUSERS
      // :Nobody logged in
      // TODO clear buddy list?
      return false;
    },

    // Error messages, Implement Section 5.2 of RFC 2812
    401(aMessage) {
      // ERR_NOSUCHNICK
      // <nickname> :No such nick/channel
      // Can arise in response to /mode, /invite, /kill, /msg, /whois.
      // TODO Handled in the conversation for /whois and /mgs so far.
      let msgId =
        "error.noSuch" +
        (this.isMUCName(aMessage.params[1]) ? "Channel" : "Nick");
      if (this.conversations.has(aMessage.params[1])) {
        // If the conversation exists and we just sent a message from it, then
        // notify that the user is offline.
        if (this.getConversation(aMessage.params[1])._pendingMessage) {
          conversationErrorMessage(this, aMessage, msgId);
        }
      }

      return serverErrorMessage(
        this,
        aMessage,
        lazy._(msgId, aMessage.params[1])
      );
    },
    402(aMessage) {
      // ERR_NOSUCHSERVER
      // <server name> :No such server
      // TODO Parse & display an error to the user.
      return false;
    },
    403(aMessage) {
      // ERR_NOSUCHCHANNEL
      // <channel name> :No such channel
      return conversationErrorMessage(
        this,
        aMessage,
        "error.noChannel",
        true,
        false
      );
    },
    404(aMessage) {
      // ERR_CANNOTSENDTOCHAN
      // <channel name> :Cannot send to channel
      // Notify the user that they can't send to that channel.
      return conversationErrorMessage(
        this,
        aMessage,
        "error.cannotSendToChannel"
      );
    },
    405(aMessage) {
      // ERR_TOOMANYCHANNELS
      // <channel name> :You have joined too many channels
      return conversationErrorMessage(
        this,
        aMessage,
        "error.tooManyChannels",
        true
      );
    },
    406(aMessage) {
      // ERR_WASNOSUCHNICK
      // <nickname> :There was no such nickname
      // Can arise in response to WHOWAS.
      return serverErrorMessage(
        this,
        aMessage,
        lazy._("error.wasNoSuchNick", aMessage.params[1])
      );
    },
    407(aMessage) {
      // ERR_TOOMANYTARGETS
      // <target> :<error code> recipients. <abort message>
      return conversationErrorMessage(
        this,
        aMessage,
        "error.nonUniqueTarget",
        false,
        false
      );
    },
    408(aMessage) {
      // ERR_NOSUCHSERVICE
      // <service name> :No such service
      // TODO
      return false;
    },
    409(aMessage) {
      // ERR_NOORIGIN
      // :No origin specified
      // TODO failed PING/PONG message, this should never occur?
      return false;
    },
    411(aMessage) {
      // ERR_NORECIPIENT
      // :No recipient given (<command>)
      // If this happens a real error with the protocol occurred.
      this.ERROR("ERR_NORECIPIENT: No recipient given for PRIVMSG.");
      return true;
    },
    412(aMessage) {
      // ERR_NOTEXTTOSEND
      // :No text to send
      // If this happens a real error with the protocol occurred: we should
      // always block the user from sending empty messages.
      this.ERROR("ERR_NOTEXTTOSEND: No text to send for PRIVMSG.");
      return true;
    },
    413(aMessage) {
      // ERR_NOTOPLEVEL
      // <mask> :No toplevel domain specified
      // If this response is received, a real error occurred in the protocol.
      this.ERROR("ERR_NOTOPLEVEL: Toplevel domain not specified.");
      return true;
    },
    414(aMessage) {
      // ERR_WILDTOPLEVEL
      // <mask> :Wildcard in toplevel domain
      // If this response is received, a real error occurred in the protocol.
      this.ERROR("ERR_WILDTOPLEVEL: Wildcard toplevel domain specified.");
      return true;
    },
    415(aMessage) {
      // ERR_BADMASK
      // <mask> :Bad Server/host mask
      // If this response is received, a real error occurred in the protocol.
      this.ERROR("ERR_BADMASK: Bad server/host mask specified.");
      return true;
    },
    421(aMessage) {
      // ERR_UNKNOWNCOMMAND
      // <command> :Unknown command
      // TODO This shouldn't occur.
      return false;
    },
    422(aMessage) {
      // ERR_NOMOTD
      // :MOTD File is missing
      // No message of the day to display.
      return true;
    },
    423(aMessage) {
      // ERR_NOADMININFO
      // <server> :No administrative info available
      // TODO
      return false;
    },
    424(aMessage) {
      // ERR_FILEERROR
      // :File error doing <file op> on <file>
      // TODO
      return false;
    },
    431(aMessage) {
      // ERR_NONICKNAMEGIVEN
      // :No nickname given
      // TODO
      return false;
    },
    432(aMessage) {
      // ERR_ERRONEUSNICKNAME
      // <nick> :Erroneous nickname
      let msg = lazy._("error.erroneousNickname", this._requestedNickname);
      serverErrorMessage(this, aMessage, msg);
      if (this._requestedNickname == this._accountNickname) {
        // The account has been set up with an illegal nickname.
        this.ERROR(
          "Erroneous nickname " +
            this._requestedNickname +
            ": " +
            aMessage.params.slice(1).join(" ")
        );
        this.gotDisconnected(Ci.prplIAccount.ERROR_INVALID_USERNAME, msg);
      } else {
        // Reset original nickname to the account nickname in case of
        // later reconnections.
        this._requestedNickname = this._accountNickname;
      }
      return true;
    },
    433(aMessage) {
      // ERR_NICKNAMEINUSE
      // <nick> :Nickname is already in use
      // Try to get the desired nick back in 2.5 minutes if this happens when
      // connecting, in case it was just due to the user's nick not having
      // timed out yet on the server.
      if (this.connecting && aMessage.params[1] == this._requestedNickname) {
        this._nickInUseTimeout = setTimeout(() => {
          this.changeNick(this._requestedNickname);
          delete this._nickInUseTimeout;
        }, 150000);
      }
      return this.tryNewNick(aMessage.params[1]);
    },
    436(aMessage) {
      // ERR_NICKCOLLISION
      // <nick> :Nickname collision KILL from <user>@<host>
      return this.tryNewNick(aMessage.params[1]);
    },
    437(aMessage) {
      // ERR_UNAVAILRESOURCE
      // <nick/channel> :Nick/channel is temporarily unavailable
      return conversationErrorMessage(
        this,
        aMessage,
        "error.unavailable",
        true
      );
    },
    441(aMessage) {
      // ERR_USERNOTINCHANNEL
      // <nick> <channel> :They aren't on that channel
      // TODO
      return false;
    },
    442(aMessage) {
      // ERR_NOTONCHANNEL
      // <channel> :You're not on that channel
      this.ERROR(
        "A command affecting " +
          aMessage.params[1] +
          " failed because you aren't in that channel."
      );
      return true;
    },
    443(aMessage) {
      // ERR_USERONCHANNEL
      // <user> <channel> :is already on channel
      this.getConversation(aMessage.params[2]).writeMessage(
        aMessage.origin,
        lazy._(
          "message.alreadyInChannel",
          aMessage.params[1],
          aMessage.params[2]
        ),
        { system: true }
      );
      return true;
    },
    444(aMessage) {
      // ERR_NOLOGIN
      // <user> :User not logged in
      // TODO
      return false;
    },
    445(aMessage) {
      // ERR_SUMMONDISABLED
      // :SUMMON has been disabled
      // TODO keep track of this and disable UI associated?
      return false;
    },
    446(aMessage) {
      // ERR_USERSDISABLED
      // :USERS has been disabled
      // TODO Disabled all buddy list etc.
      return false;
    },
    451(aMessage) {
      // ERR_NOTREGISTERED
      // :You have not registered
      // If the server doesn't understand CAP it might return this error.
      if (aMessage.params[0] == "CAP") {
        this.LOG("Server doesn't support CAP.");
        return true;
      }
      // TODO
      return false;
    },
    461(aMessage) {
      // ERR_NEEDMOREPARAMS
      // <command> :Not enough parameters

      if (!this.connected) {
        // The account has been set up with an illegal username.
        this.ERROR("Erroneous username: " + this.username);
        this.gotDisconnected(
          Ci.prplIAccount.ERROR_INVALID_USERNAME,
          lazy._("connection.error.invalidUsername", this.user)
        );
        return true;
      }

      return false;
    },
    462(aMessage) {
      // ERR_ALREADYREGISTERED
      // :Unauthorized command (already registered)
      // TODO
      return false;
    },
    463(aMessage) {
      // ERR_NOPERMFORHOST
      // :Your host isn't among the privileged
      // TODO
      return false;
    },
    464(aMessage) {
      // ERR_PASSWDMISMATCH
      // :Password incorrect
      this.gotDisconnected(
        Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED,
        lazy._("connection.error.invalidPassword")
      );
      return true;
    },
    465(aMessage) {
      // ERR_YOUREBANEDCREEP
      // :You are banned from this server
      serverErrorMessage(this, aMessage, lazy._("error.banned"));
      this.gotDisconnected(
        Ci.prplIAccount.ERROR_OTHER_ERROR,
        lazy._("error.banned")
      ); // Notify account manager.
      return true;
    },
    466(aMessage) {
      // ERR_YOUWILLBEBANNED
      return serverErrorMessage(this, aMessage, lazy._("error.bannedSoon"));
    },
    467(aMessage) {
      // ERR_KEYSET
      // <channel> :Channel key already set
      // TODO
      return false;
    },
    471(aMessage) {
      // ERR_CHANNELISFULL
      // <channel> :Cannot join channel (+l)
      return conversationErrorMessage(
        this,
        aMessage,
        "error.channelFull",
        true
      );
    },
    472(aMessage) {
      // ERR_UNKNOWNMODE
      // <char> :is unknown mode char to me for <channel>
      // TODO
      return false;
    },
    473(aMessage) {
      // ERR_INVITEONLYCHAN
      // <channel> :Cannot join channel (+i)
      return conversationErrorMessage(
        this,
        aMessage,
        "error.inviteOnly",
        true,
        false
      );
    },
    474(aMessage) {
      // ERR_BANNEDFROMCHAN
      // <channel> :Cannot join channel (+b)
      return conversationErrorMessage(
        this,
        aMessage,
        "error.channelBanned",
        true,
        false
      );
    },
    475(aMessage) {
      // ERR_BADCHANNELKEY
      // <channel> :Cannot join channel (+k)
      return conversationErrorMessage(
        this,
        aMessage,
        "error.wrongKey",
        true,
        false
      );
    },
    476(aMessage) {
      // ERR_BADCHANMASK
      // <channel> :Bad Channel Mask
      // TODO
      return false;
    },
    477(aMessage) {
      // ERR_NOCHANMODES
      // <channel> :Channel doesn't support modes
      // TODO
      return false;
    },
    478(aMessage) {
      // ERR_BANLISTFULL
      // <channel> <char> :Channel list is full
      // TODO
      return false;
    },
    481(aMessage) {
      // ERR_NOPRIVILEGES
      // :Permission Denied- You're not an IRC operator
      // TODO ask to auth?
      return false;
    },
    482(aMessage) {
      // ERR_CHANOPRIVSNEEDED
      // <channel> :You're not channel operator
      return conversationErrorMessage(this, aMessage, "error.notChannelOp");
    },
    483(aMessage) {
      // ERR_CANTKILLSERVER
      // :You can't kill a server!
      // TODO Display error?
      return false;
    },
    484(aMessage) {
      // ERR_RESTRICTED
      // :Your connection is restricted!
      // Indicates user mode +r
      // TODO
      return false;
    },
    485(aMessage) {
      // ERR_UNIQOPPRIVSNEEDED
      // :You're not the original channel operator
      // TODO ask to auth?
      return false;
    },
    491(aMessage) {
      // ERR_NOOPERHOST
      // :No O-lines for your host
      // TODO
      return false;
    },
    492(aMessage) {
      // ERR_NOSERVICEHOST
      // Non-generic
      // TODO
      return false;
    },
    501(aMessage) {
      // ERR_UMODEUNKNOWNFLAGS
      // :Unknown MODE flag
      return serverErrorMessage(
        this,
        aMessage,
        lazy._("error.unknownMode", aMessage.params[1])
      );
    },
    502(aMessage) {
      // ERR_USERSDONTMATCH
      // :Cannot change mode for other users
      return serverErrorMessage(this, aMessage, lazy._("error.mode.wrongUser"));
    },
  },
};