simple-irc-server 0.1.6

// reply.rs - replies
//
// simple-irc-server - simple IRC server
// Copyright (C) 2022  Mateusz Szpakowski
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

// replies

use std::fmt;

#[derive(Clone)]
pub(crate) struct WhoIsChannelStruct<'a> {
    pub(crate) prefix: Option<String>,
    pub(crate) channel: &'a str,
}

#[derive(Clone)]
pub(crate) struct NameReplyStruct<'a> {
    pub(crate) prefix: String,
    pub(crate) nick: &'a str,
}

// all replies used by this IRC server.
pub(crate) enum Reply<'a> {
    RplWelcome001{ client: &'a str, networkname: &'a str, nick: &'a str,
            user: &'a str, host: &'a str },
    RplYourHost002{ client: &'a str, servername: &'a str, version: &'a str },
    RplCreated003{ client: &'a str, datetime: &'a str },
    RplMyInfo004{ client: &'a str, servername: &'a str, version: &'a str,
            avail_user_modes: &'a str, avail_chmodes: &'a str,
            avail_chmodes_with_params: Option<&'a str> },
    RplISupport005{ client: &'a str, tokens: &'a str },
    RplStatsCommands212{ client: &'a str, command: &'a str, count: u64 },
    RplEndOfStats219{ client: &'a str, stat: char },
    RplUModeIs221{ client: &'a str, user_modes: &'a str },
    RplStatsUptime242{ client: &'a str, seconds: u64 },
    RplLUserClient251{ client: &'a str, users_num: usize, inv_users_num: usize,
            servers_num: usize },
    RplLUserOp252{ client: &'a str, ops_num: usize },
    RplLUserUnknown253{ client: &'a str, conns_num: usize },
    RplLUserChannels254{ client: &'a str, channels_num: usize },
    RplLUserMe255{ client: &'a str, clients_num: usize, servers_num: usize },
    RplAdminMe256{ client: &'a str, server: &'a str },
    RplAdminLoc1257{ client: &'a str, info: &'a str },
    RplAdminLoc2258{ client: &'a str, info: &'a str },
    RplAdminEmail259{ client: &'a str, email: &'a str },
    RplLocalUsers265{ client: &'a str, clients_num: usize, max_clients_num: usize },
    RplGlobalUsers266{ client: &'a str, clients_num: usize, max_clients_num: usize },
    //RplWhoIsCertFP276{ client: &'a str, nick: &'a str, fingerprint: &'a str },
    RplAway301{ client: &'a str, nick: &'a str, message: &'a str },
    RplUserHost302{ client: &'a str, replies: &'a [String] },
    RplIson303{ client: &'a str, nicknames: &'a [&'a str] },
    RplUnAway305{ client: &'a str },
    RplNowAway306{ client: &'a str },
    RplWhoReply352{ client: &'a str, channel: &'a str, username: &'a str, host: &'a str,
            server: &'a str, nick: &'a str, flags: &'a str,
            hopcount: usize, realname: &'a str },
    RplEndOfWho315{ client: &'a str, mask: &'a str },
    RplWhoIsRegNick307{ client: &'a str, nick: &'a str },
    RplWhoIsUser311{ client: &'a str, nick: &'a str, username: &'a str, host: &'a str,
            realname: &'a str },
    RplWhoIsServer312{ client: &'a str, nick: &'a str, server: &'a str,
            server_info: &'a str },
    RplWhoIsOperator313{ client: &'a str, nick: &'a str },
    RplWhoWasUser314{ client: &'a str, nick: &'a str, username: &'a str, host: &'a str,
            realname: &'a str },
    RplwhoIsIdle317{ client: &'a str, nick: &'a str, secs: u64, signon: u64 },
    RplEndOfWhoIs318{ client: &'a str, nick: &'a str },
    RplWhoIsChannels319{ client: &'a str, nick: &'a str,
            channels: &'a [WhoIsChannelStruct<'a>] },
    RplListStart321{ client: &'a str },
    RplList322{ client: &'a str, channel: &'a str, client_count: usize, topic: &'a str },
    RplListEnd323{ client: &'a str },
    RplChannelModeIs324{ client: &'a str, channel: &'a str, modestring: &'a str },
    RplCreationTime329{ client: &'a str, channel: &'a str, creation_time: u64 },
    RplNoTopic331{ client: &'a str, channel: &'a str },
    RplTopic332{ client: &'a str, channel: &'a str, topic: &'a str },
    RplTopicWhoTime333{ client: &'a str, channel: &'a str, nick: &'a str, setat: u64 },
    RplInviting341{ client: &'a str, nick: &'a str, channel: &'a str },
    RplInviteList346{ client: &'a str, channel: &'a str, mask: &'a str },
    RplEndOfInviteList347{ client: &'a str, channel: &'a str },
    RplExceptList348{ client: &'a str, channel: &'a str, mask: &'a str },
    RplEndOfExceptList349{ client: &'a str, channel: &'a str },
    RplVersion351{ client: &'a str, version: &'a str, server: &'a str,
            comments: &'a str },
    RplNameReply353{ client: &'a str, symbol: &'a str, channel: &'a str,
            replies: &'a[NameReplyStruct<'a>] },
    RplEndOfNames366{ client: &'a str, channel: &'a str },
    RplLinks364{ client: &'a str, mask: &'a str, server: &'a str, hop_count: u64,
                server_info: &'a str },
    RplEndOfLinks365{ client: &'a str, mask: &'a str },
    RplBanList367{ client: &'a str, channel: &'a str, mask: &'a str,
            who: &'a str, set_ts: u64 },
    RplEndOfBanList368{ client: &'a str, channel: &'a str },
    RplEndOfWhoWas369{ client: &'a str, nick: &'a str },
    RplInfo371{ client: &'a str, info: &'a str },
    RplEndOfInfo374{ client: &'a str },
    RplMotdStart375{ client: &'a str, server: &'a str },
    RplMotd372{ client: &'a str, motd: &'a str },
    RplEndOfMotd376{ client: &'a str },
    RplWhoIsHost378{ client: &'a str, nick: &'a str, host_info: &'a str },
    RplWhoIsModes379{ client: &'a str, nick: &'a str, modes: &'a str },
    RplYoureOper381{ client: &'a str },
    //RplRehashing382{ client: &'a str, config_file: &'a str },
    RplTime391{ client: &'a str, server: &'a str, timestamp: u64, ts_offset: &'a str,
            human_readable: &'a str },
    ErrUnknownError400{ client: &'a str, command: &'a str, subcommand: Option<&'a str>,
            info: &'a str },
    ErrNoSuchNick401{ client: &'a str, nick: &'a str },
    //ErrNoSuchServer402{ client: &'a str, server: &'a str },
    ErrNoSuchChannel403{ client: &'a str, channel: &'a str },
    ErrCannotSendToChain404{ client: &'a str, channel: &'a str },
    ErrTooManyChannels405{ client: &'a str, channel: &'a str },
    ErrWasNoSuchNick406{ client: &'a str, nick: &'a str },
    ErrInputTooLong417{ client: &'a str },
    ErrUnknownCommand421{ client: &'a str, command: &'a str },
    ErrNicknameInUse433{ client: &'a str, nick: &'a str },
    ErrUserNotInChannel441{ client: &'a str, nick: &'a str, channel: &'a str },
    ErrNotOnChannel442{ client: &'a str, channel: &'a str },
    ErrUserOnChannel443{ client: &'a str, nick: &'a str, channel: &'a str },
    ErrNotRegistered451{ client: &'a str },
    ErrNeedMoreParams461{ client: &'a str, command: &'a str },
    ErrAlreadyRegistered462{ client: &'a str },
    ErrPasswdMismatch464{ client: &'a str },
    //ErrYoureBannedCreep465{ client: &'a str },
    ErrChannelIsFull471{ client: &'a str, channel: &'a str },
    ErrUnknownMode472{ client: &'a str, modechar: char, channel: &'a str },
    ErrInviteOnlyChan473{ client: &'a str, channel: &'a str },
    ErrBannedFromChan474{ client: &'a str, channel: &'a str },
    ErrBadChannelKey475{ client: &'a str, channel: &'a str },
    ErrNoPrivileges481{ client: &'a str },
    ErrChanOpPrivsNeeded482{ client: &'a str, channel: &'a str },
    ErrCantKillServer483{ client: &'a str },
    ErrYourConnRestricted484{ client: &'a str },
    ErrNoOperHost491{ client: &'a str },
    ErrUmodeUnknownFlag501{ client: &'a str },
    ErrUsersDontMatch502{ client: &'a str },
    ErrHelpNotFound524{ client: &'a str, subject: &'a str },
    //RplStartTls670{ client: &'a str },
    RplWhoIsSecure671{ client: &'a str, nick: &'a str },
    //ErrStartTls691{ client: &'a str },
    ErrInvalidModeParam696{ client: &'a str, target: &'a str, modechar: char,
        param: &'a str, description: &'a str },
    RplHelpStart704{ client: &'a str, subject: &'a str, line: &'a str },
    RplHelpTxt705{ client: &'a str, subject: &'a str, line: &'a str },
    RplEndOfHelp706{ client: &'a str, subject: &'a str, line: &'a str },
    //RplLoggedIn900{ client: &'a str, nick: &'a str, user: &'a str, host: &'a str,
    //        account: &'a str, username: &'a str },
    //RplLoggedOut901{ client: &'a str, nick: &'a str, user: &'a str, host: &'a str },
    //ErrNickLocked902{ client: &'a str },
    //RplSaslSuccess903{ client: &'a str },
    //ErrSaslFail904{ client: &'a str },
    //ErrSaslTooLong905{ client: &'a str },
    //ErrSaslAborted906{ client: &'a str },
    //ErrSaslAlready907{ client: &'a str },
    //RplSaslMechs908{ client: &'a str, mechanisms: &'a str },
    ErrCannotDoCommand972{ client: &'a str },
}

use Reply::*;

impl<'a> fmt::Display for Reply<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RplWelcome001{ client, networkname, nick, user, host } => {
                write!(f, "001 {} :Welcome to the {} Network, {}!~{}@{}",
                    client, networkname, nick, user, host) }
            RplYourHost002{ client, servername, version } => {
                write!(f, "002 {} :Your host is {}, running version {}",
                    client, servername, version) }
            RplCreated003{ client, datetime } => {
                write!(f, "003 {} :This server was created {}", client, datetime) }
            RplMyInfo004{ client, servername, version, avail_user_modes,
                    avail_chmodes, avail_chmodes_with_params } => {
                if let Some(p) = avail_chmodes_with_params {
                    write!(f, "004 {} {} {} {} {} {}", client, servername, version,
                        avail_user_modes, avail_chmodes, p)
                } else {
                    write!(f, "004 {} {} {} {} {}", client, servername, version,
                        avail_user_modes, avail_chmodes) } }
            RplISupport005{ client, tokens } => {
                write!(f, "005 {} {} :are supported by this server", client, tokens) }
            RplStatsCommands212{ client, command, count } => {
                write!(f, "212 {} {} {}", client, command, count) }
            RplEndOfStats219{ client, stat } => {
                write!(f, "219 {} {} :End of STATS report", client, stat) }
            RplUModeIs221{ client, user_modes } => {
                write!(f, "221 {} {}", client, user_modes) }
            RplStatsUptime242{ client, seconds } => {
                let day_time = seconds%(24*3600);
                let hour = day_time/3600;
                let minute = (day_time - hour*3600)/60;
                let second = day_time%60;
                write!(f, "242 {} :Server Up {} days {}:{:02}:{:02}", client,
                        seconds/(24*3600), hour, minute, second) }
            RplLUserClient251{ client, users_num, inv_users_num, servers_num } => {
                write!(f, "251 {} :There are {} users and {} invisible on {} servers",
                    client, users_num, inv_users_num, servers_num) }
            RplLUserOp252{ client, ops_num } => {
                write!(f, "252 {} {} :operator(s) online", client, ops_num) }
            RplLUserUnknown253{ client, conns_num } => {
                write!(f, "253 {} {} :unknown connection(s)", client, conns_num) }
            RplLUserChannels254{ client, channels_num } => {
                write!(f, "254 {} {} :channels formed", client, channels_num) }
            RplLUserMe255{ client, clients_num, servers_num } => {
                write!(f, "255 {} :I have {} clients and {} servers", client, clients_num,
                    servers_num) }
            RplAdminMe256{ client, server } => {
                write!(f, "256 {} {} :Administrative info", client, server) }
            RplAdminLoc1257{ client, info } => {
                write!(f, "257 {} :{}", client, info) }
            RplAdminLoc2258{ client, info } => {
                write!(f, "258 {} :{}", client, info) }
            RplAdminEmail259{ client, email } => {
                write!(f, "259 {} :{}", client, email) }
            RplLocalUsers265{ client, clients_num, max_clients_num } => {
                write!(f, "265 {} {} {} :Current local users {}, max {}", client,
                    clients_num, max_clients_num, clients_num, max_clients_num) }
            RplGlobalUsers266{ client, clients_num, max_clients_num } => {
                write!(f, "266 {} {} {} :Current global users {}, max {}", client,
                    clients_num, max_clients_num, clients_num, max_clients_num) }
            //RplWhoIsCertFP276{ client, nick, fingerprint } => {
            //    write!(f, "276 {} {} :has client certificate fingerprint {}", client, nick,
            //        fingerprint) }
            RplAway301{ client, nick, message } => {
                write!(f, "301 {} {} :{}", client, nick, message) }
            RplUserHost302{ client, replies } => {
                write!(f, "302 {} :{}", client, replies.iter()
                    .map(|x| x.to_string()).collect::<Vec::<_>>().join(" ")) }
            RplIson303{ client, nicknames } => {
                write!(f, "303 {} :{}", client, nicknames.iter()
                    .map(|x| x.to_string()).collect::<Vec::<_>>().join(" ")) }
            RplUnAway305{ client } => {
                write!(f, "305 {} :You are no longer marked as being away", client) }
            RplNowAway306{ client } => {
                write!(f, "306 {} :You have been marked as being away", client) }
            RplWhoReply352{ client, channel, username, host, server, nick, flags,
                    hopcount, realname } => {
                write!(f, "352 {} {} ~{} {} {} {} {} :{} {}", client, channel, username, host,
                    server, nick, flags, hopcount, realname) }
            RplEndOfWho315{ client, mask } => {
                write!(f, "315 {} {} :End of WHO list", client, mask) }
            RplWhoIsRegNick307{ client, nick } => {
                write!(f, "307 {} {} :has identified for this nick", client, nick) }
            RplWhoIsUser311{ client, nick, username, host, realname } => {
                write!(f, "311 {} {} ~{} {} * :{}", client, nick, username, host, realname) }
            RplWhoIsServer312{ client, nick, server, server_info } => {
                write!(f, "312 {} {} {} :{}", client, nick, server, server_info) }
            RplWhoIsOperator313{ client, nick } => {
                write!(f, "313 {} {} :is an IRC operator", client, nick) }
            RplWhoWasUser314{ client, nick, username, host, realname } => {
                write!(f, "314 {} {} ~{} {} * :{}", client, nick, username, host, realname) }
            RplwhoIsIdle317{ client, nick, secs, signon } => {
                write!(f, "317 {} {} {} {} :seconds idle, signon time",
                    client, nick, secs, signon) }
            RplEndOfWhoIs318{ client, nick } => {
                write!(f, "318 {} {} :End of /WHOIS list", client, nick) }
            RplWhoIsChannels319{ client, nick, channels } => {
                write!(f, "319 {} {} :{}", client, nick, channels.iter().map(|c| {
                    if let Some(ref prefix) = c.prefix {
                        prefix.to_string() + c.channel
                    } else { c.channel.to_string() }
                }).collect::<Vec<_>>().join(" ")) }
            RplListStart321{ client } => {
                write!(f, "321 {} Channel :Users  Name", client) }
            RplList322{ client, channel, client_count, topic } => {
                write!(f, "322 {} {} {} :{}", client, channel, client_count, topic) }
            RplListEnd323{ client } => {
                write!(f, "323 {} :End of /LIST", client) }
            RplChannelModeIs324{ client, channel, modestring } => {
                write!(f, "324 {} {} {}", client, channel, modestring) }
            RplCreationTime329{ client, channel, creation_time } => {
                write!(f, "329 {} {} {}", client, channel, creation_time) }
            RplNoTopic331{ client, channel } => {
                write!(f, "331 {} {} :No topic is set", client, channel) }
            RplTopic332{ client, channel, topic } => {
                write!(f, "332 {} {} :{}", client, channel, topic) }
            RplTopicWhoTime333{ client, channel, nick, setat } => {
                write!(f, "333 {} {} {} {}", client, channel, nick, setat) }
            RplInviting341{ client, nick, channel } => {
                write!(f, "341 {} {} {}", client, nick, channel) }
            RplInviteList346{ client, channel, mask } => {
                write!(f, "346 {} {} {}", client, channel, mask) }
            RplEndOfInviteList347{ client, channel } => {
                write!(f, "347 {} {} :End of channel invite list", client, channel) }
            RplExceptList348{ client, channel, mask } => {
                write!(f, "348 {} {} {}", client, channel, mask) }
            RplEndOfExceptList349{ client, channel } => {
                write!(f, "349 {} {} :End of channel exception list", client, channel) }
            RplVersion351{ client, version, server, comments } => {
                write!(f, "351 {} {} {} :{}", client, version, server, comments) }
            RplNameReply353{ client, symbol, channel, replies } => {
                write!(f, "353 {} {} {} :{}", client, symbol, channel,
                    replies.iter().map(|r| { r.prefix.to_string() + r.nick
                    }).collect::<Vec<_>>().join(" ")) }
            RplLinks364{ client, server, mask, hop_count, server_info } => {
                write!(f, "364 {} {} {} :{} {}", client, server, mask,
                        hop_count, server_info) }
            RplEndOfLinks365{ client, mask } => {
                write!(f, "365 {} {} :End of LINKS list", client, mask) },
            RplEndOfNames366{ client, channel } => {
                write!(f, "366 {} {} :End of /NAMES list", client, channel) }
            RplBanList367{ client, channel, mask, who, set_ts } => {
                write!(f, "367 {} {} {} {} {}", client, channel, mask, who, set_ts) }
            RplEndOfBanList368{ client, channel } => {
                write!(f, "368 {} {} :End of channel ban list", client, channel) }
            RplEndOfWhoWas369{ client, nick } => {
                write!(f, "369 {} {} :End of WHOWAS", client, nick) }
            RplInfo371{ client, info } => {
                write!(f, "371 {} :{}", client, info) }
            RplEndOfInfo374{ client } => {
                write!(f, "374 {} :End of INFO list", client) }
            RplMotdStart375{ client, server } => {
                write!(f, "375 {} :- {} Message of the day - ", client, server) }
            RplMotd372{ client, motd } => {
                write!(f, "372 {} :{}", client, motd) }
            RplEndOfMotd376{ client } => {
                write!(f, "376 {} :End of /MOTD command." , client) }
            RplWhoIsHost378{ client, nick, host_info } => {
                write!(f, "378 {} {} :is connecting from {}", client, nick, host_info) }
            RplWhoIsModes379{ client, nick, modes } => {
                write!(f, "379 {} {} :is using modes {}", client, nick, modes) }
            RplYoureOper381{ client } => {
                write!(f, "381 {} :You are now an IRC operator", client) }
            //RplRehashing382{ client, config_file } => {
            //    write!(f, "382 {} {} :Rehashing", client, config_file) }
            RplTime391{ client, server, timestamp, ts_offset, human_readable } => {
                write!(f, "391 {} {} {} {} :{}", client, server, timestamp, ts_offset,
                    human_readable) }
            ErrUnknownError400{ client, command, subcommand, info } => {
                if let Some(sc) = subcommand {
                    write!(f, "400 {} {} {} :{}", client, command, sc, info)
                } else {
                    write!(f, "400 {} {} :{}", client, command, info)
                } }
            ErrNoSuchNick401{ client, nick } => {
                write!(f, "401 {} {} :No such nick/channel", client, nick) }
            //ErrNoSuchServer402{ client, server } => {
            //    write!(f, "402 {} {} :No such server", client, server) }
            ErrNoSuchChannel403{ client, channel } => {
                write!(f, "403 {} {} :No such channel", client, channel) }
            ErrCannotSendToChain404{ client, channel } => {
                write!(f, "404 {} {} :Cannot send to channel", client, channel) }
            ErrTooManyChannels405{ client, channel } => {
                write!(f, "405 {} {} :You have joined too many channels", client, channel) }
            ErrWasNoSuchNick406{ client, nick } => {
                write!(f, "406 {} {} :There was no such nickname", client, nick) }
            ErrInputTooLong417{ client } => {
                write!(f, "417 {} :Input line was too long", client) }
            ErrUnknownCommand421{ client, command } => {
                write!(f, "421 {} {} :Unknown command", client, command) }
            ErrNicknameInUse433{ client, nick } => {
                write!(f, "433 {} {} :Nickname is already in use", client, nick) }
            ErrUserNotInChannel441{ client, nick, channel } => {
                write!(f, "441 {} {} {} :They aren't on that channel", client, nick, channel) }
            ErrNotOnChannel442{ client, channel } => {
                write!(f, "442 {} {} :You're not on that channel", client, channel) }
            ErrUserOnChannel443{ client, nick, channel } => {
                write!(f, "443 {} {} {} :is already on channel", client, nick, channel) }
            ErrNotRegistered451{ client } => {
                write!(f, "451 {} :You have not registered", client) }
            ErrNeedMoreParams461{ client, command } => {
                write!(f, "461 {} {} :Not enough parameters", client, command) }
            ErrAlreadyRegistered462{ client } => {
                write!(f, "462 {} :You may not reregister", client) }
            ErrPasswdMismatch464{ client } => {
                write!(f, "464 {} :Password incorrect", client) }
            //ErrYoureBannedCreep465{ client } => {
            //    write!(f, "465 {} :You are banned from this server.", client) }
            ErrChannelIsFull471{ client, channel } => {
                write!(f, "471 {} {} :Cannot join channel (+l)", client, channel) }
            ErrUnknownMode472{ client, modechar, channel } => {
                write!(f, "472 {} {} :is unknown mode char for {}", client, modechar,
                    channel) }
            ErrInviteOnlyChan473{ client, channel } => {
                write!(f, "473 {} {} :Cannot join channel (+i)", client, channel) }
            ErrBannedFromChan474{ client, channel } => {
                write!(f, "474 {} {} :Cannot join channel (+b)", client, channel) }
            ErrBadChannelKey475{ client, channel } => {
                write!(f, "475 {} {} :Cannot join channel (+k)", client, channel) }
            ErrNoPrivileges481{ client } => {
                write!(f, "481 {} :Permission Denied- You're not an IRC operator", client) }
            ErrChanOpPrivsNeeded482{ client, channel } => {
                write!(f, "482 {} {} :You're not channel operator", client, channel) }
            ErrCantKillServer483{ client } => {
                write!(f, "483 {} :You cant kill a server!", client) }
            ErrYourConnRestricted484{ client } => {
                write!(f, "484 {} :Your connection is restricted!", client) }
            ErrNoOperHost491{ client } => {
                write!(f, "491 {} :No O-lines for your host", client) }
            ErrUmodeUnknownFlag501{ client } => {
                write!(f, "501 {} :Unknown MODE flag", client) }
            ErrUsersDontMatch502{ client } => {
                write!(f, "502 {} :Cant change mode for other users", client) }
            ErrHelpNotFound524{ client, subject } => {
                write!(f, "524 {} {} :No help available on this topic", client, subject) }
            //RplStartTls670{ client } => {
            //    write!(f, "670 {} :STARTTLS successful, proceed with TLS handshake", client) }
            RplWhoIsSecure671{ client, nick } => {
                write!(f, "671 {} {} :is using a secure connection", client, nick) }
            //ErrStartTls691{ client } => {
            //    write!(f, "691 {} :STARTTLS failed (Wrong moon phase)", client) }
            ErrInvalidModeParam696{ client, target, modechar, param, description } => {
                write!(f, "696 {} {} {} {} :{}", client, target, modechar,
                          param, description) }
            RplHelpStart704{ client, subject, line } => {
                write!(f, "704 {} {} :{}", client, subject, line) }
            RplHelpTxt705{ client, subject, line } => {
                write!(f, "705 {} {} :{}", client, subject, line) }
            RplEndOfHelp706{ client, subject, line } => {
                write!(f, "706 {} {} :{}", client, subject, line) }
            //RplLoggedIn900{ client, nick, user, host, account, username } => {
            //    write!(f, "900 {} {}!~{}@{} {} :You are now logged in as {}", client, nick,
            //        user, host, account, username) }
            //RplLoggedOut901{ client, nick, user, host } => {
            //    write!(f, "901 {} {}!~{}@{} :You are now logged out", client, nick,
            //        user, host) }
            //ErrNickLocked902{ client } => {
            //    write!(f, "902 {} :You must use a nick assigned to you", client) }
            //RplSaslSuccess903{ client } => {
            //    write!(f, "903 {} :SASL authentication successful", client) }
            //ErrSaslFail904{ client } => {
            //    write!(f, "904 {} :SASL authentication failed", client) }
            //ErrSaslTooLong905{ client } => {
            //    write!(f, "905 {} :SASL message too long", client) }
            //ErrSaslAborted906{ client } => {
            //    write!(f, "906 {} :SASL authentication aborted", client) }
            //ErrSaslAlready907{ client } => {
            //    write!(f, "907 {} :You have already authenticated using SASL", client) }
            //RplSaslMechs908{ client, mechanisms } => {
            //    write!(f, "908 {} {} :are available SASL mechanisms", client, mechanisms) }
            ErrCannotDoCommand972{ client } => {
                write!(f, "972 {} :Can not do command", client) }
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    
    #[test]
    fn test_replies() {
        assert_eq!("001 <client> :Welcome to the <networkname> Network, <nick>!~<user>@<host>",
            format!("{}", RplWelcome001{ client: "<client>", networkname: "<networkname>",
                nick: "<nick>", user: "<user>", host: "<host>" }));
        assert_eq!("002 <client> :Your host is <servername>, running version <version>",
            format!("{}", RplYourHost002{ client: "<client>", servername: "<servername>",
                version: "<version>" }));
        assert_eq!("003 <client> :This server was created <datetime>",
            format!("{}", RplCreated003{ client: "<client>", datetime: "<datetime>" }));
        assert_eq!("004 <client> <servername> <version> <available user modes> \
                    <available channel modes> <channel modes with a parameter>",
            format!("{}", RplMyInfo004{ client: "<client>", servername: "<servername>",
            version: "<version>", avail_user_modes: "<available user modes>",
            avail_chmodes: "<available channel modes>",
            avail_chmodes_with_params: Some("<channel modes with a parameter>") }));
        assert_eq!("004 <client> <servername> <version> <available user modes> \
                    <available channel modes>",
            format!("{}", RplMyInfo004{ client: "<client>", servername: "<servername>",
            version: "<version>", avail_user_modes: "<available user modes>",
            avail_chmodes: "<available channel modes>",
            avail_chmodes_with_params: None }));
        assert_eq!("005 <client> <1-13 tokens> :are supported by this server",
            format!("{}", RplISupport005{ client: "<client>", tokens: "<1-13 tokens>" }));
        assert_eq!("212 <client> <command> 67",
            format!("{}", RplStatsCommands212{ client: "<client>", command: "<command>",
                    count: 67 }));
        assert_eq!("219 <client> u :End of STATS report",
            format!("{}", RplEndOfStats219{ client: "<client>", stat: 'u' }));
        assert_eq!("221 <client> <user modes>",
            format!("{}", RplUModeIs221{ client: "<client>", user_modes: "<user modes>" }));
        assert_eq!("242 <client> :Server Up 4120 days 21:34:49",
            format!("{}", RplStatsUptime242{ client: "<client>", seconds: 356045689 }));
        assert_eq!("251 <client> :There are 3 users and 4 invisible on 5 servers",
            format!("{}", RplLUserClient251{ client: "<client>", users_num: 3,
                inv_users_num: 4, servers_num: 5 }));
        assert_eq!("252 <client> 6 :operator(s) online",
            format!("{}", RplLUserOp252{ client: "<client>", ops_num: 6 }));
        assert_eq!("253 <client> 7 :unknown connection(s)",
            format!("{}", RplLUserUnknown253{ client: "<client>", conns_num: 7 }));
        assert_eq!("254 <client> 8 :channels formed",
            format!("{}", RplLUserChannels254{ client: "<client>", channels_num: 8 }));
        assert_eq!("255 <client> :I have 3 clients and 6 servers",
            format!("{}", RplLUserMe255{ client: "<client>", clients_num: 3,
                servers_num: 6 }));
        assert_eq!("256 <client> <server> :Administrative info",
            format!("{}", RplAdminMe256{ client: "<client>", server: "<server>" }));
        assert_eq!("257 <client> :<info>",
            format!("{}", RplAdminLoc1257{ client: "<client>", info: "<info>" }));
        assert_eq!("258 <client> :<info>",
            format!("{}", RplAdminLoc2258{ client: "<client>", info: "<info>" }));
        assert_eq!("259 <client> :<info>",
            format!("{}", RplAdminEmail259{ client: "<client>", email: "<info>" }));
        assert_eq!("265 <client> 4 7 :Current local users 4, max 7",
            format!("{}", RplLocalUsers265{ client: "<client>", clients_num: 4,
                max_clients_num: 7 }));
        assert_eq!("266 <client> 7 10 :Current global users 7, max 10",
            format!("{}", RplGlobalUsers266{ client: "<client>", clients_num: 7,
                max_clients_num: 10 }));
        //assert_eq!("276 <client> <nick> :has client certificate fingerprint <fingerprint>",
        //    format!("{}", RplWhoIsCertFP276{ client: "<client>", nick: "<nick>",
        //        fingerprint: "<fingerprint>" }));
        assert_eq!("301 <client> <nick> :<message>",
            format!("{}", RplAway301{ client: "<client>", nick: "<nick>",
                message: "<message>" }));
        assert_eq!("302 <client> :",
            format!("{}", RplUserHost302{ client: "<client>", replies: &vec![] }));
        assert_eq!("302 <client> :<reply1> <reply2> <reply3>",
            format!("{}", RplUserHost302{ client: "<client>",
                replies: &vec![ "<reply1>".to_string(), "<reply2>".to_string(),
                            "<reply3>".to_string()] }));
        assert_eq!("303 <client> :<nick1> <nick2> <nick3>",
            format!("{}", RplIson303{ client: "<client>",
                nicknames: &vec![ "<nick1>", "<nick2>", "<nick3>"] }));
        assert_eq!("305 <client> :You are no longer marked as being away",
            format!("{}", RplUnAway305{ client: "<client>" }));
        assert_eq!("306 <client> :You have been marked as being away",
            format!("{}", RplNowAway306{ client: "<client>" }));
        assert_eq!("352 <client> <channel> ~<username> <host> <server> <nick> \
                <flags> :2 <realname>",
            format!("{}", RplWhoReply352{ client: "<client>", channel: "<channel>",
                username: "<username>", host: "<host>", server: "<server>", nick: "<nick>",
                flags: "<flags>", hopcount: 2, realname: "<realname>" }));
        assert_eq!("315 <client> <mask> :End of WHO list",
            format!("{}", RplEndOfWho315{ client: "<client>", mask: "<mask>" }));
        assert_eq!("307 <client> <nick> :has identified for this nick",
            format!("{}", RplWhoIsRegNick307{ client: "<client>", nick: "<nick>" }));
        assert_eq!("311 <client> <nick> ~<username> <host> * :<realname>",
            format!("{}", RplWhoIsUser311{ client: "<client>", nick: "<nick>",
                host: "<host>", username: "<username>", realname: "<realname>" }));
        assert_eq!("312 <client> <nick> <server> :<server info>",
            format!("{}", RplWhoIsServer312{ client: "<client>", nick: "<nick>",
                server: "<server>", server_info: "<server info>" }));
        assert_eq!("313 <client> <nick> :is an IRC operator",
            format!("{}", RplWhoIsOperator313{ client: "<client>", nick: "<nick>" }));
        assert_eq!("314 <client> <nick> ~<username> <host> * :<realname>",
            format!("{}", RplWhoWasUser314{ client: "<client>", nick: "<nick>",
                username: "<username>", host: "<host>", realname: "<realname>" }));
        assert_eq!("317 <client> <nick> 134 548989343 :seconds idle, signon time",
            format!("{}", RplwhoIsIdle317{ client: "<client>", nick: "<nick>",
                secs: 134, signon: 548989343 }));
        assert_eq!("318 <client> <nick> :End of /WHOIS list",
            format!("{}", RplEndOfWhoIs318{ client: "<client>", nick: "<nick>" }));
        assert_eq!("319 <client> <nick> :prefix1<channel1> <channel2> prefix3<channel3>",
            format!("{}", RplWhoIsChannels319{ client: "<client>", nick: "<nick>",
                channels: &vec![
                    WhoIsChannelStruct{ prefix: Some("prefix1".to_string()),
                            channel: "<channel1>" },
                    WhoIsChannelStruct{ prefix: None, channel: "<channel2>" },
                    WhoIsChannelStruct{ prefix: Some("prefix3".to_string()),
                            channel: "<channel3>" }]}));
        assert_eq!("321 <client> Channel :Users  Name",
            format!("{}", RplListStart321{ client: "<client>" }));
        assert_eq!("322 <client> <channel> 47 :<topic>",
            format!("{}", RplList322{ client: "<client>", channel: "<channel>",
                client_count: 47, topic: "<topic>" }));
        assert_eq!("323 <client> :End of /LIST",
            format!("{}", RplListEnd323{ client: "<client>" }));
        assert_eq!("324 <client> <channel> <modestring>",
            format!("{}", RplChannelModeIs324{ client: "<client>", channel: "<channel>",
                modestring: "<modestring>" }));
        assert_eq!("329 <client> <channel> 334411111",
            format!("{}", RplCreationTime329{ client: "<client>", channel: "<channel>",
                creation_time: 334411111 }));
        assert_eq!("331 <client> <channel> :No topic is set",
            format!("{}", RplNoTopic331{ client: "<client>", channel: "<channel>" }));
        assert_eq!("332 <client> <channel> :<topic>",
            format!("{}", RplTopic332{ client: "<client>", channel: "<channel>",
                topic: "<topic>" }));
        assert_eq!("333 <client> <channel> <nick> 38329311",
            format!("{}", RplTopicWhoTime333{ client: "<client>", channel: "<channel>",
                nick: "<nick>", setat: 38329311 }));
        assert_eq!("341 <client> <nick> <channel>",
            format!("{}", RplInviting341{ client: "<client>", nick: "<nick>",
                channel: "<channel>" }));
        assert_eq!("346 <client> <channel> <mask>",
            format!("{}", RplInviteList346{ client: "<client>", channel: "<channel>",
                mask: "<mask>" }));
        assert_eq!("347 <client> <channel> :End of channel invite list",
            format!("{}", RplEndOfInviteList347{ client: "<client>",
                channel: "<channel>" }));
        assert_eq!("348 <client> <channel> <mask>",
            format!("{}", RplExceptList348{ client: "<client>", channel: "<channel>",
                mask: "<mask>" }));
        assert_eq!("349 <client> <channel> :End of channel exception list",
            format!("{}", RplEndOfExceptList349{ client: "<client>",
                channel: "<channel>" }));
        assert_eq!("351 <client> <version> <server> :<comments>",
            format!("{}", RplVersion351{ client: "<client>", version: "<version>",
                server: "<server>", comments: "<comments>" }));
        assert_eq!("353 <client> <symbol> <channel> :<prefix1><nick1> <nick2>",
            format!("{}", RplNameReply353{ client: "<client>", symbol: "<symbol>",
                channel: "<channel>", replies: &vec![
                    NameReplyStruct{ prefix: "<prefix1>".to_string(), nick: "<nick1>" },
                    NameReplyStruct{ prefix: String::new(), nick: "<nick2>" }] }));
        assert_eq!("364 <client> <server> <mask> :1 <server_info>",
            format!("{}", RplLinks364{ client: "<client>",
                server: "<server>", mask: "<mask>", hop_count: 1,
                server_info: "<server_info>" }));
        assert_eq!("365 <client> <mask> :End of LINKS list",
            format!("{}", RplEndOfLinks365{ client: "<client>", mask: "<mask>" }));
        assert_eq!("366 <client> <channel> :End of /NAMES list",
            format!("{}", RplEndOfNames366{ client: "<client>", channel: "<channel>" }));
        assert_eq!("367 <client> <channel> <mask> <who> 3894211355",
            format!("{}", RplBanList367{ client: "<client>", channel: "<channel>",
                mask: "<mask>", who: "<who>", set_ts: 3894211355 }));
        assert_eq!("368 <client> <channel> :End of channel ban list",
            format!("{}", RplEndOfBanList368{ client: "<client>", channel: "<channel>" }));
        assert_eq!("369 <client> <nick> :End of WHOWAS",
            format!("{}", RplEndOfWhoWas369{ client: "<client>", nick: "<nick>" }));
        assert_eq!("371 <client> :<info>",
            format!("{}", RplInfo371{ client: "<client>", info: "<info>" }));
        assert_eq!("374 <client> :End of INFO list",
            format!("{}", RplEndOfInfo374{ client: "<client>" }));
        assert_eq!("375 <client> :- <server> Message of the day - ",
            format!("{}", RplMotdStart375{ client: "<client>", server: "<server>" }));
        assert_eq!("372 <client> :<motd>",
            format!("{}", RplMotd372{ client: "<client>", motd: "<motd>" }));
        assert_eq!("376 <client> :End of /MOTD command.",
            format!("{}", RplEndOfMotd376{ client: "<client>" }));
        assert_eq!("378 <client> <nick> :is connecting from *@localhost 127.0.0.1",
            format!("{}", RplWhoIsHost378{ client: "<client>", nick: "<nick>",
                host_info: "*@localhost 127.0.0.1" }));
        assert_eq!("379 <client> <nick> :is using modes +ailosw",
            format!("{}", RplWhoIsModes379{ client: "<client>", nick: "<nick>",
                modes: "+ailosw" }));
        assert_eq!("381 <client> :You are now an IRC operator",
            format!("{}", RplYoureOper381{ client: "<client>" }));
        //assert_eq!("382 <client> <config file> :Rehashing",
        //    format!("{}", RplRehashing382{ client: "<client>",
        //        config_file: "<config file>" }));
        assert_eq!("391 <client> <server> 485829211 <TS offset> :<human-readable time>",
            format!("{}", RplTime391{ client: "<client>", server: "<server>",
                timestamp: 485829211, ts_offset: "<TS offset>",
                human_readable: "<human-readable time>" }));
        assert_eq!("400 <client> <command> :<info>",
            format!("{}", ErrUnknownError400{ client: "<client>", command: "<command>",
                subcommand: None, info: "<info>" }));
        assert_eq!("400 <client> <command> <subcommand> :<info>",
            format!("{}", ErrUnknownError400{ client: "<client>", command: "<command>",
                subcommand: Some("<subcommand>"), info: "<info>" }));
        assert_eq!("401 <client> <nickname> :No such nick/channel",
            format!("{}", ErrNoSuchNick401{ client: "<client>", nick: "<nickname>" }));
        //assert_eq!("402 <client> <server name> :No such server",
        //    format!("{}", ErrNoSuchServer402{ client: "<client>",
        //        server: "<server name>" }));
        assert_eq!("403 <client> <channel> :No such channel",
            format!("{}", ErrNoSuchChannel403{ client: "<client>", channel: "<channel>" }));
        assert_eq!("404 <client> <channel> :Cannot send to channel",
            format!("{}", ErrCannotSendToChain404{ client: "<client>",
                channel: "<channel>" }));
        assert_eq!("405 <client> <channel> :You have joined too many channels",
            format!("{}", ErrTooManyChannels405{ client: "<client>",
                channel: "<channel>" }));
        assert_eq!("406 <client> <nickname> :There was no such nickname",
            format!("{}", ErrWasNoSuchNick406{ client: "<client>", nick: "<nickname>" }));
        assert_eq!("417 <client> :Input line was too long",
            format!("{}", ErrInputTooLong417{ client: "<client>" }));
        assert_eq!("421 <client> <command> :Unknown command",
            format!("{}", ErrUnknownCommand421{ client: "<client>",
                command: "<command>" }));
        assert_eq!("433 <client> <nick> :Nickname is already in use",
            format!("{}", ErrNicknameInUse433{ client: "<client>", nick: "<nick>" }));
        assert_eq!("441 <client> <nick> <channel> :They aren't on that channel",
            format!("{}", ErrUserNotInChannel441{ client: "<client>", nick: "<nick>",
                channel: "<channel>" }));
        assert_eq!("442 <client> <channel> :You're not on that channel",
            format!("{}", ErrNotOnChannel442{ client: "<client>", channel: "<channel>" }));
        assert_eq!("443 <client> <nick> <channel> :is already on channel",
            format!("{}", ErrUserOnChannel443{ client: "<client>", nick: "<nick>",
                channel: "<channel>" }));
        assert_eq!("451 <client> :You have not registered",
            format!("{}", ErrNotRegistered451{ client: "<client>" }));
        assert_eq!("461 <client> <command> :Not enough parameters",
            format!("{}", ErrNeedMoreParams461{ client: "<client>",command: "<command>" }));
        assert_eq!("462 <client> :You may not reregister",
            format!("{}", ErrAlreadyRegistered462{ client: "<client>" }));
        assert_eq!("464 <client> :Password incorrect",
            format!("{}", ErrPasswdMismatch464{ client: "<client>" }));
        //assert_eq!("465 <client> :You are banned from this server.",
        //    format!("{}", ErrYoureBannedCreep465{ client: "<client>" }));
        assert_eq!("471 <client> <channel> :Cannot join channel (+l)",
            format!("{}", ErrChannelIsFull471{ client: "<client>", channel: "<channel>" }));
        assert_eq!("472 <client> x :is unknown mode char for <channel>",
            format!("{}", ErrUnknownMode472{ client: "<client>", modechar: 'x',
                    channel: "<channel>" }));
        assert_eq!("473 <client> <channel> :Cannot join channel (+i)",
            format!("{}", ErrInviteOnlyChan473{ client: "<client>", channel: "<channel>" }));
        assert_eq!("474 <client> <channel> :Cannot join channel (+b)",
            format!("{}", ErrBannedFromChan474{ client: "<client>", channel: "<channel>" }));
        assert_eq!("475 <client> <channel> :Cannot join channel (+k)",
            format!("{}", ErrBadChannelKey475{ client: "<client>", channel: "<channel>" }));
        assert_eq!("481 <client> :Permission Denied- You're not an IRC operator",
            format!("{}", ErrNoPrivileges481{ client: "<client>" }));
        assert_eq!("482 <client> <channel> :You're not channel operator",
            format!("{}", ErrChanOpPrivsNeeded482{ client: "<client>",
                channel: "<channel>" }));
        assert_eq!("483 <client> :You cant kill a server!",
            format!("{}", ErrCantKillServer483{ client: "<client>" }));
        assert_eq!("484 <client> :Your connection is restricted!",
            format!("{}", ErrYourConnRestricted484{ client: "<client>" }));
        assert_eq!("491 <client> :No O-lines for your host",
            format!("{}", ErrNoOperHost491{ client: "<client>" }));
        assert_eq!("501 <client> :Unknown MODE flag",
            format!("{}", ErrUmodeUnknownFlag501{ client: "<client>" }));
        assert_eq!("502 <client> :Cant change mode for other users",
            format!("{}", ErrUsersDontMatch502{ client: "<client>" }));
        assert_eq!("524 <client> <subject> :No help available on this topic",
            format!("{}", ErrHelpNotFound524{ client: "<client>", subject: "<subject>" }));
        //assert_eq!("670 <client> :STARTTLS successful, proceed with TLS handshake",
        //    format!("{}", RplStartTls670{ client: "<client>" }));
        //assert_eq!("671 <client> <nick> :is using a secure connection",
        //    format!("{}", RplWhoIsSecure671{ client: "<client>", nick: "<nick>" }));
        //assert_eq!("691 <client> :STARTTLS failed (Wrong moon phase)",
        //    format!("{}", ErrStartTls691{ client: "<client>" }));
        assert_eq!("696 <client> <target chan/user> x <parameter> :<description>",
            format!("{}", ErrInvalidModeParam696{ client: "<client>",
                target: "<target chan/user>", modechar: 'x', param: "<parameter>",
                description: "<description>" }));
        assert_eq!("704 <client> <subject> :<first line of help section>",
            format!("{}", RplHelpStart704{ client: "<client>", subject: "<subject>",
                line: "<first line of help section>" }));
        assert_eq!("705 <client> <subject> :<line of help text>",
            format!("{}", RplHelpTxt705{ client: "<client>", subject: "<subject>",
                line: "<line of help text>" }));
        assert_eq!("706 <client> <subject> :<last line of help text>",
            format!("{}", RplEndOfHelp706{ client: "<client>", subject: "<subject>",
                line: "<last line of help text>" }));
        //assert_eq!("900 <client> <nick>!~<user>@<host> <account> \
        //    :You are now logged in as <username>",
        //    format!("{}", RplLoggedIn900{ client: "<client>", nick: "<nick>",
        //        user: "<user>", host: "<host>", account: "<account>",
        //        username: "<username>" }));
        //assert_eq!("901 <client> <nick>!~<user>@<host> :You are now logged out",
        //    format!("{}", RplLoggedOut901{ client: "<client>", nick: "<nick>",
        //        user: "<user>", host: "<host>" }));
        //assert_eq!("902 <client> :You must use a nick assigned to you",
        //    format!("{}", ErrNickLocked902{ client: "<client>" }));
        //assert_eq!("903 <client> :SASL authentication successful",
        //    format!("{}", RplSaslSuccess903{ client: "<client>" }));
        //assert_eq!("904 <client> :SASL authentication failed",
        //    format!("{}", ErrSaslFail904{ client: "<client>" }));
        //assert_eq!("905 <client> :SASL message too long",
        //    format!("{}", ErrSaslTooLong905{ client: "<client>" }));
        //assert_eq!("906 <client> :SASL authentication aborted",
        //    format!("{}", ErrSaslAborted906{ client: "<client>" }));
        //assert_eq!("907 <client> :You have already authenticated using SASL",
        //    format!("{}", ErrSaslAlready907{ client: "<client>" }));
        //assert_eq!("908 <client> <mechanisms> :are available SASL mechanisms",
        //    format!("{}", RplSaslMechs908{ client: "<client>",
        //        mechanisms: "<mechanisms>" }));
        assert_eq!("972 <client> :Can not do command",
            format!("{}", ErrCannotDoCommand972{ client: "<client>" }));
    }
}