unit EvilIrc;

interface

uses
    Windows, Classes, SysUtils, EvilStrings, EvilWinUtils, EvilClasses, EvilTCPSocket;

const
    CWHO: string     = 'WHO';
    CTIME: string    = 'TIME';
    CPASS: string    = 'PASS';
    CNICK: string    = 'NICK';
    CUSER: string    = 'USER';
    CPING: string    = 'PING';
    CPONG: string    = 'PONG';
    CJOIN: string    = 'JOIN';
    CPART: string    = 'PART';
    CKICK: string    = 'KICK';
    CMODE: string    = 'MODE';
    CQUIT: string    = 'QUIT';
    CKILL: string    = 'KILL';
    CWHOIS: string   = 'WHOIS';
    CTOPIC: string   = 'TOPIC';
    CNAMES: string   = 'NAMES';
    CERROR: string   = 'ERROR';
    CINVITE: string  = 'INVITE';
    CNOTICE: string  = 'NOTICE';
    CACTION: string  = 'ACTION';
    CFINGER: string  = 'FINGER';
    CVERSION: string = 'VERSION';
    CWALLOPS: string = 'WALLOPS';
    CPRIVMSG: string = 'PRIVMSG';

    CBold: char      = #$02;
    CColor: char     = #$03;
    COrdinary: char  = #$0F;
    CReverse: char   = #$16;
    CItalic: char    = #$1D;
    CUnderline: char = #$1F;

