WormbotReporter.WIR_IRCConnection

/******************************************************************************
Copyright (c) 2005-2007 by Wormbo <wormbo@online.de>
$Id$

Manages an IRC connection.
******************************************************************************/


class WIR_IRCConnection extends WIR_IRCBase
  config;


//=============================================================================
// Constants
//=============================================================================

/** Number of milliseconds per week. Used to handle time intervals at Level.DayOfWeek wrap-around */
const MILLISECONDS_PER_WEEK = 604800000;
//const MILLISECONDS_PER_DAY = 86400000;


//=============================================================================
// Enums
//=============================================================================

enum EModeType {
  MT_Unknown,
  MT_Join,
  MT_Part,
  MT_Quit,
  MT_Kick,
  MT_Nick,
};


//=============================================================================
// Structs
//=============================================================================

struct TKeyValuePair {
  var string Key;
  var string Value;
};

struct TSentBytes {
  var int Timestamp;
  var int Length;
};

struct TMessage {
  var string Message;
  var int Timestamp;
  var bool bImportant;
};


//=============================================================================
// Localization
//=============================================================================

var localized string MsgBotJoinChat;
var localized string MsgBotJoinChatTwoWay;
var localized string MsgBotJoinReport;
var localized string MsgBotJoinReportChat;
var localized string MsgBotJoinReportChatTwoWay;
var localized string MsgBotFlooding;


//=============================================================================
// Configuration
//=============================================================================

var config string LastTopicTemplate;


//=============================================================================
// Configured Variables
//=============================================================================

// flood protection
var int FloodProtectCommandPenalty;
var int FloodProtectMessagePenalty;
var int FloodProtectMaxPenalty;
var int FloodProtectBytes;
var int FloodProtectBytesDuration;
var int MaxLenMessageQueue;

// automatically restore connections
var bool bAutoReconnect;
var int  ReconnectDelay;
var bool bAutoRejoin;
var int  ConnectTimeout;

// debug logging
var string DebugLogFileName;
var bool   bDebugStartMatch;


//=============================================================================
// Variables
//=============================================================================

var MutWormbot MyMutator;

// connection parameters
var string ServerName     "DNS name of IRC server.";
var string ServerPassword "Password required to connect to the server.";
var IpAddr ServerAddress  "Resolved server address and port.";
var string UserNick       "User's current nick name";
var string UserIdent      "User ident";
var string RealServerName "DNS name of IRC server as reported by the server itself.";

// registration handler
var WIR_RegistrationHandler RegistrationHandler "Handles the registration on the IRC server.";

// channel parameters
var string ChannelName  "Name of the channel to join after login and registration.";
var string ChannelKey   "Password required to join the channel.";
var string ChannelTopic "Channel topic received from the server.";

// current state
var bool bRegistered      "Whether this client already registered on the server.";
var bool bNoChannelColor;
var bool bNoChannelCodes;
var int  TimestampNow     "Current timestamp.";
var int  TimestampTimeout "Tracks timeouts.";
var int  ChannelJoinTime  "Timestamp when the channel was joined to delay the first message.";

var array<TKeyValuePair> NetworkParameters  "Parameters used by this server.";

// flood protection
var int SendLimitTime   "Simple flood protection. If this is more than 10s ahead of the current timestamp, nothing is sent this tick.";
var array<TSentBytes> SentBytes "Bytes sent in the last few seconds.";

var array<string>   CommandQueue  "Holds the commands to be sent as soon as the flood protection allows.";
var array<TMessage> MessageQueue  "Holds other messages to be sent when no commands are queued.";

// debug log file
var FileLog LogFile "Log file handle";


//-----------------------------------------------------------------------------
// Delegates
//-----------------------------------------------------------------------------

//== delegate OnTimeout =======================================================
/**
Called on timeout. Used internally.
*/
//============================================================================= 

delegate OnTimeout()
{
  warn("OnTimeout delegate not assigned");
}


//== delegate OnChat ==========================================================
/**
Called when someone in the channel talks.
*/
//============================================================================= 

delegate OnChat(string Nick, string Message);


//== delegate OnMode ==========================================================
/**
Called when something in the channel changes.
*/
//============================================================================= 

delegate OnMode(EModeType Type, string Nick, optional string Message);


//-----------------------------------------------------------------------------
// Interface functions
//-----------------------------------------------------------------------------

//== SetConnection ============================================================
/**
Sets the registration handler class.
*/
//============================================================================= 

function SetConnection(string Server, int Port, string Password, string Nick, string Ident)
{
  local bool bNewServer, bNewNick, bNewIdent;
  
  bNewServer = ServerName != Server || ServerAddress.Port != Port;
  bNewNick   = UserNick != Nick;
  bNewIdent  = UserIdent != Ident;
  
  ServerName          = Server;
  RealServerName      = Server;
  ServerAddress.Port  = Port;
  ServerPassword      = Password;
  UserNick            = Nick;
  UserIdent           = Ident;
  
  if ( bNewServer )
    Disconnect(True, "Changing Servers");
  else if ( bNewIdent )
    Disconnect(True, "Changing User Ident");
  else if ( bNewNick )
    SetNick(UserNick);
}


