(*
  Unit com a Classe TIrc e todas as classes necessárias ao seu funcionamento.
  Eduardo Rolim(Vndmtrx) - Knal #DelphiX - [BrasNet]
  www.delphix.com.br
*)

unit unIrc;

interface

Uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
  Contnrs, unCoreIrc, unModos;

Type

  TMode = Class;

  TMensagemEvent = Procedure (Mensagem: TMensagem) of Object;
  TModeEvent = Procedure (Mode: TMode) of Object;

  TIrc = Class (TObject)
  private
    FCore: TCoreIrcProtocol;
    FOnMensagem: TMensagemEvent;
    FOnPrivmsg: TMensagemEvent;
    FOnUnknownMensagem: TMensagemEvent;
    FOnMode: TModeEvent;
    FOnPing: TMensagemEvent;
    FOnKick: TMensagemEvent;
    // nicklist
    FOnNames: TMensagemEvent;
    FOnJoin: TMensagemEvent;
    FOnPart: TMensagemEvent;
    FOnNick: TMensagemEvent;
    FOnQuit: TMensagemEvent;
  protected
    procedure DoMensagem(const Mensagem: TMensagem); Virtual;
    procedure DoUnknownCmd(const Mensagem: TMensagem); Virtual;
    procedure DoPrivmsg(const Mensagem: TMensagem); Virtual;
    procedure DoMode(const Mensagem: TMensagem); Virtual;
    procedure DoJoin(const Mensagem: TMensagem); virtual;
    procedure DoPart(const Mensagem: TMensagem); virtual;
    procedure DoNick(const Mensagem: TMensagem); virtual;
    procedure DoPing(const Mensagem: TMensagem); virtual;
    procedure DoKick(const Mensagem: TMensagem); virtual;
    procedure DoNames(const Mensagem: TMensagem); virtual;
    procedure DoQuit(const Mensagem: TMensagem); virtual;
  public
    constructor Create;
    destructor Destroy; Override;

    procedure RecebeProtocolo(Mensagem: String);

    property OnMensagem: TMensagemEvent Read FOnMensagem Write FOnMensagem;
    property OnUnknownMensagem: TMensagemEvent Read FOnUnknownMensagem Write FOnUnknownMensagem;
    property OnPrivMsg: TMensagemEvent Read FOnPrivMsg Write FOnPrivMsg;
    property OnMode: TModeEvent Read FOnMode Write FOnMode;
    property OnJoin: TMensagemEvent read FOnJoin write FOnJoin;
    property OnPart: TMensagemEvent read FOnPart write FOnPart;
    property OnNickChange: TMensagemEvent read FOnNick write FOnNick;
    property OnPing: TMensagemEvent read FOnPing write FOnPing;
    property OnKick: TMensagemEvent read FOnKick write FOnKick;
    property OnNames: TMensagemEvent read FOnNames write FOnNames;
    property OnQuit: TMensagemEvent read FOnQuit write FOnQuit;
  end;

  TMode = Class(TObject)
  Private
    FAlvo: String;
    FOperador: Char;
    FModo: Char;
    FComplemento: String;
  Public
    Constructor Create;

    Class Function Transitivo(Modo: Char): Boolean;

    Property Alvo: String Read FAlvo Write FAlvo;
    Property Modo: Char Read FModo Write FModo;
    Property Operador: Char Read FOperador Write FOperador;
    Property Complemento: String Read FComplemento Write FComplemento;
  end;

implementation

{ TIrc }

constructor TIrc.Create;
begin
  FCore := TCoreIrcProtocol.Create;
  FCore.UnkownComando := DoUnknownCmd;
  FCore.Mensagem := DoMensagem;
  FCore.AddManipulador('PRIVMSG', DoPrivmsg);
  FCore.AddManipulador('MODE', DoMode);
  FCore.AddManipulador('JOIN', DoJoin);
  FCore.AddManipulador('PART', DoPart);
  FCore.AddManipulador('NICK', DoNick);
  FCore.AddManipulador('PING', DoPing);
  FCore.AddManipulador('KICK', DoKick);
  FCore.AddManipulador('353', DoNames);
  FCore.AddManipulador('QUIT', DoQuit);
end;

destructor TIrc.Destroy;
begin
  FCore.Free;
end;

procedure TIrc.DoMensagem(Const Mensagem: TMensagem);
begin
  If Assigned(FOnMensagem) then
    FOnMensagem(Mensagem);