type
    { Forward declarations }
    TIrcNickname            = class;
    TIrcNicknameList        = class;
    TIrcChannelNickname     = class;
    TIrcChannelNicknameList = class;
    TIrcChannel             = class;
    TIrcChannelList         = class;
    TIrcIAL                 = class;
    TIrc                    = class;

    { Misc types }
    TIrcChanMode  = (cmOwner, cmAdmin, cmOperator, cmHelper, cmVoice);
    TIrcChanModes = set of TIrcChanMode;

    { TIrcMsgParser }
    TIrcMsgParser = class
    strict private
    type
        TSourceType = (stServer, stUser, stNotPresent);

        TWordMarker = record
            Start: integer;
            Length: integer;
        end;
    strict private
        FRaw           : string; { Parsed IRC command }
        FSourceType    : TSourceType;
        FSource        : TWordMarker;
        FSourceNickName: TWordMarker;
        FSourceUserName: TWordMarker;
        FSourceHostName: TWordMarker;
        FCommand       : TWordMarker;
        FParams        : TWordMarker;
        FParamsArray   : array of TWordMarker;
        FParamCount    : integer;
        FTrailings     : TWordMarker;
        FTrailingsArray: array of TWordMarker;
        FTrailingCount : integer;
        function GetParam(aIndex: integer): string;
        function GetTrailing(aIndex: integer): string;
    private
        procedure AddParam(const aStart, aLength: integer);
        procedure AddTrailing(const aStart, aLength: integer);
        procedure Clear;
    public
        constructor Create;
        destructor Destroy; override;

        function Parse(const aRaw: string): boolean;
        { Parses a RAW IRC message }
        property Raw: string read FRaw; { Returns the last RAW passed to Parse(); }

        property SourceType: TSourceType read FSourceType; { Type of message source prefix. }
        function Source: string;
        { Returns the message source, if present; Client or server that sent the message. }
        function SourceNickName: string;
        { Returns NickName from Source if Source is a Client, full source string otherwise }
        function SourceUserName: string;
        { Returns UserName from Source if Source is a Client, full source string otherwise }
        function SourceHostName: string;
        { Returns HostName from Source if Source is a Client, full source string otherwise }

        function Command: string;
        { Returns IRC Command that was parsed from RAW }

        property Param[aIndex: integer]: string read GetParam;
        { Array of parsed Parameters. This excludes trailing Parameters }
        property ParamCount: integer read FParamCount; { Number of parsed Parameters. }
        function Params: string;                       { Returns all Parameters as a single string }
        function ParamsFrom(const aIndex: integer): string;
        { Returns parameters from and including token at aIndex. }

        property Trailing[aIndex: integer]: string read GetTrailing; { Array of parsed trailing Parameters. }
        property TrailingCount: integer read FTrailingCount;         { Number of parsed trailing Parameters. }
        function Trailings: string;
        { Returns all trailing Parameters as a single string }
        function TrailingsFrom(const aIndex: integer): string;
        { Returns trailing parameters from and including token at aIndex. }

        function AllParams: string;
        { Returns all middle and trailing params as a single string. }
    end;

    { TIrcNickname }
    { Contains info about a nickname }
    TIrcNickname = class
    private
        FNicknameList: TIrcNicknameList;
        FNickname    : string;
        FUsername    : string;
        FRealname    : string;
        FHostname    : string;
        FUserMode    : string;
        FIdentified  : boolean;
        FIrcOp       : boolean;
        FBot         : boolean;
        FAway        : boolean;
        FHops        : byte;
        FLeaf        : string;
        procedure SetNickname(const Value: string);
        procedure SetRealName(const Value: string);
        procedure SetUsername(const Value: string);
        procedure SetHostname(const Value: string);
        procedure SetUsermode(const Value: string);
    public
        constructor Create(aList: TIrcNicknameList);
        destructor Destroy; override;
        procedure Assign(aSource: TIrcNickname);

        procedure UpdateHostmask(const aHostmask: string);
        function GetHostMask: string; overload;
        function GetHostMask(const aType: byte): string; overload;
    public
        function IsOwner(const aChannel: string): boolean;
        function IsAdmin(const aChannel: string): boolean;
        function IsChanop(const aChannel: string): boolean;
        function IsHelper(const aChannel: string): boolean;
        function IsVoice(const aChannel: string): boolean;
        function IsRegular(const aChannel: string): boolean;

        function IsOnChannel(const aChannel: string): boolean;
        function IsIdentified(const aNick: string): boolean;

        property Nickname: string read FNickname write SetNickname;
        property Username: string read FUsername write SetUsername;
        property Realname: string read FRealname write SetRealName;
        property Hostname: string read FHostname write SetHostname;
        property Usermode: string read FUserMode write SetUsermode;

        property Identified: boolean read FIdentified write FIdentified;
        property IrcOp: boolean read FIrcOp write FIrcOp;
        property Bot: boolean read FBot write FBot;
        property Away: boolean read FAway write FAway;
        property Hops: byte read FHops write FHops;
        property Leaf: string read FLeaf write FLeaf;
    end;

    { TIrcNicknameList }
    { Contains and manages a list of TIrcNickname for TInternalAddressList }
    TIrcNicknameList = class
    private
        FIAL      : TIrcIAL;
        FNicknames: array of TIrcNickname;
        FCount    : integer;
    protected
        procedure Exchange(aIndexA, aIndexB: integer);
        procedure QuickSort(aStart, aEnd: integer);
        function GetInsertIndex(const aNickname: string): integer;
    public
        constructor Create(aIAL: TIrcIAL);
        destructor Destroy; override;

        function Add(const aNickname: string): TIrcNickname;
        procedure Del(const aNickname: string);
        function IndexOf(const aNickname: string): integer;
        function Find(const aNickname: string): TIrcNickname;
        procedure Sort;
        procedure Clear;

        property IAL: TIrcIAL read FIAL;
    end;

    { TIrcChannelNickname }
    { Contains info about a nickname on a channel }
    TIrcChannelNickname = class
    private
        FChannelNicknameList: TIrcChannelNicknameList;
        FNickname           : TIrcNickname;
        FChanModes          : TIrcChanModes;
    public
        constructor Create(aList: TIrcChannelNicknameList);
        procedure Assign(aSource: TIrcChannelNickname);

        property Nickname: TIrcNickname read FNickname write FNickname;
        property ChanModes: TIrcChanModes read FChanModes write FChanModes;
    end;

    { TIrcChannel }
    { Contains and manages a list of TIrcChannelNickname for TIrcChannel }
    TIrcChannelNicknameList = class
    private
        FChannel  : TIrcChannel;
        FNicknames: array of TIrcChannelNickname;
        FCount    : integer;
        function GetNickname(const aIndex: integer): TIrcChannelNickname;
        procedure SetNickname(const aIndex: integer; const Value: TIrcChannelNickname);
    protected
        procedure Exchange(aIndexA, aIndexB: integer);
        procedure QuickSort(aStart, aEnd: integer);
        function GetInsertIndex(const aNickname: string): integer;
    public
        constructor Create(aChannel: TIrcChannel);
        destructor Destroy; override;

        function Add(aNickname: TIrcNickname; const aChanModes: TIrcChanModes = []): TIrcChannelNickname;
        procedure Del(const aNickname: string);
        function IndexOf(const aNickname: string): integer;
        function Find(const aNickname: string): TIrcChannelNickname;
        procedure Sort;
        procedure Clear;

        property Nicknames[const aIndex: integer]: TIrcChannelNickname read GetNickname write SetNickname;
        property Count: integer read FCount;
        property Channel: TIrcChannel read FChannel;
    end;

    { TIrcChannel }
    { Contains info about a channel }
    TIrcChannel = class
    private
        FChannelList        : TIrcChannelList;
        FTopic              : string;
        FTopicSetBy         : string;
        FTopicSetOn         : TDateTime;
        FModes              : string;
        FChannelName        : string;
        FChannelNicknameList: TIrcChannelNicknameList;
    public
        constructor Create(aList: TIrcChannelList);
        destructor Destroy; override;
        procedure Assign(aSource: TIrcChannel);

        property ChannelName: string read FChannelName write FChannelName;
        property Topic: string read FTopic write FTopic;
        property TopicSetBy: string read FTopicSetBy write FTopicSetBy;
        property TopicSetOn: TDateTime read FTopicSetOn write FTopicSetOn;
        property Modes: string read FModes write FModes;

        property Nicknames: TIrcChannelNicknameList read FChannelNicknameList write FChannelNicknameList;
    end;

    { TIrcChannelList }
    { Contains and manages a list of TIrcChannel for TInternalAddressList }
    TIrcChannelList = class
    private
        FIAL     : TIrcIAL;
        FChannels: array of TIrcChannel;
        FCount   : integer;
    protected
        procedure Exchange(aIndexA, aIndexB: integer);
        procedure QuickSort(aStart, aEnd: integer);
        function GetInsertIndex(const aChannel: string): integer;
    public
        constructor Create(aIAL: TIrcIAL);
        destructor Destroy; override;

        function Add(const aChannel: string): TIrcChannel;
        procedure Del(const aChannel: string);
        function IndexOf(const aChannel: string): integer;
        function Find(const aChannel: string): TIrcChannel;
        procedure Sort;
        procedure Clear;

        property IAL: TIrcIAL read FIAL;
    end;

    { TInternalAddressList }
    TIrcIAL = class(TPersistent)
    private
        FIrc             : TIrc;
        FEnabled         : boolean;
        FNicknameList    : TIrcNicknameList;
        FChannelList     : TIrcChannelList;
        FTokenizer       : TTokenizer;
        FDetailedTracking: boolean;
        procedure SetEnabled(const Value: boolean);
        function GetNicknameByName(const aNickname: string): TIrcNickname;
        function GetNicknameByIndex(const aIndex: integer): TIrcNickname;
        procedure SetNicknameByIndex(const aIndex: integer; const Value: TIrcNickname);
        function GetNicknameCount: integer;
        function GetChannelByName(const aChannel: string): TIrcChannel;
        function GetChannelByIndex(const aIndex: integer): TIrcChannel;
        procedure SetChannelByIndex(const aIndex: integer; const Value: TIrcChannel);
        function GetChannelCount: integer;
    protected
        procedure NickJoinedChannel(const aNickname, aHostmask, aChannel: string);
        procedure NickPartedChannel(const aNickname, aChannel: string);
        procedure NickKickedFromChannel(const aNickname, aChannel: string);
        procedure NickChange(const aOldNickname, aNewNickname: string);
        procedure NickQuit(const aNickname: string);
        procedure NamesList(const aChannel, aNamesList: string);
        procedure WhoText(const aText: string);
        procedure NickIsIdentified(const aNickname: string);
    public
        constructor Create(aIrc: TIrc);
        destructor Destroy; override;

        function IsNicknameIdentified(const aNickname: string): boolean;
    public
        procedure Clear;

        property Nickname[const aNickname: string]: TIrcNickname read GetNicknameByName;
        property Nicknames[const aIndex: integer]: TIrcNickname read GetNicknameByIndex write SetNicknameByIndex;
        property NicknameCount: integer read GetNicknameCount;

        property Channel[const aChannel: string]: TIrcChannel read GetChannelByName;
        property Channels[const aIndex: integer]: TIrcChannel read GetChannelByIndex write SetChannelByIndex;
        property ChannelCount: integer read GetChannelCount;

    published
        property Enabled         : boolean read FEnabled write SetEnabled default True;
        property DetailedTracking: boolean read FDetailedTracking write FDetailedTracking default True;

        property IRC: TIrc read FIrc;
    end;

    { Events }
    TOnIrcEvent        = procedure(aClient: TIrc) of object;
    TOnIrcTextEvent    = procedure(aClient: TIrc; const aText: string) of object;
    TOnIrcRaw          = procedure(aClient: TIrc; const aCmd: string; const aIn: boolean; var aBlockIt: boolean) of object;
    TOnIrcJoin         = procedure(aClient: TIrc; const aNick, aHost, aChannel: string) of object;
    TOnIrcPart         = procedure(aClient: TIrc; const aNick, aHost, aChannel, aReason: string) of object;
    TOnIrcKick         = procedure(aClient: TIrc; const aKicker, aKicked, aChannel, aReason: string) of object;
    TOnIrcKill         = procedure(aClient: TIrc; const aKiller, aKilled, aReason: string) of object;
    TOnIrcQuit         = procedure(aClient: TIrc; const aNick, aHost, aReason: string) of object;
    TOnIrcPrivMsg      = procedure(aClient: TIrc; const aFromNick, aFromHost, aTarget, aText: string) of object;
    TOnIrcServerNotice = procedure(aClient: TIrc; const aSource, aText: string) of object;
    TOnIrcCTCP         = procedure(aClient: TIrc; const aFromNick, aFromHost, aTarget, aCommand, aParameters: string) of object;
    TOnNick            = procedure(aClient: TIrc; const aOldNick, aNewNick, aHost: string) of object;
    TOnMode            = procedure(aClient: TIrc; const aSource, aTarget, aMode: string) of object;
    TOnIrcStatus       = procedure(aClient: TIrc; const aStatus: string) of object;
    TOnIrcError        = procedure(aClient: TIrc; const aError: string) of object;

    { TIrc }
    TIrc = class(TCustomTCPSocket)
    private
        { Settings }
        FNickname           : string;
        FRealname           : string;
        FUsername           : string;
        FPassword           : string;
        FAltNicknames       : TStrings;
        FUserMode           : string;
        FRejoinWhenKicked   : boolean;
        FReconnectWhenKilled: boolean;
    private
        { Workers }
        FIAL          : TIrcIAL;
        FTokenizer    : TTokenizer;
        FParser       : TIrcMsgParser;
        FIncompleteCmd: string;
        { Partial command on incomplete socket recv until next recv. }
    private
        { Events }
        FOnRaw          : TOnIrcRaw;
        FOnServerWelcome: TOnIrcEvent;
        FOnCTCP         : TOnIrcCTCP;
        FOnJoin         : TOnIrcJoin;
        FOnPrivMsg      : TOnIrcPrivMsg;
        FOnNotice       : TOnIrcPrivMsg;
        FOnQuit         : TOnIrcQuit;
        FOnPart         : TOnIrcPart;
        FOnKick         : TOnIrcKick;
        FOnNick         : TOnNick;
        FOnKill         : TOnIrcKill;
        FOnServerNotice : TOnIrcServerNotice;
        FOnMode         : TOnMode;
        { Set/Get }
        procedure SetNickname(const Value: string);
        procedure SetRealName(const Value: string);
        procedure SetUsername(const Value: string);
        procedure SetPassword(const Value: string);
        procedure SetAltNicknames(const Value: TStrings);
        procedure SetUsermode(const Value: string);
        procedure SetRejoinWhenKicked(const Value: boolean);
        procedure SetReconnectWhenKilled(const Value: boolean);
    protected
        { Overriden events }
        procedure EventConnect(const aError: word); override;
        procedure EventClose(const aError: word; const aClosedByRemote: boolean); override;
        procedure EventRead(const aError: word); override;

        { Introduced events }
        procedure EventRaw(const aCmd: string; const aIn: boolean; var aBlockIt: boolean); virtual;
        procedure EventServerWelcome; virtual;
        procedure EventJoin(const aNick, aHost, aChannel: string); virtual;
        procedure EventPart(const aNick, aHost, aChannel, aReason: string); virtual;
        procedure EventKick(const aKicker, aKicked, aChannel, aReason: string); virtual;
        procedure EventQuit(const aNick, aHost, aReason: string); virtual;
        procedure EventKill(const aKiller, aKilled, aReason: string); virtual;
        procedure EventPrivMsg(const aFromNick, aFromHost, aTarget, aText: string); virtual;
        procedure EventNotice(const aFromNick, aFromHost, aTarget, aText: string); virtual;
        procedure EventServerNotice(const aSource, aText: string); virtual;
        procedure EventCTCP(const aFromNick, aFromHost, aTarget, aCommand, aParameters: string); virtual;
        procedure EventNick(const aOldNick, aNewNick, aHost: string); virtual;
        procedure EventMode(const aSource, aTarget, aMode: string); virtual;

        { Funcs }
        procedure ParseCommand(const aLine: string);
    public
        constructor Create(aOwner: TComponent); override;
        destructor Destroy; override;
        procedure Assign(aSource: TPersistent); override;

        procedure Raw(const aText: string);
        { Sends raw text, terminates with CRLF. }

        { IRC Commands }
        procedure CmdJoin(const aChannel: string; const aKey: string = CEmpty);
        procedure CmdPart(const aChannel: string; const aPartMsg: string = CEmpty);
        procedure CmdMsg(const aTarget, aMessage: string);
        procedure CmdNotice(const aTarget, aMessage: string);
        procedure CmdNick(const aNewNickname: string);
        procedure CmdKill(const aNick, aReason: string);
        procedure CmdMode(const aMode: string);
        procedure CmdWho(const aTarget: string; const aOptionalParams: string = CEmpty);
        procedure CmdWhois(const aTarget: string);
    published
        { Inherited Props }
        property AddressFamily;
        property SocketState;
        property ReceiveBufferSize;
        property BindHost;
        property BindPort;
        property RemoteHost;
        property RemotePort;
        property ProxyHost;
        property ProxyPort;
        property ProxyType;
        property SSLType;
        property SSLPrivateKeyFile;
        property SSLCertificateChainFile;
        property SSLTrustedAuthoritiesFile;
        property SSLVerifyCertificate;
        property ConnectTimeout;
        property ConnectRetryDelay;
        property ConnectRetryCount;
        property ReconnectOnError;
        property ReconnectOnClose;

        { Introduced props }
        property Nickname           : string read FNickname write SetNickname;
        property Username           : string read FUsername write SetUsername;
        property Realname           : string read FRealname write SetRealName;
        property Password           : string read FPassword write SetPassword;
        property Usermode           : string read FUserMode write SetUsermode;
        property AltNicknames       : TStrings read FAltNicknames write SetAltNicknames;
        property IAL                : TIrcIAL read FIAL;
        property RejoinWhenKicked   : boolean read FRejoinWhenKicked write SetRejoinWhenKicked default True;
        property ReconnectWhenKilled: boolean read FReconnectWhenKilled write SetReconnectWhenKilled default True;

        { Inherited events }
        property OnResolving;
        property OnResolved;
        property OnConnecting;
        property OnConnectTimeout;
        property OnConnected;
        property OnDisconnected;
        property OnError;

        { Introduced events }
        property OnRaw          : TOnIrcRaw read FOnRaw write FOnRaw;
        property OnServerWelcome: TOnIrcEvent read FOnServerWelcome write FOnServerWelcome;
        property OnJoin         : TOnIrcJoin read FOnJoin write FOnJoin;
        property OnPart         : TOnIrcPart read FOnPart write FOnPart;
        property OnKick         : TOnIrcKick read FOnKick write FOnKick;
        property OnQuit         : TOnIrcQuit read FOnQuit write FOnQuit;
        property OnKill         : TOnIrcKill read FOnKill write FOnKill;
        property OnPrivMsg      : TOnIrcPrivMsg read FOnPrivMsg write FOnPrivMsg;
        property OnNotice       : TOnIrcPrivMsg read FOnNotice write FOnNotice;
        property OnServerNotice : TOnIrcServerNotice read FOnServerNotice write FOnServerNotice;
        property OnCTCP         : TOnIrcCTCP read FOnCTCP write FOnCTCP;
        property OnNick         : TOnNick read FOnNick write FOnNick;
        property OnMode         : TOnMode read FOnMode write FOnMode;
    end;