//== SetNick ================================================================
/**
changes the client's nick name.
*/
//===========================================================================

function SetNick(string NewNick)
{
  UserNick = NewNick;
}


//== SetRegistrationHandler ===================================================
/**
Sets the registration handler class.
*/
//============================================================================= 

function SetRegistrationDetails(class<WIR_RegistrationHandler> HandlerClass, string RegistrationDetails)
{
  local WIR_RegistrationHandler NewHandler;
  
  if ( HandlerClass == None )
    HandlerClass = class'WIR_RegistrationHandler';
  
  if ( RegistrationHandler != None && RegistrationHandler.Class == HandlerClass ) {
    log("IRC registration handler class" @ HandlerClass @ "already set.");
    return;
  }
  NewHandler = new(Self) HandlerClass;
  if ( NewHandler == None )
    log("Error creating IRC registration handler class" @ HandlerClass);
  
  if ( NewHandler != None ) {
    if ( RegistrationHandler != None )
      RegistrationHandler = None;
    
    RegistrationHandler = NewHandler;
  }
  else if ( RegistrationHandler == None ) {
    RegistrationHandler = new(Self) class'WIR_RegistrationHandler';
  }
  else {
    return;
  }
  RegistrationHandler.SetDetails(RegistrationDetails);
}


//== Connect ==================================================================
/**
Try to establish a connection to the IRC server.
*/
//============================================================================= 

function Connect();


//== Disconnect ===============================================================
/**
Disconnect from the currently used IRC server.
*/
//============================================================================= 

function Disconnect(bool bReconnect, string QuitMessage);


//== JoinChannel ==============================================================
/**
Join a channel.
*/
//============================================================================= 

function JoinChannel(string Channel, string Key)
{
  ChannelName = Channel;
  ChannelKey  = Key;
}


//== IsTargetChannel ==============================================================
/**
Return, whether the channel is a target channel.
*/
//============================================================================= 

function bool IsTargetChannel(string Target)
{
  local array<string> Channels;
  
  Split(ChannelName, ",", Channels);
  while(Channels.Length > 0) {
    if (Channels[0] ~= Target)
      return true;
    Channels.Remove(0, 1);
  }
  return false;
}


//== PartChannel ==============================================================
/**
Parts the channel.
*/
//============================================================================= 

function PartChannel()
{
  ChannelName = "";
  ChannelKey  = "";
}


//== ImportantMessagesQueued =========================================================
/**
Returns whether there are currently important messages in the queue.
*/
//============================================================================= 

function bool ImportantMessagesQueued()
{
  local int i;
  
  for (i = 0; i < MessageQueue.Length; ++i)
    if ( MessageQueue[i].bImportant )
      return true;
  return false;
}


//== SendMessage ==============================================================
/**
Sends a message to the channel.
*/
//============================================================================= 

function SendMessage(string Message, optional bool bImportant)
{
  Message = class'WIR_Util'.static.Trim(Message);
  if ( Message != "" && ChannelName != "" )
    SendCommand("PRIVMSG" @ ChannelName @ ":" $ Message, False, bImportant);
}


//== GetNetworkParameter ======================================================
/**
Returns true if the specified parameter is set on this network and sets Value.
*/
//=============================================================================

function bool GetNetworkParameter(string Key, out string Value)
{
  local int i;
  
  for (i = 0; i < NetworkParameters.Length; i++) {
    //log(NetworkParameters[i].Key);
    if ( NetworkParameters[i].Key ~= Key ) {
      Value = NetworkParameters[i].Value;
      return true;
    }
  }
  return false;
}


//== Chomp ====================================================================
/**
Removes a leading ":" from a string.
*/
//=============================================================================

function string Chomp(string S)
{
  if ( Left(S, 1) == ":" )
    return Mid(S, 1);
  return S;
}


//-----------------------------------------------------------------------------
// Internal functions
//-----------------------------------------------------------------------------

//== PostBeginPlay ============================================================
/**
Initializes the IRC socket.
*/
//============================================================================= 

event PostBeginPlay()
{
  Super.PostBeginPlay();
  if (LastTopicTemplate != "") {
    LastTopicTemplate = class'WIR_Util'.static.EscapeIRCCodes(LastTopicTemplate);
  }
  MyMutator   = MutWormbot(Owner);
  LinkMode    = MODE_Line;
  ReceiveMode = RMODE_Event;
}


//== IsFlooding ===============================================================
/**
Returns whether the client is flodding the server with messages.
*/
//============================================================================= 