end;

// Descrição do comando MODE <alvo> +/-<modo> <complemento>
procedure TIrc.DoMode(Const Mensagem: TMensagem);
Var
 Alvo, Mode: String;
 TempOp, TempMode: Char;
 ClModo: TMode;
 QueueComplemento: TQueue;
 I: Integer;
begin
  QueueComplemento := TQueue.Create;
  TempOp := #0;
  If Assigned(FOnMode) then begin
    //Efetua a divisão do mode e chama FOnMode(Alvo, Op, Modo, Complemento) para
    //cada modo individual (MODE #Knl +vv-o nick nick nick = 3 chamadas à FOnMode)
    //Implementar uma classe específica para tratamento de modes
    Alvo := Mensagem.Params[0];
    Mode := Mensagem.Params[1];

    for I := 2 to Mensagem.ParamCount - 1 do
      QueueComplemento.Push(PChar(Mensagem.Params[I]));

    while Length(Mode) > 0 do begin
      if Mode[1] in ['+', '-']then begin
        TempOp := Mode[1];
        Delete(Mode, 1, 1);
      end else begin
        TempMode := Mode[1];
        Delete(Mode, 1, 1);
        
        ClModo := TMode.Create;
        ClModo.Alvo := Alvo;
        ClModo.Operador := TempOp;
        ClModo.Modo := TempMode;
        
        if ClModo.Transitivo(TempMode) then
          ClModo.Complemento := String(QueueComplemento.Pop);
          
        FOnMode(ClModo);
        ClModo.Free;
      end;
    end;
  QueueComplemento.Free;
  end;
end;

procedure TIrc.DoNames(const Mensagem: TMensagem);
begin
  if Assigned(FOnNames) then
    FOnNames(Mensagem);
end;

procedure TIrc.DoNick(const Mensagem: TMensagem);
begin
  if Assigned(FOnNick) then
    FOnNick(Mensagem);
end;

procedure TIrc.DoPart(const Mensagem: TMensagem);
begin
  if Assigned(FOnPart) then
    FOnPart(Mensagem);
end;

procedure TIrc.DoPing(const Mensagem: TMensagem);
begin
  if Assigned(FOnPing) then
    FOnPing(Mensagem);
end;

procedure TIrc.DoPrivmsg(Const Mensagem: TMensagem);
begin
  If Assigned(FOnPrivmsg) then
    FOnPrivmsg(Mensagem);
end;

procedure TIrc.DoQuit(const Mensagem: TMensagem);
begin
  if Assigned(FOnQuit) then
    FOnQuit(Mensagem);
end;

procedure TIrc.DoUnknownCmd(Const Mensagem: TMensagem);
begin
  If Assigned(FOnUnknownMensagem) then
    FOnUnknownMensagem(Mensagem);
end;

procedure TIrc.DoJoin(const Mensagem: TMensagem);
begin
  if Assigned(FOnJoin) then
    FOnJoin(Mensagem);
end;

procedure TIrc.DoKick(const Mensagem: TMensagem);
begin
  if Assigned(FOnKick) then
    FOnKick(Mensagem);  
end;

procedure TIrc.RecebeProtocolo(Mensagem: String);
begin
  FCore.ProcessProtocol(Mensagem);
end;

{ TModo }

constructor TMode.Create;
begin
  FAlvo := #0;
  FOperador := #0;
  FComplemento := #0;
  FModo := #0;
end;

class function TMode.Transitivo(Modo: Char): Boolean;
begin
  Result := Modo in ['a','o','v','b','e','f','k','l'];
end;

end.










//----------------------------------------------------
//---------------------------------------------------

unit UnIrcEx;

interface

uses
  UnIrc, Classes, unCoreIrc, SysUtils;

type
  TPing      = procedure (const Resposta: String) of Object;
  TListNicks = procedure (const Canal: String; ListaNicks: TStringList) of object;
  TChangeList= procedure (const Canal: String; Nick: String) of Object;
  TKick      = procedure (const Operador, Nick, Canal, Razao: String) of object;
  TNickChange= procedure (const OldNick: String; NewNick: String) of Object;
  TQuit      = procedure (const Nick: String) of Object;