function SplitNickAndChanmodes(const aText: string; var aChanModes: TIrcChanModes; var aNickname: string): boolean;

implementation

function SplitNickAndChanmodes(const aText: string; var aChanModes: TIrcChanModes; var aNickname: string): boolean;
var
    i: integer;
    l: integer;
begin
    l := Length(aText);
    if (l = 0) then
        Exit(False)
    else
    begin
        i          := 1;
        aChanModes := [];
        aNickname  := CEmpty;
    end;

    while (i <= l) do
    begin
        if (aText[i] = '~') then
            Include(aChanModes, cmOwner)
        else
            if (aText[i] = '&') then
                Include(aChanModes, cmAdmin)
            else
                if (aText[i] = '@') then
                    Include(aChanModes, cmOperator)
                else
                    if (aText[i] = '%') then
                        Include(aChanModes, cmHelper)
                    else
                        if (aText[i] = '+') then
                            Include(aChanModes, cmVoice)
                        else
                        begin
                            aNickname := TextCopy(aText, i, MaxInt);
                            Exit(True);
                        end;
        Inc(i);
    end;
end;

{ TELIrc.TELIrcMsgParser }

constructor TIrcMsgParser.Create;
begin
    Clear;
end;

destructor TIrcMsgParser.Destroy;
begin
    Clear;
    inherited;
end;

procedure TIrcMsgParser.AddParam(const aStart, aLength: integer);
begin
    Inc(FParamCount);
    SetLength(FParamsArray, FParamCount);
    FParamsArray[FParamCount - 1].Start  := aStart;
    FParamsArray[FParamCount - 1].Length := aLength;
end;

procedure TIrcMsgParser.AddTrailing(const aStart, aLength: integer);
begin
    Inc(FTrailingCount);
    SetLength(FTrailingsArray, FTrailingCount);
    FTrailingsArray[FTrailingCount - 1].Start  := aStart;
    FTrailingsArray[FTrailingCount - 1].Length := aLength;
end;

procedure TIrcMsgParser.Clear;
begin
    FRaw := CEmpty;

    FSourceType    := stNotPresent;
    FSource.Start  := 0;
    FSource.Length := 0;

    FSourceNickName.Start  := 0;
    FSourceNickName.Length := 0;
    FSourceUserName.Start  := 0;
    FSourceUserName.Length := 0;
    FSourceHostName.Start  := 0;
    FSourceHostName.Length := 0;

    FCommand.Start  := 0;
    FCommand.Length := 0;

    FParams.Start  := 0;
    FParams.Length := 0;
    SetLength(FParamsArray, 0);
    FParamCount := 0;

    FTrailings.Start  := 0;
    FTrailings.Length := 0;
    SetLength(FTrailingsArray, 0);
    FTrailingCount := 0;
end;

function TIrcMsgParser.Parse(const aRaw: string): boolean;
var
    a: integer; // Copy start/Last Copy end position.
    b: integer; // Parse cursor.
    t: integer; // Temp cursor.
    l: integer; // Length of input string.

    function DoTrim: boolean;
    begin
        Result := False;
        while (b <= l) do
        begin
            if (b > l) then
                Exit(False);
            if (FRaw[b] <= CSpace) then
                Inc(b)
            else
            begin
                a := b;
                Exit(True);
            end;
        end;
    end;

    function FindSpace: boolean;
    begin
        b      := TextPos(FRaw, CSpace, True, b);
        Result := (b <> 0);
    end;

begin
    // <message> ::=
    //
    // [':' <prefix> <SPACE> ] <command> <Trailing> <crlf>
    //
    // <prefix> ::=
    // <servername> | <nick> [ '!' <user> ] [ '@' <host> ]
    //
    // <command> ::=
    // <letter> { <letter> } | <number> <number> <number>
    //
    // <SPACE> ::=
    // ' ' { ' ' }
    //
    // <Trailing> ::=
    // <SPACE> [ ':' <Trailings> | <middle> <Trailing> ]
    //
    // <middle> ::=
    // <Any *non-empty* sequence of octets not including SPACE or NUL or CR or LF, the first of which may not be ':'>
    //
    // <Trailings> ::=
    // <Any, possibly *empty*, sequence of octets not including NUL or CR or LF>
    //
    // <crlf> ::=
    // CR LF

    { Check and initialize }
    Result := False;
    l      := Length(aRaw);
    if (l = 0) then
        Exit;

    Clear;
    FRaw := aRaw;
    a    := 1;
    b    := 1;

    if (DoTrim = False) then
        Exit;

    { Optional Message Source Prefix. }
    if (FRaw[b] = CColon) then
    begin
        if (FindSpace = False) then
            Exit;

        Inc(a);
        FSource.Start  := a;
        FSource.Length := (b - a);

        { If msg source is an user, split it to <nick>!<user>@<host>. }
        t := TextPos(FRaw, CExclam, True, a);
        if (t > 0) and (t < b) then
        begin
            FSourceNickName.Start  := a;
            FSourceNickName.Length := (t - a);

            a := t;
            Inc(a);
            t := TextPos(FRaw, CMonkey, True, a);
            if (t > 0) and (t < b) then
            begin
                FSourceUserName.Start  := a;
                FSourceUserName.Length := (t - a);

                a := t;
                Inc(a);
                t := TextPos(FRaw, CSpace, True, a);
                if (t = b) then
                begin
                    FSourceHostName.Start  := a;
                    FSourceHostName.Length := (t - a);

                    FSourceType := stUser;
                end;
            end;
        end
        else
            FSourceType := stServer;

        a := b;

        { Trim }
        if (DoTrim = False) then
            Exit;
    end;

    { Parse out command }
    if (FindSpace) then
    begin
        FCommand.Start  := a;
        FCommand.Length := (b - a);

        a := b;
        { If no params, exit. }
        if (DoTrim = False) then
            Exit(True);
    end
    else
    begin
        { If no params, exit }
        FCommand.Start  := a;
        FCommand.Length := (l - a);
        Exit(True);
    end;

    { Parse parameters }

    { If there are trailing params, parse middle first }
    t := TextPos(FRaw, CColon, True, a);
    if (t <> 0) then
    begin
        FParams.Start  := a;
        FParams.Length := (t - a);
        // Get the pre-Trailings params.
        while (b < t) and (FindSpace) do
        begin
            AddParam(a, b - a);
            Inc(b);
            a := b;
        end;

        // If no space before Trailings colon..
        if (a < t) then
            AddParam(a, t - a);

        // Move cursor to start of Trailings.
        a := t + 1;
        b := a;
    end
    else
    begin
        FParams.Start  := a;
        FParams.Length := (l + 1 - a);
    end;

    if (t <> 0) then
    begin
        FTrailings.Start  := t + 1;
        FTrailings.Length := (l + 1 - a);
    end;

    while (FindSpace) do
    begin
        if (t <> 0) then
            AddTrailing(a, b - a)
        else
            AddParam(a, b - a);
        Inc(b);
        a := b;
    end;

    // Last chunk.
    if (b < l) then
    begin
        if (t <> 0) then
            AddTrailing(a, MaxInt)
        else
            AddParam(a, MaxInt);
    end;

    // Done.
    Result := True;
end;

function TIrcMsgParser.Source: string;
begin
    if (FSource.Length = 0) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FSource.Start, FSource.Length);
end;

function TIrcMsgParser.SourceNickName: string;
begin
    if (FSourceNickName.Length = 0) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FSourceNickName.Start, FSourceNickName.Length);
end;

function TIrcMsgParser.SourceUserName: string;
begin
    if (FSourceUserName.Length = 0) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FSourceUserName.Start, FSourceUserName.Length);
end;

function TIrcMsgParser.SourceHostName: string;
begin
    if (FSourceHostName.Length = 0) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FSourceHostName.Start, FSourceHostName.Length);
end;

function TIrcMsgParser.Command: string;
begin
    if (FCommand.Length = 0) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FCommand.Start, FCommand.Length);
end;

function TIrcMsgParser.Params: string;
begin
    if (FParams.Length = 0) then
        Result := CEmpty
    else
        Result := Trim(TextCopy(FRaw, FParams.Start, FParams.Length));
end;

function TIrcMsgParser.ParamsFrom(const aIndex: integer): string;
begin
    if (aIndex < 0) or (aIndex >= FParamCount) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FParamsArray[aIndex].Start, MaxInt);
end;

function TIrcMsgParser.Trailings: string;
begin
    if (FTrailings.Length = 0) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FTrailings.Start, FTrailings.Length);
end;

function TIrcMsgParser.TrailingsFrom(const aIndex: integer): string;
begin
    if (aIndex < 0) or (aIndex >= FTrailingCount) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FTrailingsArray[aIndex].Start, MaxInt);
end;

function TIrcMsgParser.AllParams: string;
begin
    if (FParams.Length > 0) then
        Result := Params
    else
        Result := CEmpty;

    if (FParams.Length > 0) then
    begin
        if (FTrailings.Length > 0) then
            Result := Result + CSpace + Trailings;
    end
    else
    begin
        if (FTrailings.Length > 0) then
            Result := Trailings;
    end;
end;

function TIrcMsgParser.GetParam(aIndex: integer): string;
begin
    if (aIndex < 0) or (aIndex >= FParamCount) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FParamsArray[aIndex].Start, FParamsArray[aIndex].Length);
end;

function TIrcMsgParser.GetTrailing(aIndex: integer): string;
begin
    if (aIndex < 0) or (aIndex >= FTrailingCount) then
        Result := CEmpty
    else
        Result := TextCopy(FRaw, FTrailingsArray[aIndex].Start, FTrailingsArray[aIndex].Length);
end;

{ TIrcNickname }

function TIrcNickname.GetHostMask: string;
begin
    if (FNickname = CEmpty) or (FUsername = CEmpty) or (FHostname = CEmpty) then
        Exit(CEmpty);

    Result := FNickname + CExclam + FUsername + CMonkey + FHostname;