function bool IsFlooding(int LenNextCommand)
{
  local int i, NumBytes;
  
  if ( SendLimitTime - TimestampNow < FloodProtectMaxPenalty * 1000 ) {
    //log("No Line Flood."@SendLimitTime - TimestampNow);
    return false;
  }
  for (i = 0; i < SentBytes.Length; i++) {
    if ( SentBytes[i].Timestamp > TimestampNow - FloodProtectBytesDuration * 1000 )
      NumBytes += SentBytes[i].Length;
    else
      SentBytes.Remove(i, SentBytes.Length - i);
  }
  
  if ( NumBytes + Min(LenNextCommand, FloodProtectBytes) < FloodProtectBytes ) {
    //log("No Byte Flood."@NumBytes + Min(LenNextCommand, FloodProtectBytes));
    return false;
  }
  
  return true;
}


//== SendCommand ==============================================================
/**
Queues a command for sending.
*/
//============================================================================= 

function SendCommand(string Command, bool bIsCommand, optional bool bImportant)
{
  if ( Command != "" ) {
    if ( bIsCommand ) {
      if ( CommandQueue.Length == 0 || CommandQueue[CommandQueue.Length-1] != Command )
        CommandQueue[CommandQueue.Length] = Command;
    }
    else if ( MessageQueue.Length == 0 || MessageQueue[MessageQueue.Length-1].Message != Command ) {
      MessageQueue.Insert(MessageQueue.Length, 1);
      MessageQueue[MessageQueue.Length - 1].Message     = Command;
      MessageQueue[MessageQueue.Length - 1].bImportant  = bImportant;
      MessageQueue[MessageQueue.Length - 1].Timestamp   = TimestampNow;
    }
  }
}


//== SendText =================================================================
/**
Logs the sent text.
*/
//============================================================================= 

function int SendText(string Line)
{
  local int i;
  
  Line = class'WIR_Util'.static.StripColorCodes(class'WIR_Util'.static.UnescapeIRCCodes(Line));
  
  DebugLog("<<--" @ Line);
  
  if ( SendLimitTime < TimestampNow )
    SendLimitTime = TimestampNow;
  if ( Left(Line, 8) ~= "PRIVMSG " ) {
    SendLimitTime += FloodProtectMessagePenalty;
    if ( bNoChannelCodes )
      Line = class'WIR_Util'.static.StripIRCCodes(Line);
    else if ( bNoChannelColor )
      Line = class'WIR_Util'.static.StripIRCCodes(Line, True);
  }
  else
    SendLimitTime += FloodProtectCommandPenalty;
  
  i = Super.SendText(Line);
  SentBytes.Insert(0, 1);
  SentBytes[0].Length = i;
  SentBytes[0].Timestamp = SendLimitTime;
  return i;
}


//== ReceivedLine =============================================================
/**
Logs the received text.
*/
//============================================================================= 

event ReceivedLine(string Line)
{
  local string Server, Command, Target;
  
  DebugLog("-->>" @ Line);
  
  if ( IsInState('ConnectionEstablished') ) {
    if ( Left(Line, 1) == ":" ) {
      if ( Divide(Line, " ", Server, Line) && Divide(Line, " ", Command, Line) ) {
        if ( !Divide(Line, " ", Target, Line) ) {
          Target = Line;
          Line = "";
        }
        if ( int(Command) > 0 )
          HandleNumericReply(int(Command), Server, Target, Line);
        else
          HandleStringReply(Command, Server, Target, Line);
        return;
      }
    }
    else if ( Divide(Line, " ", Command, Line) && Command == Caps(Command) ) {
      HandleCommand(Command, Line);
      return;
    }
    
    DebugLog("???? Unknown message format");
  }
}


//== HandleCommand ============================================================
/**
Handles a string command received from the server.
*/
//============================================================================= 

function HandleCommand(string Command, string Parameters)
{
  switch (Command) {
    case "PING":
      SendText("PONG" @ Parameters);
      return;
    case "ERROR":
      log("IRC Received Error:" @ Chomp(Parameters));
      //Close();
      //Disconnect(True, "");
      return;
    default:
      if ( !bRegistered && RegistrationHandler != None )
        RegistrationHandler.ReceivedCommand(Command, Parameters);
  }
}


//== HandleStringReply ============================================================
/**
Handles a string message received from the server.
*/
//============================================================================= 

function HandleStringReply(string Command, string Server, string Target, string Parameters)
{
  local string Nick;
  
  if ( !bRegistered && RegistrationHandler != None )
    RegistrationHandler.ReceivedString(Command, Server, Target, Parameters);
  if ( Command ~= "TOPIC" ) {
    ChannelTopic = class'WIR_Util'.static.EscapeIRCCodes(Chomp(Parameters));
    
    if ( MyMutator.bSetReportChannelTopic && IsTargetChannel(Target) && MyMutator.ReportConnection == Self && class'WIR_Util'.static.ParseIRCUserAddress(Chomp(Server), Nick) && Nick != UserNick )
      UpdateTopic();
  }
}