type
  TIrcEx = class(TObject)
  private
    Irc: TIrc;
    FOnMode: TModeEvent;
    FOnNames: TListNicks;
    FOnJoin: TChangeList;
    FOnPart: TChangeList;
    FOnKick: TKick;
    FOnNickChange: TNickChange;
    FOnPing: TPing;
    FOnQuit: TQuit;
  protected
    procedure DoUserJoin(Mensagem: TMensagem);
    procedure DoUserPart(Mensagem: TMensagem);
    procedure DoNick(Mensagem: TMensagem);
    procedure DoPing(Mensagem: TMensagem);
    procedure DoKick(Mensagem: TMensagem);
    procedure DoNames(Mensagem: TMensagem);
    procedure DoQuit(Mensagem: TMensagem);
    procedure DoMode(Mode: TMode); virtual;
  public
    procedure RecebeProtocolo(Mensagem: String);
    // eventos
    property OnNames: TListNicks read FOnNames write FOnNames;
    property OnJoin: TChangeList read FOnJoin write FOnJoin;
    property OnPart: TChangeList read FOnPart write FOnPart;
    property OnUserKicked: TKick read FOnKick write FOnKick;
    property OnNickChange: TNickChange read FOnNickChange write FOnNickChange;
    property OnServerPing: TPing read FOnPing write FOnPing;
    property OnMode: TModeEvent read FOnMode write FOnMode;
    property OnPing: TPing read FOnPing write FOnPing;
    property OnQuit: TQuit read FOnQuit write FOnQuit;
  published
    constructor Create;
    destructor Destroy;
  end;

implementation

{ TIrcEx }

constructor TIrcEx.Create;
begin
  inherited Create;
  Irc := TIrc.Create;
  Irc.OnNickChange := DoNick;
  Irc.OnJoin  := DoUserJoin;
  Irc.OnPart  := DoUserPart;
  Irc.OnPing  := DoPing;
  Irc.OnKick  := DoKick;
  Irc.OnNames := DoNames;
  Irc.OnQuit  := DoQuit;
end;

destructor TIrcEx.Destroy;
begin
  Irc.Destroy;
  inherited;
end;

procedure TIrcEx.DoMode(Mode: TMode);
begin
  if Assigned(FOnMode) then
    FOnMode(Mode);
end;

procedure TIrcEx.DoKick(Mensagem: TMensagem);
begin
  if(Assigned(FOnKick))and(Mensagem.ParamCount = 2)then
    FOnKick(Copy(Mensagem.Host, 1, Pos('!', Mensagem.Host)-1),{ Kickador }
           Mensagem.Params[1]{Canal},
           Mensagem.Params[0]{Nick} ,
           Mensagem.Params[2]{Razao});
end;

procedure TIrcEx.DoNames(Mensagem: TMensagem);
var
  Str: TStringList;
begin
  if(Assigned(FOnNames))and(Mensagem.Command = '353')then
  begin
    Str := TStringList.Create;
    Str.Text := StringReplace(Mensagem.Params[3], #32, #13#10, [rfReplaceAll]);
    FOnNames(Mensagem.Params[2], Str);
    Str.Free;
  end;
end;

procedure TIrcEx.DoNick(Mensagem: TMensagem);
begin
  if Assigned(FOnNickChange) then
    FOnNickChange(Copy(Mensagem.Host, 1, Pos('!', Mensagem.Host)-1), Mensagem.Params[0]);
end;

procedure TIrcEx.DoPing(Mensagem: TMensagem);
begin
  if Assigned(FOnPing) then
    FOnPing(Mensagem.Params[0]);
end;

procedure TIrcEx.DoQuit(Mensagem: TMensagem);
begin
  if Assigned(FOnQuit) then
    FOnQuit(Copy(Mensagem.Host, 1, Pos('!', Mensagem.Host)-1));
end;

procedure TIrcEx.DoUserJoin(Mensagem: TMensagem);
begin
  if Assigned(FOnJoin) then
    FOnJoin(Mensagem.Params[0], Copy(Mensagem.Host, 1, Pos('!', Mensagem.Host)-1));
end;

procedure TIrcEx.DoUserPart(Mensagem: TMensagem);
begin
  if Assigned(FOnPart) then
    FOnPart(Mensagem.Params[0], Copy(Mensagem.Host, 1, Pos('!', Mensagem.Host)-1));
end;

procedure TIrcEx.RecebeProtocolo(Mensagem: String);
begin
  Irc.RecebeProtocolo(Mensagem);
end;

end.