end;

procedure TIrcNickname.Assign(aSource: TIrcNickname);
begin

end;

constructor TIrcNickname.Create(aList: TIrcNicknameList);
begin
    FNicknameList := aList;

    FIdentified := False;
    FIrcOp      := False;
    FBot        := False;
    FAway       := False;
    FHops       := 0;
end;

destructor TIrcNickname.Destroy;
begin

    inherited;
end;

procedure TIrcNickname.UpdateHostmask(const aHostmask: string);
begin

end;

function TIrcNickname.GetHostMask(const aType: byte): string;
begin
    if (FNickname = CEmpty) or (FUsername = CEmpty) or (FHostname = CEmpty) then
        Exit(CEmpty);

    case aType of
        0:
        Result := FNickname + CExclam + CAsterisk + CMonkey + CAsterisk;
        // nick!*@*
        1:
        Result := CAsterisk + CExclam + FUsername + CMonkey + CAsterisk;
        // *!user@*
        2:
        Result := CAsterisk + CExclam + CAsterisk + CMonkey + FHostname;
        // *!*@host
        3:
        Result := FNickname + CExclam + FUsername + CMonkey + CAsterisk;
        // nick!user@*
        4:
        Result := CAsterisk + CExclam + FUsername + CMonkey + FHostname;
        // *!user@host
        5:
        Result := FNickname + CExclam + CAsterisk + CMonkey + FHostname;
        // nick!*@host
        else
        Result := FNickname + CExclam + FUsername + CMonkey + FHostname;
        // nick!user@host
    end;
end;

function TIrcNickname.IsAdmin(const aChannel: string): boolean;
begin

end;

function TIrcNickname.IsChanop(const aChannel: string): boolean;
begin

end;

function TIrcNickname.IsHelper(const aChannel: string): boolean;
begin

end;

function TIrcNickname.IsIdentified(const aNick: string): boolean;
begin

end;

function TIrcNickname.IsOnChannel(const aChannel: string): boolean;
begin

end;

function TIrcNickname.IsOwner(const aChannel: string): boolean;
begin

end;

function TIrcNickname.IsRegular(const aChannel: string): boolean;
begin

end;

function TIrcNickname.IsVoice(const aChannel: string): boolean;
begin

end;

procedure TIrcNickname.SetHostname(const Value: string);
begin
    FHostname := Value;
end;

procedure TIrcNickname.SetNickname(const Value: string);
begin
    FNickname := Value;
end;

procedure TIrcNickname.SetRealName(const Value: string);
begin
    FRealname := Value;
end;

procedure TIrcNickname.SetUsermode(const Value: string);
begin
    FUserMode := Value;
end;

procedure TIrcNickname.SetUsername(const Value: string);
begin
    FUsername := Value;
end;

{ TIrcNicknameList }

constructor TIrcNicknameList.Create(aIAL: TIrcIAL);
begin
    FIAL   := aIAL;
    FCount := 0;
end;

destructor TIrcNicknameList.Destroy;
begin
    Clear;
    inherited;
end;

function TIrcNicknameList.Add(const aNickname: string): TIrcNickname;
var
    nick       : TIrcNickname;
    insertIndex: integer;
begin
    insertIndex := GetInsertIndex(aNickname);
    if (insertIndex = -1) then
    begin
        FIAL.FIrc.EventError(Format('TIrcNicknameList.Add: Failed to add nickname "%s". Already exists.', [aNickname]));
        Exit;
    end;

    nick          := TIrcNickname.Create(Self);
    nick.Nickname := aNickname;

    SetLength(FNicknames, FCount + 1);
    if (insertIndex < FCount) then
        System.Move(FNicknames[insertIndex], FNicknames[insertIndex + 1], (FCount - insertIndex) * SizeOf(TIrcNickname));
    FNicknames[insertIndex] := nick;
    Inc(FCount);
    Result := nick;
    FIAL.IRC.CmdWho(aNickname);
    if (FIAL.DetailedTracking) then
        FIAL.IRC.CmdWhois(aNickname);
end;

procedure TIrcNicknameList.Del(const aNickname: string);
var
    idx: integer;
begin
    idx := IndexOf(aNickname);
    if (idx <> -1) then
    begin
        Dec(FCount);
        if (idx < FCount) then
            System.Move(FNicknames[idx + 1], FNicknames[idx], (FCount - idx) * SizeOf(TIrcNickname));
        SetLength(FNicknames, FCount);
    end;
end;

function TIrcNicknameList.IndexOf(const aNickname: string): integer;
var
    lowIndex    : integer;
    highIndex   : integer;
    centerIndex : integer;
    compareValue: integer;
begin
    lowIndex  := 0;
    highIndex := FCount - 1;

    while (lowIndex <= highIndex) do
    begin
        centerIndex  := (lowIndex + highIndex) div 2;
        compareValue := CompareText(aNickname, FNicknames[centerIndex].Nickname);

        if (compareValue < 0) then
        begin
            highIndex := centerIndex - 1;
        end
        else
        begin
            if (compareValue = 0) then
            begin
                Exit(centerIndex);
            end
            else
            begin
                if (compareValue > 0) then
                    lowIndex := centerIndex + 1;
            end;
        end;
    end;
    Result := -1;
end;

function TIrcNicknameList.Find(const aNickname: string): TIrcNickname;
var
    idx: integer;
begin
    idx := IndexOf(aNickname);
    if (idx = -1) then
        Result := nil
    else
        Result := FNicknames[idx];
end;

procedure TIrcNicknameList.Sort;
begin
    QuickSort(0, FCount - 1);
end;

procedure TIrcNicknameList.Clear;
var
    i: integer;
begin
    for i := 0 to FCount - 1 do
        FNicknames[i].Free;
    SetLength(FNicknames, 0);
    FCount := 0;
end;

procedure TIrcNicknameList.Exchange(aIndexA, aIndexB: integer);
var
    temp: TIrcNickname;
begin
    temp                := FNicknames[aIndexB];
    FNicknames[aIndexB] := FNicknames[aIndexA];
    FNicknames[aIndexA] := temp;
end;

procedure TIrcNicknameList.QuickSort(aStart, aEnd: integer);
var
    a: integer;
    i: integer;
    j: integer;
    p: integer;
begin
    if (FCount <= 1) then
        Exit;
    a := aStart;
    repeat
        i := a;
        j := aEnd;
        p := (a + aEnd) shr 1;
        repeat
            while (CompareText(FNicknames[i].Nickname, FNicknames[p].Nickname) < 0) do
                Inc(i);
            while (CompareText(FNicknames[j].Nickname, FNicknames[p].Nickname) > 0) do
                Dec(j);
            if (i <= j) then
            begin
                if (i <> j) then
                    Exchange(i, j);
                if (p = i) then
                    p := j
                else
                    if (p = j) then
                        p := i;
                Inc(i);
                Dec(j);
            end;
        until (i > j);
        if (a < j) then
            QuickSort(a, j);
        a := i;
    until (i >= aEnd);
end;

function TIrcNicknameList.GetInsertIndex(const aNickname: string): integer;
var
    lowIndex    : integer;
    highIndex   : integer;
    centerIndex : integer;
    compareValue: integer;
begin
    lowIndex  := 0;
    highIndex := FCount - 1;

    while (lowIndex <= highIndex) do
    begin
        centerIndex  := (lowIndex + highIndex) div 2;
        compareValue := CompareText(aNickname, FNicknames[centerIndex].Nickname);

        if (compareValue < 0) then
        begin
            highIndex := centerIndex - 1;
        end
        else
        begin
            if (compareValue = 0) then
            begin
                Result := -1;
                FIAL.FIrc.EventError('TIrcNicknameList.GetInsertIndex: Nickname already exists.');
                Exit;
            end
            else
            begin
                if (compareValue > 0) then
                    lowIndex := centerIndex + 1;
            end;
        end;
    end;
    Result := lowIndex;
end;

{ TIrcChannelNickname }

constructor TIrcChannelNickname.Create(aList: TIrcChannelNicknameList);
begin
    FChannelNicknameList := aList;
    FNickname            := nil;
    FChanModes           := [];
end;

procedure TIrcChannelNickname.Assign(aSource: TIrcChannelNickname);
begin
    Nickname  := aSource.Nickname;
    ChanModes := aSource.ChanModes;
end;

{ TIrcChannelNicknameList }

constructor TIrcChannelNicknameList.Create(aChannel: TIrcChannel);
begin
    FChannel := aChannel;
    FCount   := 0;
end;

destructor TIrcChannelNicknameList.Destroy;
begin
    Clear;
    inherited;
end;

function TIrcChannelNicknameList.Add(aNickname: TIrcNickname; const aChanModes: TIrcChanModes): TIrcChannelNickname;
var
    nick       : TIrcChannelNickname;
    insertIndex: integer;
begin
    insertIndex := GetInsertIndex(aNickname.Nickname);
    if (insertIndex = -1) then
    begin
        Channel.FChannelList.IAL.FIrc.EventError('TIrcChannelNicknameList.Add: Failed to add nickname. Already exists.');
        Exit;
    end;

    nick           := TIrcChannelNickname.Create(Self);
    nick.Nickname  := aNickname;
    nick.ChanModes := aChanModes;

    SetLength(FNicknames, FCount + 1);
    if (insertIndex < FCount) then
        System.Move(FNicknames[insertIndex], FNicknames[insertIndex + 1], (FCount - insertIndex) * SizeOf(TIrcChannelNickname));
    FNicknames[insertIndex] := nick;
    Inc(FCount);
    Result := nick;
end;

procedure TIrcChannelNicknameList.Del(const aNickname: string);
var
    idx: integer;
begin
    idx := IndexOf(aNickname);
    if (idx <> -1) then
    begin
        Dec(FCount);
        if (idx < FCount) then
            System.Move(FNicknames[idx + 1], FNicknames[idx], (FCount - idx) * SizeOf(TIrcChannelNickname));
        SetLength(FNicknames, FCount);
    end;
end;

function TIrcChannelNicknameList.IndexOf(const aNickname: string): integer;
var
    lowIndex    : integer;
    highIndex   : integer;
    centerIndex : integer;
    compareValue: integer;