//== HandleNumericReply =======================================================
/**
Handles a numeric message received from the server.
*/
//============================================================================= 

function HandleNumericReply(int Command, string Server, string Target, string Parameters)
{
  if ( Command != 433 && Target != UserNick ) {
    log("Nick changed from" @ UserNick @ "to" @ Target, Name);
    UserNick = Target;
  }
  if ( !bRegistered && RegistrationHandler != None )
    RegistrationHandler.ReceivedNumeric(Command, Server, Target, Parameters);
  if ( Command == RPL_TOPIC ) {
    Divide(Parameters, " :", Parameters, ChannelTopic);
    ChannelTopic = class'WIR_Util'.static.EscapeIRCCodes(ChannelTopic);
    if ( MyMutator.bSetReportChannelTopic && IsTargetChannel(Parameters) && MyMutator.ReportConnection == Self )
      UpdateTopic();
  }
  else if ( Command == RPL_NOTOPIC ) {
    ChannelTopic = "";
    if ( MyMutator.bSetReportChannelTopic && IsTargetChannel(Parameters) && MyMutator.ReportConnection == Self )
      UpdateTopic();
  }
}


//== UpdateTopic ==============================================================
/**
Updates the channel topic.
*/
//============================================================================= 

function UpdateTopic(optional bool bLeaving)
{
  local string BotPart, UserPart;
  local string NewTopic, OldTopic;
  local array<string> Parts;
  local int i, TopicLen, NewTopicLen;
  local bool bTopicMatches;
  local string TopicLenString;
  
  NewTopic = Repl(MyMutator.ReportChannelTopicTemplate, "%%chan%%", ChannelName, True);
  OldTopic = ChannelTopic;
  if ( GetNetworkParameter("topiclen", TopicLenString) )
    TopicLen = int(TopicLenString);
  
  if ( InStr(NewTopic, "%%botpart%%") == -1 ) {
    log("ERROR: No '%%botpart%%' in ReportChannelTopicTemplate - channel topic will not be set.");
    return;
  }
  
  if ( bLeaving || MyMutator.bMatchEnded
      || !MyMutator.bMatchStarted && Level.Game.GetNumPlayers() == 0 ) {
    BotPart = MyMutator.ReportChannelTopicBotIdle;
  }
  else {
    BotPart = MyMutator.ReportChannelTopicBotPart;
    BotPart = Repl(BotPart, "%%game%%", Level.Game.GameName, True);
    BotPart = Repl(BotPart, "%%map%%", Level.Title, True);
  }
  
  if ( InStr(LastTopicTemplate, "%%userpart%%") != -1 && OldTopic != "" ) {
    // We need to identify the userpart in the current topic.
    bTopicMatches = True;
    
    // To do this we first take apart the topic template...
    if ( Split(LastTopicTemplate, "%%", Parts) > 0 ) {
      for (i = Parts.Length - 1; i > 0; --i) {
        if ( Parts[i] != "botpart" && Parts[i-1] != "botpart" && Parts[i] != "userpart" && Parts[i-1] != "userpart" ) {
          Parts[i-1] $= "%%" $ Parts[i];
          Parts.Remove(i, 1);
        }
        //else
          //log("Parts:"@Parts[i]);
      }
      //log("Parts:"@Parts[0]);
      
      // ...and then match the individual parts against the current topic.
      // If neither botpart nor userpart of the template are the beginning of the topic, try matching the first part.
      if ( Parts[0] != "botpart" && Parts[0] != "userpart" ) {
        if ( Left(OldTopic, Len(Parts[0])) != Parts[0] )
          bTopicMatches = False;  // doesn't match
        else
          OldTopic = Mid(OldTopic, Len(Parts[0]));
      }
      
      if ( bTopicMatches ) {
        // We have a match, now try matching the last part.
        i = Parts.Length - 1;
        if ( Parts[i] != "botpart" && Parts[i] != "userpart" ) {
          if ( Right(OldTopic, Len(Parts[i])) != Parts[i] )
            bTopicMatches = False;  // doesn't match
          else
            OldTopic = Left(OldTopic, Len(OldTopic) - Len(Parts[i]));
        }
        
        if ( bTopicMatches ) {
          // The topic still matches. Let's see if we can find the middle part as well.
          i = InStr(OldTopic, Parts[2]);
          if ( i != -1 ) {
            // Alright, we found it.
            if ( Parts[1] == "userpart" ) {
              // This one's easy: The user part is at the beginning of the remaining string.
              UserPart = Left(OldTopic, i);
            }
            else {
              // This one's not difficult either: The user part is at the end of the remaining string.
              UserPart = Mid(OldTopic, i + Len(Parts[2]));
            }
          }
          else
            bTopicMatches = False;
        }
      }
      
      if ( !bTopicMatches )
        UserPart = ChannelTopic;
    }
    else
      return;
  }
  
  if ( UserPart == "" )
    UserPart = MyMutator.ReportChannelTopicUserPart;
  
  LastTopicTemplate = NewTopic;
  SaveConfig();
  
  // need to temporarily unescape codes to find the correct length
  UserPart = class'WIR_Util'.static.UnescapeIRCCodes(UserPart);
  NewTopic = class'WIR_Util'.static.UnescapeIRCCodes(Repl(NewTopic, "%%botpart%%", BotPart, True));
  NewTopicLen = Len(Repl(NewTopic, "%%userpart%%", UserPart, True));
  if ( TopicLen > 0 && NewTopicLen > TopicLen )
    UserPart = Left(UserPart, Len(UserPart) - (NewTopicLen - TopicLen));
  
  // now escape codes again because SendText() should handle unescaping them
  NewTopic = class'WIR_Util'.static.EscapeIRCCodes(Repl(NewTopic, "%%userpart%%", UserPart, True));
  
  if ( NewTopic != ChannelTopic ) {
    if ( bLeaving )
      SendText("TOPIC"@ChannelName@":"$NewTopic);     // no time to queue the command
    else
      SendCommand("TOPIC"@ChannelName@":"$NewTopic, True);
  }
}