begin
    lowIndex  := 0;
    highIndex := FCount - 1;

    while (lowIndex <= highIndex) do
    begin
        centerIndex  := (lowIndex + highIndex) div 2;
        compareValue := CompareText(aNickname, FNicknames[centerIndex].Nickname.Nickname);

        if (compareValue < 0) then
        begin
            highIndex := centerIndex - 1;
        end
        else
        begin
            if (compareValue = 0) then
            begin
                Exit(centerIndex);
            end
            else
            begin
                if (compareValue > 0) then
                    lowIndex := centerIndex + 1;
            end;
        end;
    end;
    Result := -1;
end;

function TIrcChannelNicknameList.Find(const aNickname: string): TIrcChannelNickname;
var
    idx: integer;
begin
    idx := IndexOf(aNickname);
    if (idx = -1) then
        Result := nil
    else
        Result := FNicknames[idx];
end;

procedure TIrcChannelNicknameList.Sort;
begin
    QuickSort(0, FCount - 1);
end;

procedure TIrcChannelNicknameList.Clear;
var
    i: integer;
begin
    for i := 0 to FCount - 1 do
        FNicknames[i].Free;
    SetLength(FNicknames, 0);
    FCount := 0;
end;

procedure TIrcChannelNicknameList.Exchange(aIndexA, aIndexB: integer);
var
    temp: TIrcChannelNickname;
begin
    temp                := FNicknames[aIndexB];
    FNicknames[aIndexB] := FNicknames[aIndexA];
    FNicknames[aIndexA] := temp;
end;

procedure TIrcChannelNicknameList.QuickSort(aStart, aEnd: integer);
var
    a: integer;
    i: integer;
    j: integer;
    p: integer;
begin
    if (FCount <= 1) then
        Exit;
    a := aStart;
    repeat
        i := a;
        j := aEnd;
        p := (a + aEnd) shr 1;
        repeat
            while (CompareText(FNicknames[i].Nickname.Nickname, FNicknames[p].Nickname.Nickname) < 0) do
                Inc(i);
            while (CompareText(FNicknames[j].Nickname.Nickname, FNicknames[p].Nickname.Nickname) > 0) do
                Dec(j);
            if (i <= j) then
            begin
                if (i <> j) then
                    Exchange(i, j);
                if (p = i) then
                    p := j
                else
                    if (p = j) then
                        p := i;
                Inc(i);
                Dec(j);
            end;
        until (i > j);
        if (a < j) then
            QuickSort(a, j);
        a := i;
    until (i >= aEnd);
end;

function TIrcChannelNicknameList.GetInsertIndex(const aNickname: string): integer;
var
    lowIndex    : integer;
    highIndex   : integer;
    centerIndex : integer;
    compareValue: integer;
begin
    lowIndex  := 0;
    highIndex := FCount - 1;

    while (lowIndex <= highIndex) do
    begin
        centerIndex  := (lowIndex + highIndex) div 2;
        compareValue := CompareText(aNickname, FNicknames[centerIndex].Nickname.Nickname);

        if (compareValue < 0) then
        begin
            highIndex := centerIndex - 1;
        end
        else
        begin
            if (compareValue = 0) then
            begin
                Result := -1;
                Channel.FChannelList.IAL.FIrc.EventError('TIrcChannelNicknameList.GetInsertIndex: Nickname already exists.');
                Exit;
            end
            else
            begin
                if (compareValue > 0) then
                    lowIndex := centerIndex + 1;
            end;
        end;
    end;
    Result := lowIndex;
end;

function TIrcChannelNicknameList.GetNickname(const aIndex: integer): TIrcChannelNickname;
begin
    if (aIndex < 0) or (aIndex >= FCount) then
    begin
        FChannel.FChannelList.FIAL.FIrc.EventError(Format('TIrcChannelNicknameList.GetNickname(%d) out of bounds(%d).', [aIndex, FCount]));
        Exit(nil);
    end;
    Result := FNicknames[aIndex];
end;

procedure TIrcChannelNicknameList.SetNickname(const aIndex: integer; const Value: TIrcChannelNickname);
begin
    if (aIndex < 0) or (aIndex >= FCount) then
    begin
        FChannel.FChannelList.FIAL.FIrc.EventError(Format('TIrcChannelNicknameList.SetNickname(%d) out of bounds(%d).', [aIndex, FCount]));
        Exit;
    end;
    FNicknames[aIndex].Assign(Value);
end;

{ TIrcChannel }

constructor TIrcChannel.Create(aList: TIrcChannelList);
begin
    FChannelList         := aList;
    FChannelNicknameList := TIrcChannelNicknameList.Create(Self);
end;

destructor TIrcChannel.Destroy;
begin
    FChannelNicknameList.Free;
    inherited;
end;

procedure TIrcChannel.Assign(aSource: TIrcChannel);
begin

end;

{ TIrcChannelList }

constructor TIrcChannelList.Create(aIAL: TIrcIAL);
begin
    FIAL   := aIAL;
    FCount := 0;
end;

destructor TIrcChannelList.Destroy;
begin
    Clear;
    inherited;
end;

function TIrcChannelList.Add(const aChannel: string): TIrcChannel;
var
    Channel    : TIrcChannel;
    insertIndex: integer;
begin
    insertIndex := GetInsertIndex(aChannel);
    if (insertIndex = -1) then
    begin
        FIAL.FIrc.EventError('TIrcChannelList.Add: Failed to add channel. Already exists.');
        Exit;
    end;

    Channel             := TIrcChannel.Create(Self);
    Channel.ChannelName := aChannel;

    SetLength(FChannels, FCount + 1);
    if (insertIndex < FCount) then
        System.Move(FChannels[insertIndex], FChannels[insertIndex + 1], (FCount - insertIndex) * SizeOf(TIrcChannel));
    FChannels[insertIndex] := Channel;
    Inc(FCount);
    Result := Channel;
end;

procedure TIrcChannelList.Del(const aChannel: string);
var
    idx: integer;
begin
    idx := IndexOf(aChannel);
    if (idx <> -1) then
    begin
        Dec(FCount);
        if (idx < FCount) then
            System.Move(FChannels[idx + 1], FChannels[idx], (FCount - idx) * SizeOf(TIrcChannel));
        SetLength(FChannels, FCount);
    end;
end;

function TIrcChannelList.IndexOf(const aChannel: string): integer;
var
    lowIndex    : integer;
    highIndex   : integer;
    centerIndex : integer;
    compareValue: integer;
begin
    lowIndex  := 0;
    highIndex := FCount - 1;

    while (lowIndex <= highIndex) do
    begin
        centerIndex  := (lowIndex + highIndex) div 2;
        compareValue := CompareText(aChannel, FChannels[centerIndex].ChannelName);

        if (compareValue < 0) then
        begin
            highIndex := centerIndex - 1;
        end
        else
        begin
            if (compareValue = 0) then
            begin
                Exit(centerIndex);
            end
            else
            begin
                if (compareValue > 0) then
                    lowIndex := centerIndex + 1;
            end;
        end;
    end;
    Result := -1;
end;

function TIrcChannelList.Find(const aChannel: string): TIrcChannel;
var
    idx: integer;
begin
    idx := IndexOf(aChannel);
    if (idx = -1) then
        Result := nil
    else
        Result := FChannels[idx];
end;

procedure TIrcChannelList.Sort;
begin
    QuickSort(0, FCount - 1);
end;

procedure TIrcChannelList.Clear;
var
    i: integer;
begin
    for i := 0 to FCount - 1 do
        FChannels[i].Free;
    SetLength(FChannels, 0);
    FCount := 0;
end;

procedure TIrcChannelList.Exchange(aIndexA, aIndexB: integer);
var
    temp: TIrcChannel;
begin
    temp               := FChannels[aIndexB];
    FChannels[aIndexB] := FChannels[aIndexA];
    FChannels[aIndexA] := temp;
end;

procedure TIrcChannelList.QuickSort(aStart, aEnd: integer);
var
    a: integer;
    i: integer;
    j: integer;
    p: integer;
begin
    if (FCount <= 1) then
        Exit;
    a := aStart;
    repeat
        i := a;
        j := aEnd;
        p := (a + aEnd) shr 1;
        repeat
            while (CompareText(FChannels[i].ChannelName, FChannels[p].ChannelName) < 0) do
                Inc(i);
            while (CompareText(FChannels[j].ChannelName, FChannels[p].ChannelName) > 0) do
                Dec(j);
            if (i <= j) then
            begin
                if (i <> j) then
                    Exchange(i, j);
                if (p = i) then
                    p := j
                else
                    if (p = j) then
                        p := i;
                Inc(i);
                Dec(j);
            end;
        until (i > j);
        if (a < j) then
            QuickSort(a, j);
        a := i;
    until (i >= aEnd);
end;

function TIrcChannelList.GetInsertIndex(const aChannel: string): integer;
var
    lowIndex    : integer;
    highIndex   : integer;
    centerIndex : integer;
    compareValue: integer;
begin
    lowIndex  := 0;
    highIndex := FCount - 1;

    while (lowIndex <= highIndex) do
    begin
        centerIndex  := (lowIndex + highIndex) div 2;
        compareValue := CompareText(aChannel, FChannels[centerIndex].ChannelName);

        if (compareValue < 0) then
        begin
            highIndex := centerIndex - 1;
        end
        else
        begin
            if (compareValue = 0) then
            begin
                Result := -1;
                FIAL.FIrc.EventError('TIrcChannelList.GetInsertIndex: Channel already exists.');
                Exit;
            end
            else
            begin
                if (compareValue > 0) then
                    lowIndex := centerIndex + 1;
            end;
        end;
    end;
    Result := lowIndex;
end;

{ TIrcIAL }

constructor TIrcIAL.Create(aIrc: TIrc);
begin
    FIrc := aIrc;

    FTokenizer := TTokenizer.Create;

    FNicknameList     := TIrcNicknameList.Create(Self);
    FChannelList      := TIrcChannelList.Create(Self);
    FEnabled          := True;
    FDetailedTracking := True;
end;

destructor TIrcIAL.Destroy;
begin
    FChannelList.Free;
    FNicknameList.Free;
    Clear;
    FTokenizer.Free;
end;

procedure TIrcIAL.Clear;
begin
    FNicknameList.Clear;
    FChannelList.Clear;
end;

procedure TIrcIAL.NickJoinedChannel(const aNickname, aHostmask, aChannel: string);
var
    nick    : TIrcNickname;
    chan    : TIrcChannel;
    channick: TIrcChannelNickname;
begin
    nick := FNicknameList.Find(aNickname);
    if (nick = nil) then
        nick := FNicknameList.Add(aNickname);
    nick.UpdateHostmask(aHostmask);

    chan := FChannelList.Find(aChannel);
    if (chan = nil) then
        chan := FChannelList.Add(aChannel);

    channick := chan.Nicknames.Find(aNickname);
    if (channick <> nil) then
        Exit;

    channick := chan.Nicknames.Add(nick);
end;

procedure TIrcIAL.NickPartedChannel(const aNickname, aChannel: string);
var
    chan: TIrcChannel;
begin
    chan := FChannelList.Find(aChannel);
    if (chan = nil) then
        chan := FChannelList.Add(aChannel);

    chan.Nicknames.Del(aNickname);

    if (chan.Nicknames.Count = 0) then
        FChannelList.Del(chan.ChannelName);
end;

procedure TIrcIAL.NickChange(const aOldNickname, aNewNickname: string);
var
    nick: TIrcNickname;
    i   : integer;
begin
    nick := FNicknameList.Find(aOldNickname);
    if (nick = nil) then
        nick := FNicknameList.Add(aOldNickname);

    nick.Nickname := aNewNickname;

    FNicknameList.Sort;
    for i := 0 to FChannelList.FCount - 1 do
        FChannelList.FChannels[i].Nicknames.Sort;
end;

procedure TIrcIAL.NickIsIdentified(const aNickname: string);
var
    nick: TIrcNickname;
begin
    nick := FNicknameList.Find(aNickname);
    if (nick <> nil) then
        nick.Identified := True;
end;

procedure TIrcIAL.NickKickedFromChannel(const aNickname, aChannel: string);
begin
    NickPartedChannel(aNickname, aChannel);
end;

procedure TIrcIAL.NickQuit(const aNickname: string);
var
    i: integer;
begin
    FNicknameList.Del(aNickname);
    for i := 0 to FChannelList.FCount - 1 do
        FChannelList.FChannels[i].Nicknames.Del(aNickname);
end;

procedure TIrcIAL.NamesList(const aChannel, aNamesList: string);
var
    tkn    : TTokenizer;
    i      : integer;
    nick   : TIrcNickname;
    chan   : TIrcChannel;
    channick: TIrcChannelNickname;
    nickstr: string;
    chmode : TIrcChanModes;
begin
    chan := FChannelList.Find(aChannel);
    if (chan = nil) then
        FChannelList.Add(aChannel);

    FTokenizer.Split(aNamesList, CSpace, [soCSSep]);
    for i := 0 to FTokenizer.Count - 1 do
    begin
        SplitNickAndChanmodes(FTokenizer[i], chmode, nickstr);
        nick := FNicknameList.Find(nickstr);
        if (nick = nil) then
            nick := FNicknameList.Add(nickstr);
        channick := chan.Nicknames.Find(nickstr);
        if (channick = nil) then
            chan.Nicknames.Add(nick, chmode)
        else
            channick.ChanModes := chmode;
    end;
end;

function TIrcIAL.IsNicknameIdentified(const aNickname: string): boolean;
var
    nick: TIrcNickname;
begin
    nick := FNicknameList.Find(aNickname);
    if (nick <> nil) then
        Result := nick.Identified
    else
        Result := False;
end;

function TIrcIAL.GetNicknameByName(const aNickname: string): TIrcNickname;
begin
    Result := FNicknameList.Find(aNickname);
end;

function TIrcIAL.GetNicknameByIndex(const aIndex: integer): TIrcNickname;
begin
    if (aIndex < 0) or (aIndex >= FNicknameList.FCount) then
    begin
        IRC.EventError(Format('TIrcIAL.GetNicknameByIndex(%d) out of bounds(%d).', [aIndex, FNicknameList.FCount]));
        Exit(nil);
    end;
    Result := FNicknameList.FNicknames[aIndex];
end;

function TIrcIAL.GetNicknameCount: integer;
begin
    Result := FNicknameList.FCount;
end;

function TIrcIAL.GetChannelByName(const aChannel: string): TIrcChannel;
begin
    Result := FChannelList.Find(aChannel);
end;

function TIrcIAL.GetChannelByIndex(const aIndex: integer): TIrcChannel;
begin
    if (aIndex < 0) or (aIndex >= FChannelList.FCount) then
    begin
        IRC.EventError(Format('TIrcIAL.GetChannelByIndex(%d) out of bounds(%d).', [aIndex, FChannelList.FCount]));
        Exit(nil);
    end;
    Result := FChannelList.FChannels[aIndex];
end;

function TIrcIAL.GetChannelCount: integer;
begin
    Result := FChannelList.FCount;
end;

procedure TIrcIAL.SetNicknameByIndex(const aIndex: integer; const Value: TIrcNickname);
begin
    if (aIndex < 0) or (aIndex >= FNicknameList.FCount) then
    begin
        IRC.EventError(Format('TIrcIAL.SetNicknameByIndex(%d) out of bounds(%d).', [aIndex, FNicknameList.FCount]));
        Exit;
    end;
    FNicknameList.FNicknames[aIndex].Assign(Value);
end;

procedure TIrcIAL.WhoText(const aText: string);
var
    nick: TIrcNickname;
begin
    FTokenizer.Split(aText, CSpace, [soCSSep]);
    nick := FNicknameList.Find(FTokenizer[4]);
    if (nick = nil) then
        Exit;

    nick.Username := FTokenizer[1];
    nick.Hostname := FTokenizer[2];
    nick.Leaf     := FTokenizer[3];
    if (TextInText(FTokenizer[5], 'G', True)) then
        nick.Away := True;
    if (TextInText(FTokenizer[5], '*', True)) then
        nick.IrcOp := True;
    nick.Hops      := StrToIntDef(TextRight(FTokenizer[6], Length(FTokenizer[6]) - 1), 0);
    nick.Realname  := FTokenizer.FromToken(7);
end;

procedure TIrcIAL.SetChannelByIndex(const aIndex: integer; const Value: TIrcChannel);
begin
    if (aIndex < 0) or (aIndex >= FChannelList.FCount) then
    begin
        IRC.EventError(Format('TIrcIAL.SetChannelByIndex(%d) out of bounds(%d).', [aIndex, FChannelList.FCount]));
        Exit;
    end;
    FChannelList.FChannels[aIndex].Assign(Value);
end;

procedure TIrcIAL.SetEnabled(const Value: boolean);
begin
    if (FEnabled = Value) then
        Exit;
    FEnabled := Value;
end;

{ TIrc }

constructor TIrc.Create(aOwner: TComponent);
begin
    inherited Create(aOwner);
    FAltNicknames := TStringList.Create;
    FTokenizer    := TTokenizer.Create;
    FParser       := TIrcMsgParser.Create;
    FUserMode     := '+ix';

    FIAL := TIrcIAL.Create(Self);

    FRejoinWhenKicked    := True;
    FReconnectWhenKilled := True;
end;

destructor TIrc.Destroy;
begin
    FIAL.Free;
    FAltNicknames.Free;
    FParser.Free;
    FTokenizer.Free;
    inherited;
end;

procedure TIrc.Assign(aSource: TPersistent);
begin
    if (aSource is TIrc) then
    begin
        Nickname            := TIrc(aSource).Nickname;
        Username            := TIrc(aSource).Username;
        Realname            := TIrc(aSource).Realname;
        Password            := TIrc(aSource).Password;
        Usermode            := TIrc(aSource).Usermode;
        RejoinWhenKicked    := TIrc(aSource).RejoinWhenKicked;
        ReconnectWhenKilled := TIrc(aSource).ReconnectWhenKilled;
        AltNicknames.Assign(TIrc(aSource).AltNicknames);
    end
    else
        inherited;
end;

procedure TIrc.EventClose(const aError: word; const aClosedByRemote: boolean);
begin
    inherited;
    FIAL.Clear;
end;

procedure TIrc.EventConnect(const aError: word);
begin
    inherited;

    { Client Registration }
    if (FPassword <> CEmpty) then
        Raw('PASS' + CSpace + FPassword);
    Raw('NICK' + CSpace + FNickname);
    // Usermode gets stripped of any space separated flags to retain proper format
    // If there are any flags in UserMode you have to call CmdMode again after 001
    // Some flags are Oper only so..
    Raw('USER' + CSpace + FUsername + CSpace + TextFetchLeft(FUserMode, CSpace, True) + CSpace + CAsterisk + CSpace + CColon + FRealname);
end;

procedure TIrc.EventCTCP(const aFromNick, aFromHost, aTarget, aCommand, aParameters: string);
begin
    if (Assigned(FOnCTCP)) then
        FOnCTCP(Self, aFromNick, aFromHost, aTarget, aCommand, aParameters);
end;

procedure TIrc.EventJoin(const aNick, aHost, aChannel: string);
begin
    if (IAL.Enabled) then
        IAL.NickJoinedChannel(aNick, aHost, aChannel);

    if (Assigned(FOnJoin)) then
        FOnJoin(Self, FParser.SourceNickName, FParser.Source, FParser.AllParams);
end;

procedure TIrc.EventKick(const aKicker, aKicked, aChannel, aReason: string);
begin
    if (IAL.Enabled) then
        IAL.NickKickedFromChannel(aKicked, aChannel);

    if (Assigned(FOnKick)) then
        FOnKick(Self, aKicker, aKicked, aChannel, aReason);
end;

procedure TIrc.EventKill(const aKiller, aKilled, aReason: string);
begin
    if (Assigned(FOnKill)) then
        FOnKill(Self, aKiller, aKilled, aReason);
end;

procedure TIrc.EventMode(const aSource, aTarget, aMode: string);
begin
    if (Assigned(FOnMode)) then
        FOnMode(Self, aSource, aTarget, aMode);
end;

procedure TIrc.EventNick(const aOldNick, aNewNick, aHost: string);
begin
    if (Assigned(FOnNick)) then
        FOnNick(Self, aOldNick, aNewNick, aHost);
end;

procedure TIrc.EventNotice(const aFromNick, aFromHost, aTarget, aText: string);
begin
    if (Assigned(FOnNotice)) then
        FOnNotice(Self, aFromNick, aFromHost, aTarget, aText);