//== Registered ===============================================================
/**
Called when registration was completed.
*/
//============================================================================= 

function Registered();


//== SetTimeout ===============================================================
/**
Sets a timeout delay.
*/
//============================================================================= 

function SetTimeout(float TimeoutSeconds)
{
  if ( int(TimeoutSeconds *= 1000) > 0 ) {
    TimestampTimeout = TimestampNow + int(TimeoutSeconds);
    if (TimestampTimeout > MILLISECONDS_PER_WEEK)
      TimestampTimeout = Max(TimestampTimeout - MILLISECONDS_PER_WEEK, 1);
  }
  else
    warn("Illegal TimeoutSeconds:" @ TimeoutSeconds);
}


//== ClearTimeout =============================================================
/**
Clears a timeout delay.
*/
//============================================================================= 

function ClearTimeout()
{
  TimestampTimeout = 0;
}


//== Tick =====================================================================
/**
Updates the current timestamp.
*/
//============================================================================= 

event Tick(float DeltaTime)
{
  local int TimestampLast, i, TimestampDelta;
  
  TimestampLast = TimestampNow;
  TimestampNow = Level.MilliSecond + 1000 * (Level.Second + 60 * (Level.Minute + 60 * (Level.Hour + 24 * Level.DayOfWeek)));
  if ( TimestampNow < TimestampLast ) {
    // new week?
    TimestampDelta = TimestampLast - TimestampNow;
    if (TimestampDelta > (MILLISECONDS_PER_WEEK >>> 2)) {
      // probably yes
      TimestampDelta = MILLISECONDS_PER_WEEK;
    }
    else {
      // was just a time correction, it seems
      TimestampDelta--;
    }
    TimestampLast = TimestampLast - TimestampDelta;
    
    // make sure the sent bytes records are relative to the new day
    do {
      SentBytes[i].Timestamp = SentBytes[i].Timestamp - TimestampDelta;
    } until (++i == SentBytes.Length);
  }
  
  if ( TimestampTimeout > 0 && TimestampTimeout <= TimestampNow && TimestampNow - TimestampTimeout < (MILLISECONDS_PER_WEEK >>> 2) ) {
    ClearTimeout();
    OnTimeout();
  }
}


//== DebugLog =================================================================
/**
Log debug information.
*/
//=============================================================================

function DebugLog(string S)
{
  if ( LogFile == None && DebugLogFileName != "" ) {
    foreach DynamicActors(class'FileLog', LogFile)
      if ( WIR_IRCConnection(LogFile.Owner) != None )
        break;
    if ( LogFile == None || WIR_IRCConnection(LogFile.Owner) == None )
      LogFile = Spawn(class'FileLog', self);
    if ( LogFile != None ) {
      LogFile.OpenLog(DebugLogFileName);
      LogFile.Logf("");
      LogFile.Logf("==============================================================================");
      LogFile.Logf("");
    }
  }
  if ( LogFile != None )
    LogFile.Logf(TimestampNow @ Eval(UserNick != "", Usernick, string(Name)) @ S);
  //log(TimestampNow @ Eval(UserNick != "", Usernick, string(Name)) @ S);
}


//-----------------------------------------------------------------------------
// state NotConnected
//-----------------------------------------------------------------------------