end;

procedure TIrc.EventPart(const aNick, aHost, aChannel, aReason: string);
begin
    if (IAL.Enabled) then
        IAL.NickPartedChannel(aNick, aChannel);

    if (Assigned(FOnPart)) then
        FOnPart(Self, aNick, aHost, aChannel, aReason);
end;

procedure TIrc.EventPrivMsg(const aFromNick, aFromHost, aTarget, aText: string);
begin
    if (Assigned(FOnPrivMsg)) then
        FOnPrivMsg(Self, aFromNick, aFromHost, aTarget, aText);
end;

procedure TIrc.EventQuit(const aNick, aHost, aReason: string);
begin
    if (Assigned(FOnQuit)) then
        FOnQuit(Self, aNick, aHost, aReason);
end;

procedure TIrc.EventRaw(const aCmd: string; const aIn: boolean; var aBlockIt: boolean);
begin
    if (Assigned(FOnRaw)) then
        FOnRaw(Self, aCmd, aIn, aBlockIt);
end;

procedure TIrc.EventRead(const aError: word);
var
    s: string;
    i: integer;
begin
    inherited;

    while (RecvString(s)) do
    begin
        { Split on CRLF }
        if (FIncompleteCmd <> CEmpty) then
        begin
            { If there was incomplete command present in last parse prepend that to received data. }
            FTokenizer.Split(FIncompleteCmd + s, CCrLf, [soCSSep]);
            FIncompleteCmd := CEmpty;
        end
        else
            { Otherwise split the incoming data. }
            FTokenizer.Split(s, CCrLf, [soCSQot, soCSSep]);

        { Check if last token is CRLF terminated/command was complete this time }
        if (TextRight(s, 2) = CCrLf) then
        begin
            { If received data was CRLF terminated parse all commands now. }
            for i := 0 to FTokenizer.Count - 1 do
                ParseCommand(FTokenizer[i]);
        end
        else
        begin
            { Otherwise add last token as incomplete command if not CRLF terminated }
            if (FTokenizer.Count = 1) then
                FIncompleteCmd := FTokenizer[0]
            else
            begin
                if (FTokenizer.Count <> 0) then
                begin
                    for i := 0 to FTokenizer.Count - 2 do
                        ParseCommand(FTokenizer[i]);
                    FIncompleteCmd := FTokenizer[FTokenizer.Count - 1];
                end;
            end;
        end;
    end;
end;

procedure TIrc.EventServerNotice(const aSource, aText: string);
begin
    if (Assigned(FOnServerNotice)) then
        FOnServerNotice(Self, aSource, aText);
end;

procedure TIrc.EventServerWelcome;
begin
    if (Assigned(FOnServerWelcome)) then
        FOnServerWelcome(Self);
end;

procedure TIrc.ParseCommand(const aLine: string);
var
    block : boolean;
    cmd   : string;
    Params: string;