auto state NotConnected
{
  //== Disconnect =============================================================
  /**
  Already disconnected. Try to reconnect if desired.
  */
  //===========================================================================
  
  function Disconnect(bool bReconnect, string QuitMessage)
  {
    if ( bReconnect )
      Connect();
  }
  
  
  //== Connect ================================================================
  /**
  Already disconnected. Try to reconnect if desired.
  */
  //===========================================================================
  
  function Connect()
  {
    if ( ServerAddress.Addr != 0 && ServerAddress.Port > 0 ) {
      if ( BindPort() == 0 )
        log("ERROR - Can't bind port for IRC connection.");
      else
        Open(ServerAddress);
      OnTimeout = Connect;
      SetTimeout(ConnectTimeout);
    }
    else if ( ServerName != "" && ServerAddress.Port > 0 ) {
      Resolve(ServerName);
    }
    else {
      log("ERROR - Missing server address or port.");
    }
  }
  
  
  //== Resolved ===============================================================
  /**
  Server address resolved. Try to connect.
  */
  //===========================================================================
  
  event Resolved(IpAddr Address)
  {
    if ( Address.Addr != 0 ) {
      ServerAddress.Addr = Address.Addr;
      Connect();
    }
    else
      log("ERROR - Resolving resulted in 0.0.0.0");
  }
  
  
  //== ResolveFailed ==========================================================
  /**
  Resolving server address failed.
  */
  //===========================================================================
  
  event ResolveFailed()
  {
    log("ERROR - Could not resolve server address.");
  }
  
  
  //== Opened =================================================================
  /**
  The server connection has been opened successfully.
  */
  //===========================================================================
  
  event Opened()
  {
    ClearTimeout();
    GotoState('ConnectionEstablished');
  }
  
Reconnect:
  log("Waiting before reconnecting", Name);
  ServerAddress.Addr = 0;
Begin:
  OnTimeout = Connect;
  SetTimeout(ReconnectDelay);
  NetworkParameters.Length = 0;
}


//-----------------------------------------------------------------------------
// state ConnectionEstablished
//-----------------------------------------------------------------------------

state ConnectionEstablished
{
  //== SetNick ================================================================
  /**
  Changes the client's nick name.
  */
  //===========================================================================
  
  function SetNick(string NewNick)
  {
    Global.SetNick(NewNick);
    SendCommand("NICK" @ NewNick, True);
  }
  
  
  //== HandleNumericReply ==========================================================
  /**
  Detects numeric 001 as confirmation for login.
  */
  //===========================================================================
  
  function HandleNumericReply(int Command, string Server, string Target, string Parameters)
  {
    local array<string> Params;
    local int i;
    
    if ( Server != RealServerName )
      RealServerName = Chomp(Server);
    if ( Command == 1 && !IsInState('LoggedIn') )
      GotoState('LoggedIn');
    else if ( Command == ERR_NICKNAMEINUSE ) {
      SetNick(Usernick $ "`");
    }
    else if ( Command == 1 ) {
      Usernick = Target;  // this is the name we really have
    }
    else if ( Command == 5 ) {
      Split(Parameters, " ", Params);
      while (Params.Length > 0 && Left(Params[0], 1) != ":") {
        NetworkParameters.Insert(0, 1);
        i = InStr(Params[0], "=");
        if ( i > 0 ) {
          NetworkParameters[0].Key = Left(Params[0], i);
          NetworkParameters[0].Value = Mid(Params[0], i+1);
          //log("Network parameter:"@NetworkParameters[0].Key@"="@NetworkParameters[0].Value);
        }
        else {
          NetworkParameters[0].Key = Params[0];
          NetworkParameters[0].Value = "";
          //log("Network parameter:"@NetworkParameters[0].Key@"(empty parameter)");
        }
        Params.Remove(0, 1);
      }
    }
    Global.HandleNumericReply(Command, Server, Target, Parameters);
  }
  
  
  //== Disconnect =============================================================
  /**
  Disconnect from the server.
  */
  //===========================================================================
  
  function Disconnect(bool bReconnect, string QuitMessage)
  {
    SendText("QUIT :" $ QuitMessage);
    if ( bReconnect )
      GotoState('NotConnected', 'Reconnect');
    else
      GotoState('NotConnected');
  }
  
  
  //== Tick ===================================================================
  /**
  Send commands when flood protection allows it.
  */
  //===========================================================================
  
  event Tick(float DeltaTime)
  {
    Global.Tick(DeltaTime);
    if ( CommandQueue.Length > 0 && !IsFlooding(Len(CommandQueue[0])) ) {
      SendText(Left(CommandQueue[0], FloodProtectBytes));
      CommandQueue.Remove(0, 1);
    }
  }
  
  
  //== Closed =================================================================
  /**
  The server connection has been closed.
  */
  //===========================================================================
  
  event Closed()
  {
    ClearTimeout();
    if ( CommandQueue.Length > 0 )
      CommandQueue.Remove(0, CommandQueue.Length);
    GotoState('NotConnected', 'Reconnect');
  }
  
  
  //== BeginState =============================================================
  /**
  Clear the queues and network info.
  */
  //===========================================================================
  
  event BeginState()
  {
    Super.BeginState();
    //NetworkParameters.Length = 0;
    CommandQueue.Length = 0;
  }
  
Begin:
  log("Connected to IRC server", Name);
  if ( ServerPassword != "" )
    SendText("PASS" @ ServerPassword);
  SendText("NICK" @ UserNick);
  SendText("USER" @ UserIdent @ "localhost" @ UserNick @ ":" $ class'MutWormbot'.default.FriendlyName
      @ "on" @ Level.GRI.ServerName);
}