begin
    { Fire event }
    if (Assigned(FOnRaw)) then
    begin
        block := False;
        FOnRaw(Self, aLine, True, block);
        if (block) then
            Exit;
    end;

    FParser.Parse(aLine);

    if (SameText(FParser.Command, CPING)) then
    begin
        if (FParser.TrailingCount > 0) then
            Raw(CPONG + CSpace + CColon + FParser.Trailings)
        else
            Raw(CPONG);
        Exit;
    end;

    if (SameText(FParser.Command, CJOIN)) then
    begin
        EventJoin(FParser.SourceNickName, FParser.Source, FParser.AllParams);
        Exit;
    end;

    if (SameText(FParser.Command, CPART)) then
    begin
        EventPart(FParser.SourceNickName, FParser.Source, FParser.Param[0], FParser.Trailings);
        Exit;
    end;

    if (SameText(FParser.Command, CKICK)) then
    begin
        EventKick(FParser.SourceNickName, FParser.Param[1], FParser.Param[0], FParser.Trailings);

        { Auto rejoin }
        if (SameText(FParser.Param[1], FNickname)) then
            if (FRejoinWhenKicked) then
                CmdJoin(FParser.Param[0]);
        Exit;
    end;

    if (SameText(FParser.Command, CQUIT)) then
    begin
        EventQuit(FParser.SourceNickName, FParser.Source, FParser.Trailings);
        Exit;
    end;

    if (SameText(FParser.Command, CKILL)) then
    begin
        EventKill(FParser.Source, FParser.Param[0], FParser.Trailings);
        Exit;
    end;

    if (SameText(FParser.Command, CNICK)) then
    begin
        EventNick(FParser.SourceNickName, FParser.Param[0], FParser.Source);
        Exit;
    end;

    if (SameText(FParser.Command, CMODE)) then
    begin
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden +i
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden -i
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden +i
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden +DM-i+o win32
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden -DM+i-o win32
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden +DM-i+o win32
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden -DM+i-o win32
        // -> :evilworks!evilworks@staff.anonops.li MODE #evilden +DM-i+ov win32 evilworks
        //
        // <- :evilworks!evilworks@evil.machine MODE #anonops +i-i
        //
        // -> shitstorm.anonops.in MODE evilworks -i
        // <- :evilworks!evilworks@evil.machine MODE evilworks -i

        // -> shitstorm.anonops.in SAMODE p0ke -i
        // <- :shitstorm.anonops.in NOTICE evilworks :*** ANNOUNCEMENT: evilworks used SAMODE: p0ke -i
        EventMode(FParser.Source, FParser.Param[0], FParser.ParamsFrom(1));
        Exit;
    end;

    if (SameText(FParser.Command, CPRIVMSG)) then
    begin
        if (TextEnclosed(FParser.Trailings, #01, True)) then
        begin
            Params := TextUnEnclose(FParser.Trailings, #01, True);
            cmd    := TextExtractLeft(Params, CSpace, True, True);
            EventCTCP(FParser.SourceNickName, FParser.Source, FParser.Param[0], cmd, Params);
        end
        else
            EventPrivMsg(FParser.SourceNickName, FParser.Source, FParser.Param[0], FParser.Trailings);
        Exit;
    end;

    if (SameText(FParser.Command, CNOTICE)) then
    begin
        if (TextEnclosed(FParser.Trailings, #01, True)) then
        begin
            cmd    := TextRight(FParser.Trailing[0], Length(FParser.Trailing[0]) - 1);
            Params := TextLeft(FParser.TrailingsFrom(1), Length(FParser.TrailingsFrom(1)) - 1);
            EventCTCP(FParser.SourceNickName, FParser.Source, FParser.Param[0], cmd, Params);
        end
        else
        begin
            if (FParser.SourceType = stServer) then
                EventServerNotice(FParser.Source, FParser.Trailings)
            else
                EventNotice(FParser.SourceNickName, FParser.Source, FParser.Param[0], FParser.Trailings);
        end;
        Exit;
    end;

    if (SameText(FParser.Command, CERROR)) then
    begin

        Exit;
    end;

    if (SameText(FParser.Command, CINVITE)) then
    begin
        // -> :evilworks!evilworks@evil.machine INVITE win32 :#evilden
        Exit;
    end;

    if (SameText(FParser.Command, CWALLOPS)) then
    begin

        Exit;
    end;

    case StrToIntDef(FParser.Command, -1) of

        // WHOIS
        // 311 evilworks evilworks evilworks evil.machine * :Jesus H. Christ
        // 378 evilworks evilworks :is connecting from evilworks@188.129.127.120 188.129.127.120
        // 319 evilworks evilworks :@#opers #ascii #operationpayback #lounge #anonops #antisec @#help #OperationGreenRights #operationfreedom #opnewblood @#Programmers #radiopayback #reporter #services #setup #target #voice #occupywallstreet @#vhost @#kill #idle ~#cuntx
        // 312 evilworks evilworks shitstorm.anonops.in :dammit im not gay!
        // 313 evilworks evilworks :is an IRC operator
        // 379 evilworks evilworks :is using modes +BHWiorsw +ACDFGJKLNOQTVXacdfgjklnoqtvx
        // 335 evilworks evilworks :is a bot on AnonOps
        // 330 evilworks evilworks evilworks :is logged in as
        // 307 evilworks evilworks :is a registered nick
        // 671 evilworks evilworks :is using a secure connection
        // 317 evilworks evilworks 346 1318374597 :seconds idle, signon time
        // 318 evilworks evilworks :End of /WHOIS list.

        001:
        begin
            EventServerWelcome;
            { :corey.anonops.in 001 win32 :Welcome to the AnonOps IRC Network win32!win32@188.129.57.61 }
        end;

        002:
        begin
            { :corey.anonops.in 002 win32 :Your host is corey.anonops.in, running version InspIRCd-2.0 }
        end;

        003:
        begin
            { :corey.anonops.in 003 win32 :This server was created 00:58:35 Sep  6 2011 }
        end;

        004:
        begin
            { :corey.anonops.in 004 win32 corey.anonops.in InspIRCd-2.0 BHIRSWghiorswx ACDFIKLMNOQRSTYabcfhijklmnopqrstuvz FILYabfhjkloqv }
        end;

        005:
        begin
            { :corey.anonops.in 005 win32 AWAYLEN=31 CALLERID=g CASEMAPPING=rfc1459 CHANMODES=IYb,k,FLfjl,ACDKMNOQRSTcimnprstuz CHANTYPES=# CHARSET=ascii ELIST=MU EXTBAN=,ACNOQRSTcmz FNC INVEX=I KICKLEN=151 MAP MAXBANS=60 :are supported by this server }
            { :corey.anonops.in 005 win32 MAXCHANNELS=50 MAXPARA=32 MAXTARGETS=20 MODES=20 NETWORK=AnonOps NICKLEN=32 OVERRIDE PREFIX=(qaohv)~&@%+ SECURELIST SSL=93.114.44.112:6697 STARTTLS STATUSMSG=~&@%+ TOPICLEN=308 :are supported by this server }
            { :corey.anonops.in 005 win32 VBANLIST WALLCHOPS WALLVOICES WATCH=32 :are supported by this server }
        end;

        042:
        begin
            { :corey.anonops.in 042 win32 750AACQH7 :your unique ID }
        end;

        251:
        begin
            { :corey.anonops.in 251 win32 :There are 52 users and 469 invisible on 8 servers }
        end;

        252:
        begin
            { :corey.anonops.in 252 win32 8 :operator(s) online }
        end;

        253:
        begin
            { :corey.anonops.in 253 win32 1 :unknown connections }
        end;

        254:
        begin
            { :corey.anonops.in 254 win32 195 :channels formed }
        end;

        255:
        begin
            { :corey.anonops.in 255 win32 :I have 411 clients and 1 servers }
        end;

        265:
        begin
            { :corey.anonops.in 265 win32 :Current Local Users: 411  Max: 541 }
        end;

        266:
        begin
            { :corey.anonops.in 266 win32 :Current Global Users: 521  Max: 679 }
        end;

        307:
        begin
            if (FIAL.Enabled) then
                FIAL.NickIsIdentified(FParser.Param[1]);
            // <- :shitstorm.anonops.in 307 evilworks evilworks :is a registered nick
        end;

        311:
        begin
            // <- :shitstorm.anonops.in 311 evilworks evilworks evilworks evil.machine * :Jesus H. Christ
        end;

        312:
        begin
            { WHOWAS and WHOIS }
            // <- :shitstorm.anonops.in 312 evilworks evilworks shitstorm.anonops.in :Mon Oct 10 03:09:02 2011
            // <- :shitstorm.anonops.in 312 evilworks evilworks shitstorm.anonops.in :dammit im not gay!
        end;

        313:
        begin
            // <- :shitstorm.anonops.in 313 evilworks evilworks :is an IRC operator
        end;

        314:
        begin
            { WHOWAS reply }
            // <- :shitstorm.anonops.in 314 evilworks evilworks evilworks evil.machine * :Jesus H. Christ
        end;

        315:
        begin
            { RPL_ENDOFWHOLIST }
            // <- :shitstorm.anonops.in 315 evilworks evilworks :End of /WHO list.
        end;

        317:
        begin
            // <source> 317 <replyto> <subject> <idletime> <signon time> :<time description>
            // <- :shitstorm.anonops.in 317 evilworks evilworks 346 1318374597 :seconds idle, signon time
        end;

        318:
        begin
            // <- :shitstorm.anonops.in 318 evilworks evilworks :End of /WHOIS list.
        end;

        319:
        begin
            { RPL_WHOISCHANNELS }
            // <- :shitstorm.anonops.in 319 evilworks evilworks :@#opers #ascii #operationpayback #lounge #anonops #antisec @#help #OperationGreenRights #operationfreedom #opnewblood @#Programmers #radiopayback #reporter #services #setup #target #voice #occupywallstreet @#vhost @#kill #idle ~#cuntx
        end;

        321:
        begin
            { RPL_LISTSTART - :src 321 tgt chan :usrs nam }
        end;

        322:
        begin
            { RPL_LIST }
        end;

        324:
        begin
            { Channel modes }
            // <- :shitstorm.anonops.in 324 evilworks #anonops +CDSTnrt
        end;

        329:
        begin
            { Channel creation date }
            // <- :shitstorm.anonops.in 329 evilworks #anonops 1305236043
        end;

        330:
        begin
            // <- :shitstorm.anonops.in 330 evilworks evilworks evilworks :is logged in as
        end;

        331:
        begin
            { RPL_NOTOPIC }
        end;

        332:
        begin
            { RPL_TOPIC }
            { :corey.anonops.in 332 win32 #anonops :Some topic text here }
        end;

        333:
        begin
            { Topic set by }
            { :corey.anonops.in 333 win32 #anonops Jupiler 1317771878 }
        end;

        335:
        begin
            // <- :shitstorm.anonops.in 335 evilworks evilworks :is a bot on AnonOps
        end;

        341:
        begin
            { RPL_INVITING }
        end;

        352:
        begin
            { RPL_WHOREPLY }
            if (FIAL.Enabled) then
                FIAL.WhoText(FParser.ParamsFrom(1));
            // <server> XXX <replyto> <#channel> <ident> <host> <server> <nickname> <flags> :<hopcount> <realname>
            // <- :shitstorm.anonops.in 352 evilworks #ascii evilworks evil.machine shitstorm.anonops.in evilworks H* :0 Jesus H. Christ
            // <- :shitstorm.anonops.in 352 evilworks #anonops p ke shitstorm.anonops.in p0ke G*& :0 Soet :3
            // <- :shitstorm.anonops.in 352 evilworks #anonops blowmeh AN-2d8.ges.d9fja7.IP corey.anonops.in DiggerNicks G :0 I'm probably your dad
        end;

        353:
        begin
            { RPL_NAMEREPLY }
            { Replies to /names }
            if (IAL.Enabled) then
            begin
                if (TextBegins(FParser.Param[1], '#')) then
                    IAL.NamesList(FParser.Param[1], FParser.Trailings)
                else
                    if (TextBegins(FParser.Param[2], '#')) then
                        IAL.NamesList(FParser.Param[2], FParser.Trailings);
            end;
            { :corey.anonops.in 353 win32 = #anonops :SpecialBit &Thought_Criminal @mnx }
        end;

        366:
        begin
            { END OF NAMES LIST }
            { :corey.anonops.in 366 win32 #anonops :End of /NAMES list. }
        end;

        372:
        begin
            { MOTD line }
            { :corey.anonops.in 372 win32 :A HERPA DINKA DURR }
        end;

        375:
        begin
            { MOTD start }
            { :corey.anonops.in 375 win32 :corey.anonops.in message of the day }
        end;

        376:
        begin
            { MOTD end }
            { :corey.anonops.in 376 win32 :End of message of the day. }
        end;

        378:
        begin
            // <- :shitstorm.anonops.in 378 evilworks evilworks :is connecting from evilworks@188.129.127.120 188.129.127.120
        end;

        379:
        begin
            // <- :shitstorm.anonops.in 379 evilworks evilworks :was connecting from *@188.129.125.34
            // <- :shitstorm.anonops.in 379 evilworks evilworks :is using modes +BHWiorsw +ACDFGJKLNOQTVXacdfgjklnoqtvx
        end;

        396:
        begin
            { WHOWAS END }
            { :corey.anonops.in 396 win32 AN-0jb.13v.2j3fss.IP :is now your displayed host }
            // <- :shitstorm.anonops.in 369 evilworks evilworks :End of WHOWAS
        end;

        401:
        begin
            { PrivMsg error }
            // <- :shitstorm.anonops.in 401 cuntX #cuntX:smeg :No such nick/channel
        end;

        481:
        begin
            // <- :shitstorm.anonops.in 481 cuntX :Permission Denied - Only operators may set user mode s
        end;

        482:
        begin
            { :corey.anonops.in 482 win32 #evilden :You must have a registered nickname to create a new channel }
        end;

        671:
        begin
            // <- :shitstorm.anonops.in 671 evilworks evilworks :is using a secure connection
        end;

    end; { case }
end;

procedure TIrc.Raw(const aText: string);
var
    block: boolean;
begin
    { Fire event }
    if (Assigned(FOnRaw)) then
    begin
        block := False;
        FOnRaw(Self, aText, False, block);
        if (block) then
            Exit;
    end;

    SendLine(aText);
end;

procedure TIrc.CmdJoin(const aChannel, aKey: string);
begin
    if (aKey <> CEmpty) then
        Raw(CJOIN + CSpace + aChannel + CSpace + aKey)
    else
        Raw(CJOIN + CSpace + aChannel);
end;

procedure TIrc.CmdKill(const aNick, aReason: string);
begin
    Raw(CKILL + CSpace + aNick + CSpace + CColon + aReason);
end;

procedure TIrc.CmdPart(const aChannel, aPartMsg: string);
begin
    if (aPartMsg <> CEmpty) then
        Raw(CPART + CSpace + aChannel + CSpace + CColon + aPartMsg)
    else
        Raw(CPART + CSpace + aChannel);
end;

procedure TIrc.CmdWho(const aTarget, aOptionalParams: string);
begin
    if (aOptionalParams <> CEmpty) then
        Raw(CWHO + CSpace + aTarget + CSpace + aOptionalParams)
    else
        Raw(CWHO + CSpace + aTarget);
end;

procedure TIrc.CmdWhois(const aTarget: string);
begin
    Raw(CWHOIS + CSpace + aTarget + CSpace + aTarget);
end;

procedure TIrc.CmdMode(const aMode: string);
begin
    Raw(CMODE + CSpace + CNICK + aMode);
end;

procedure TIrc.CmdMsg(const aTarget, aMessage: string);
begin
    Raw(CPRIVMSG + CSpace + aTarget + CSpace + CColon + aMessage);
end;

procedure TIrc.CmdNotice(const aTarget, aMessage: string);
begin
    Raw(CNOTICE + CSpace + aTarget + CSpace + CColon + aMessage);
end;

procedure TIrc.CmdNick(const aNewNickname: string);
begin
    Raw(CNICK + CSpace + aNewNickname);
end;

procedure TIrc.SetPassword(const Value: string);
begin
    if (FPassword = Value) then
        Exit;
    FPassword := Value;
end;

procedure TIrc.SetAltNicknames(const Value: TStrings);
begin
    FAltNicknames.Assign(Value);
end;

procedure TIrc.SetNickname(const Value: string);
begin
    if (FNickname = Value) then
        Exit;
    FNickname := Value;
    CmdNick(FNickname);
end;

procedure TIrc.SetRealName(const Value: string);
begin
    if (SocketState <> ssDisconnected) then
        Exit;
    if (FRealname = Value) then
        Exit;
    FRealname := Value;
end;

procedure TIrc.SetReconnectWhenKilled(const Value: boolean);
begin
    if (FReconnectWhenKilled = Value) then
        Exit;
    FReconnectWhenKilled := Value;
end;

procedure TIrc.SetRejoinWhenKicked(const Value: boolean);
begin
    if (FRejoinWhenKicked = Value) then
        Exit;
    FRejoinWhenKicked := Value;
end;

procedure TIrc.SetUsermode(const Value: string);
begin
    if (FUserMode = Value) then
        Exit;
    FUserMode := Value;
    if (TextLeft(FUserMode, 1) <> CPlus) then
        FUserMode := CPlus + FUserMode;
    if (SocketState = ssConnected) then
        CmdMode(FUserMode);
end;

procedure TIrc.SetUsername(const Value: string);
begin
    if (SocketState <> ssDisconnected) then
        Exit;
    if (FUsername = Value) then
        Exit;
    FUsername := Value;
end;

end.