//-----------------------------------------------------------------------------
// state LoggedIn
//-----------------------------------------------------------------------------

state LoggedIn extends ConnectionEstablished
{
  //== Registered =============================================================
  /**
  Called when registeration was successful.
  */
  //===========================================================================
  
  function Registered()
  {
    GotoState('RegisterationComplete');
  }
  
Begin:
  log("Logged in to" @ RealServerName, Name);
  if ( RegistrationHandler == None )
    SetRegistrationDetails(None, "");
  else
    RegistrationHandler.Reset();
  if ( RegistrationHandler != None )
    RegistrationHandler.Register();
  
  SetTimeout(30);
  OnTimeout = Registered;
}


//-----------------------------------------------------------------------------
// state Registered
//-----------------------------------------------------------------------------

state RegisterationComplete extends LoggedIn
{
  //== Registered =============================================================
  /**
  Use the global non-state inplementation.
  */
  //===========================================================================
  
  function Registered()
  {
    Global.Registered();
  }
  
  
  //== JoinChannel ============================================================
  /**
  Join a channel.
  */
  //===========================================================================
  
  function JoinChannel(string Channel, string Key)
  {
    Global.JoinChannel(Channel, Key);
    if ( ChannelName != "" ) {
      if ( ChannelKey != "" )
        SendCommand("JOIN"@ChannelName@ChannelKey, true);
      else
        SendCommand("JOIN"@ChannelName, true);
    }
  }
  
  
  //== HandleStringReply ======================================================
  /**
  Detects when the client joined the channel.
  */
  //===========================================================================
  
  function HandleStringReply(string Command, string Server, string Target, string Parameters)
  {
    local string Nick;
    
    if ( Command == "JOIN" && class'WIR_Util'.static.ParseIRCUserAddress(Chomp(Server), Nick) ) {
      if ( IsTargetChannel(Chomp(Target)) ) {
        Target = Chomp(Target);  // adjust capitalization
        if ( Nick ~= UserNick )
          GotoState('InChannel');
        else
          OnMode(MT_Join, Nick);
      }
    }
    Super.HandleStringReply(Command, Server, Target, Parameters);
  }
  
  
Begin:
  Sleep(0.0);
  if ( ChannelName != "" )
    JoinChannel(ChannelName, ChannelKey);
}


//-----------------------------------------------------------------------------
// state InChannel
//-----------------------------------------------------------------------------

state InChannel extends RegisterationComplete
{
  //== BeginState =============================================================
  /**
  Clear the queues and network info.
  */
  //===========================================================================
  
  event BeginState()
  {
    local WIR_IRCConnection OtherConnection;
    local string Msg;
    local GameReplicationInfo GRI;
    
    GRI = Level.Game.GameReplicationInfo;
    Super.BeginState();
    
    if ( MyMutator.ReportConnection == Self ) {
      OtherConnection = MyMutator.ChatConnection;
      if ( MyMutator.ChatConnection == Self ) {
        if ( MyMutator.bEnableTwoWayChat )
          Msg = MsgBotJoinReportChatTwoWay;
        else
          Msg = MsgBotJoinReportChat;
      }
      else
        Msg = MsgBotJoinReport;
    }
    else if ( MyMutator.ChatConnection == Self ) {
      OtherConnection = MyMutator.ReportConnection;
      if ( MyMutator.bEnableTwoWayChat )
        Msg = MsgBotJoinChatTwoWay;
      else
        Msg = MsgBotJoinChat;
    }
    Msg = Repl(Msg, "%m", class'MutWormbot'.default.FriendlyName, True);
    SendCommand("PRIVMSG" @ ChannelName @ ":" $ Repl(Msg, "%s", GRI.ServerName, True), True);
    
    if ( OtherConnection != None && OtherConnection != Self && OtherConnection.IsInState('InChannel')
        && OtherConnection.ServerName ~= ServerName && OtherConnection.ChannelName ~= ChannelName )
      return;
    
    if ( MyMutator.MyGameHandler != None ) {
      Msg = MyMutator.MyGameHandler.GetGameInfoString();
      if ( Msg != "" )
        SendCommand("PRIVMSG" @ ChannelName @ ":" $ Msg, True);
    }
  }
  
  
  //== Tick ===================================================================
  /**
  Send commands and messages to the channel when flood protection allows it.
  */
  //===========================================================================
  
  event Tick(float DeltaTime)
  {
    local int i;
    
    Global.Tick(DeltaTime);
    
    if ( CommandQueue.Length > 0 ) {
      if ( !IsFlooding(Len(CommandQueue[0])) ) {
        SendText(Left(CommandQueue[0], FloodProtectBytes));
        CommandQueue.Remove(0, 1);
      }
    }
    else if ( MessageQueue.Length > 0 && TimestampNow - ChannelJoinTime > 1000 ) {
      if ( MessageQueue.Length > MaxLenMessageQueue && MyMutator.bMatchStarted
          && !MyMutator.bMatchEnded ) {
        for (i = MessageQueue.Length - 1; i >= 0; --i)
          if ( !MessageQueue[i].bImportant )
            MessageQueue.Remove(i, 1);
        SendMessage(MsgBotFlooding);
      }
      if ( !IsFlooding(Len(MessageQueue[0].Message)) ) {
        SendText(Left(MessageQueue[0].Message, FloodProtectBytes));
        MessageQueue.Remove(0, 1);
      }
    }
  }
  
  
  //== HandleStringReply ======================================================
  /**
  Detects when the client joined the channel.
  */
  //===========================================================================
  
  function HandleStringReply(string Command, string Server, string Target, string Parameters)
  {
    local string Nick, Left, Right;
    
    class'WIR_Util'.static.ParseIRCUserAddress(Chomp(Server), Nick);
    if ( IsTargetChannel(Target) ) {
      //log(Command@Nick@Parameters);
      switch (Command) {
        case "MODE":
          if ( Parameters ~= ("+o" @ Usernick) && MyMutator.bSetReportChannelTopic && MyMutator.ReportConnection == Self )
            UpdateTopic();
          break;
        case "PRIVMSG":
          if ( Nick != UserNick )
            OnChat(Nick, Chomp(Parameters));
          break;
        case "PART":
          if ( Nick != UserNick )
            OnMode(MT_Part, Nick, Chomp(Parameters));
          else
            GotoState('RegisterationComplete');
          break;
        case "KICK":
          Divide(Parameters, " ", Left, Right);
          if ( Left ~= Usernick )
            GotoState('RegisterationComplete');
          OnMode(MT_Kick, Nick, Parameters);
          break;
      }
    }
    else if ( Nick != UserNick ) {
      if ( Command == "NICK" )
        OnMode(MT_Nick, Nick, Chomp(Target));
      if ( Command == "QUIT" )
        OnMode(MT_Quit, Nick, Chomp(Eval(Parameters != "", Target @ Parameters, Target)));
    }
    Super.HandleStringReply(Command, Server, Target, Parameters);
  }
  
  
  //== JoinChannel ============================================================
  /**
  Join a channel.
  */
  //===========================================================================
  
  function JoinChannel(string Channel, string Key)
  {
    if ( ChannelName ~= Channel )
      return;
    PartChannel();
    Global.JoinChannel(Channel, Key);
  }
  
  
  //== Disconnect =============================================================
  /**
  Disconnect from the server.
  */
  //===========================================================================
  
  function Disconnect(bool bReconnect, string QuitMessage)
  {
    if ( MyMutator.bSetReportChannelTopic && MyMutator.ReportConnection == Self )
      UpdateTopic(True);
    Super.Disconnect(bReconnect, QuitMessage);
  }
  
  
  //== PartChannel ============================================================
  /**
  Parts the channel.
  */
  //===========================================================================
  
  function PartChannel()
  {
    SendCommand("PART"@ChannelName, True);
    Global.PartChannel();
  }

Begin:
  log("Joined channel" @ ChannelName, Name);
  ChannelJoinTime = TimestampNow;
  Sleep(5.0);
  if ( bDebugStartMatch && Level.Game.IsInState('PendingMatch') )
    Level.Game.StartMatch();
  Sleep(0.0);
  if ( MyMutator.bSetReportChannelTopic && !MyMutator.bMatchStarted && MyMutator.ReportConnection == Self )
    UpdateTopic();
}


//=============================================================================
// Default properties
//=============================================================================

defaultproperties
{
  bAlwaysTick = True
  
  MsgBotJoinChat              = "[^B]%m[^B] - relaying chat from [^B]%s[^B]"
  MsgBotJoinChatTwoWay        = "[^B]%m[^B] - relaying chat from and to [^B]%s[^B]"
  MsgBotJoinReport            = "[^B]%m[^B] - reporting from [^B]%s[^B]"
  MsgBotJoinReportChat        = "[^B]%m[^B] - reporting and relaying chat from [^B]%s[^B]"
  MsgBotJoinReportChatTwoWay  = "[^B]%m[^B] - reporting and relaying chat from and to [^B]%s[^B]"
  
  MsgBotFlooding = "[^B]I had to drop some messages to catch up.[^B]"
}