IRCWeb

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

// Battle Stuffs
using BattleCore;
using BattleCore.Events;
using BattleCorePsyOps;
// Sql stuffs
using MySql.Data.MySqlClient;
using System.Diagnostics;
// Read/Write to file
using System.IO;
// IRC
using Meebey.SmartIrc4net;
// Other stuffs
using System.Collections;
using System.Threading;
using System.Timers;
using System.Text.RegularExpressions;

namespace SSZWeb
{
    [Behavior("IRCWeb", "true", "0.01", "PsyOps", "Updates website with arena list and connects to irc.")]
    public class IRCWeb:BotEventListener
    {
        public IRCWeb()
        {
            RegisterCommand("!quit", doQuit);
            RegisterCommand("!ping", doPing);

            BotPos.MapPositionX = 512 * 16;
            BotPos.MapPositionY = 512 * 16;
        }
        public void doQuit(ChatEvent c) { DisconnectIRC(); }
        public void doPing(ChatEvent c) { irc.RfcPing(MyServer); }

        // --------------------------------------------  VARIABLES AND NEEDED CLASSES   ||
        // -----------------------------------------------------------------------------//
        // Custom chat module - PsyOps
        ShortChat msg = new ShortChat();
        // Stores botname and arena
        string BotName, Arena = "";
        PlayerPositionEvent BotPos = new PlayerPositionEvent();
        double BotPosDelay = 50;//ms
        DateTime BotPosTimestamp = DateTime.Now;

        bool Initialized = false;
        byte InitializePhase = 0;
        double InitializeDelay = 5000;
        DateTime InitTimeStamp = DateTime.Now;

        Queue<string> HelpMsgIRC = new Queue<string>();
        Queue<string> HelpMsgSS = new Queue<string>();
        Queue<string> IntroMsgSS = new Queue<string>();

        // Main game timer
        System.Timers.Timer MainGameTimer = new System.Timers.Timer();

        // queue to hold biller commands - to prevent from getting kicked for flooding
        Queue<EventArgs> BillerCmdQ = new Queue<EventArgs>();
        double BillerCmdDelay = 500;
        DateTime BillerCmdTimeStamp = DateTime.Now;

        //-------------------- IRC
        bool relaySSLogin = false;
        // tag that goes before relayed messages in irc and ss
        string ircPrefix = "";
        string ssPrefix = "";
        // Main IRC Class
        public static IrcClient irc = new IrcClient();
        // Login info
        string MyNick, MyPassword, MyChannel, MyDescription, MyServer;
        int MyPort = 6667;
        bool IRCBridgeOn = true;
        bool IRCreconnect = false;
        double IRCreconnectDelay = 5;//sec
        DateTime IRCTimestamp = DateTime.Now;
        int IRCSendDelay = 50;//ms
        DateTime ToggleTimestamp = DateTime.Now;
        double ToggleDelay = 20;
        // Irc command list
        string[] IRCCommand = new string[6];
        string[] IRCCommandDesc = new string[6];
        string DoubleMsgCheckSS = "";
        string DoubleMsgCheckIRC = "";
        string BillerMsgCheckIRC = "";
        byte irc_seq = 0;
        DateTime TS_RefreshIRC = DateTime.Now;
        double Delay_RefreshIRC = 1500;//ms
        // Q's to hold the chat events
        Queue<ChatEvent> SSChatQ = new Queue<ChatEvent>();
        Queue<MyIrcMsg> IrcChatQ = new Queue<MyIrcMsg>();
        class MyIrcMsg
        {
            public MyIrcMsg(SendType SType, string SendTo, string Message)
            {
                this._SType = SType;
                this._SendTo = SendTo;
                this._Message = Message;
            }

            private SendType _SType;
            public SendType SType { get { return _SType; } }

            private string _SendTo;
            public string SendTo { get { return _SendTo; } }

            private string _Message;
            public string Message { get { return _Message; } }
        }
        public enum ColorCode
        {
            White = 0,   /**< White */
            Black = 1,   /**< Black */
            DarkBlue = 2,   /**< Dark blue */
            DarkGreen = 3,   /**< Dark green */
            Red = 4,   /**< Red */
            DarkRed = 5,   /**< Dark red */
            DarkViolet = 6,   /**< Dark violet */
            Orange = 7,   /**< Orange */
            Yellow = 8,   /**< Yellow */
            LightGreen = 9,   /**< Light green */
            Cyan = 10,   /**< Cornflower blue */
            LightCyan = 11,   /**< Light blue */
            Blue = 12,   /**< Blue */
            Violet = 13,   /**< Violet */
            DarkGray = 14,   /**< Dark gray */
            LightGray = 15   /**< Light gray */
        }
        //-------------------- Database
        private MySqlConnection connection;
        // connections strings
        private string server, database, uid, password, tablename;
        bool PrivateFreqs = false;
        int PublicFreqs = 99;
        double DBUpdateInterval = 5;
        DateTime DBUpdateTimestamp = DateTime.Now;

        // Lists to compare for arena update
        List<SQLPlayer> ServerList = new List<SQLPlayer>();
        List<SQLPlayer> CurrentList = new List<SQLPlayer>();

        class SQLPlayer
        {
            public SQLPlayer(string name, string status, int frequency)
            {
                this._name = name;
                this._status = status;
                this._frequency = frequency;
            }
            public SQLPlayer(string name, string status, int frequency, bool delete)
            {
                this._name = name;
                this._status = status;
                this._frequency = frequency;
                this._delete = delete;
            }
            private string _name;
            public string name
            {
                get { return _name; }
                set { _name = value; }
            }
            private string _status;
            public string status
            {
                get { return _status; }
                set { _status = value; }
            }
            private int _frequency;
            public int frequency
            {
                get { return _frequency; }
                set { _frequency = value; }
            }
            private bool _delete = true;
            public bool delete
            {
                get { return _delete; }
                set { _delete = value; }
            }
        }


        // ---------------------------------------------------------  TIMER FUNCTIONS   ||
        // -----------------------------------------------------------------------------//
        public void GameTimer(object source, ElapsedEventArgs e)
        {
            if ((DateTime.Now - BotPosTimestamp).TotalMilliseconds > BotPosDelay)
            {
                BotPosTimestamp = DateTime.Now;
                Game(BotPos);
            }

            if ((DateTime.Now - BillerCmdTimeStamp).TotalMilliseconds > BillerCmdDelay)
            {
                BillerCmdTimeStamp = DateTime.Now;
                if (BillerCmdQ.Count > 0)
                {
                    EventArgs eA = BillerCmdQ.Dequeue();
                    if (!(eA is ChatEvent) || (eA is ChatEvent && (eA as ChatEvent).Message != BillerMsgCheckIRC))
                    {
                        if (eA is ChatEvent)BillerMsgCheckIRC = (eA as ChatEvent).Message;
                        Game(eA);
                    }
                }
            }

            if (!Initialized)
            {
                if ((DateTime.Now - InitTimeStamp).TotalMilliseconds > InitializeDelay)
                {
                    InitTimeStamp = DateTime.Now;
                    InitializeBot();
                }
                return;
            }

            if ((DateTime.Now - DBUpdateTimestamp).TotalSeconds > DBUpdateInterval)
            {
                DBUpdateTimestamp = DateTime.Now;
                SendCommands(UpdateDB());
            }

            if (IRCreconnect)
            {
                if (!irc.IsConnected && (DateTime.Now - IRCTimestamp).TotalSeconds > IRCreconnectDelay)
                {
                    IRCTimestamp = DateTime.Now;
                    IRCreconnect = false;
                    ConnectIRC();
                }
                return;
            }

            if (IRCBridgeOn && (DateTime.Now - TS_RefreshIRC).TotalMilliseconds > Delay_RefreshIRC)
            {
                TS_RefreshIRC = DateTime.Now;
                //irc.SendMessage(SendType.Message, MyNick, "refresh");
            }

            if (IRCBridgeOn && (DateTime.Now - IRCTimestamp).TotalMilliseconds > IRCSendDelay)
            {
                irc_seq++;
                IRCTimestamp = DateTime.Now;

                if (irc_seq > 2) irc_seq = 0;

                if (irc_seq == 1)
                {
                    while(SSChatQ.Count > 0)
                        Game(SSChatQ.Dequeue());
                    return;
                }
                if (irc_seq == 0)
                {
                    while (IrcChatQ.Count > 0)
                    {
                        MyIrcMsg m = IrcChatQ.Dequeue();
                        irc.SendMessage(m.SType, m.SendTo, m.Message);
                    }
                    return;
                }
                if (irc_seq == 2)
                {
                    irc.ListenOnce();
                    return;
                }
            }
        }

        // ------------------------------------------------------  DATABASE FUNCTIONS   ||
        // -----------------------------------------------------------------------------//
        public Queue<EventArgs> ResetDatabase()
        {
            Queue<EventArgs> q = new Queue<EventArgs>();

            doSQLCommand(q, "TRUNCATE table " + tablename + ";");
            doSQLCommand(q, "ALTER TABLE " + tablename + " AUTO_INCREMENT = 1;");
            q.Enqueue(msg.chan(1, "Website arena list has been cleared."));

            return q;
        }
        private SQLPlayer GetPlayer(string name, List<SQLPlayer> list)
        {
            for (int i = 0; i < list.Count; i += 1)
                if (name == list[i].name) return list[i];

            // Ganna try and add a safety in case bot missed player enter
            PlayerInfoEvent pI = new PlayerInfoEvent();
            pI.Players.Add(name);
            BillerCmdQ.Enqueue(pI);

            return null;
        }
        public Queue<EventArgs> UpdateDB()
        {
            Queue<EventArgs> q = new Queue<EventArgs>();

            // Resetting bools for update to know who is extra
            for (int i = 0; i < ServerList.Count; i += 1)
                ServerList[i].delete = true;

            for (int i = 0; i < CurrentList.Count; i += 1)
            {
                SQLPlayer CPlayer = CurrentList[i];
                SQLPlayer SPlayer = GetPlayer(CurrentList[i].name, ServerList);

                // Checking to see if the server list has player
                if (SPlayer == null)
                {

                    // send sql to add row
                    doSQLCommand(q, "INSERT INTO " + tablename + " (playername,status,frequency) VALUES('" + CPlayer.name + "', '" + CPlayer.status + "', '" + CPlayer.frequency + "');");
                    //add player to server - SET DELETE TO FALSE ON SERVERLIST
                    ServerList.Add(new SQLPlayer(CPlayer.name, CPlayer.status, CPlayer.frequency, false));
                    //q.Enqueue(msg.chan(1, "Adding Player: [ " + CPlayer.name + " ]"));
                }
                else
                {
                    // Making sure we dont delete name
                    SPlayer.delete = false;

                    if (CPlayer.status != SPlayer.status || CPlayer.frequency != SPlayer.frequency)
                    {
                        // Check to see if player needs to be updated - SET DELETE TO FALSE ON SERVERLIST even if no update is needed
                        doSQLCommand(q, "UPDATE " + tablename + " SET status='" + CPlayer.status + "', frequency='" + CPlayer.frequency + "' WHERE playername='" + CPlayer.name + "';");
                        SPlayer.status = CPlayer.status;
                        SPlayer.frequency = CPlayer.frequency;
                        //q.Enqueue(msg.chan(1, "Info mismatch on server. Updating Player: [ " + CPlayer.name + " ]"));
                    }
                }
            }

            // checking to see if there are extra players on the server list - they will have delete set to true
            for (int i = 0; i < ServerList.Count; i += 1)
            {
                if (ServerList[i].delete)
                {
                    //q.Enqueue(msg.chan(1, "Deleting Player: [ " + ServerList[i].name + " ]"));
                    // send sql to remove row
                    doSQLCommand(q, "DELETE FROM " + tablename + " WHERE  playername='" + ServerList[i].name + "';");
                    // remove player from server list
                    ServerList.RemoveAt(i);
                }
            }
            return q;
        }
        private void doSQLCommand(Queue<EventArgs> q, string c)
        {
            if (connection.State == System.Data.ConnectionState.Closed) OpenConnection(q);
            MySqlCommand cmd = new MySqlCommand(c, connection);

            try { cmd.ExecuteNonQuery(); }
            catch (MySqlException x)
            { q.Enqueue(msg.chan(1, "doSQLCommand ERROR: " + x)); }

            CloseConnection(q);
        }
        //open connection to database
        private bool OpenConnection(Queue<EventArgs> q)
        {
            try
            {
                connection.Open();
                return true;
            }
            catch (MySqlException ex)
            {
                //When handling errors, you can your application's response based
                //on the error number.
                //The two most common error numbers when connecting are as follows:
                //0: Cannot connect to server.
                //1045: Invalid user name and/or password.
                switch (ex.Number)
                {
                    case 0:
                        q.Enqueue(msg.chan(1, "Cannot connect to server.  Contact administrator"));
                        break;

                    case 1045:
                        q.Enqueue(msg.chan(1, "Invalid username/password, please try again"));
                        break;
                    default:
                        q.Enqueue(msg.chan(1, "Error: Num[" + ex.Number + "]"));
                        break;
                }
                return false;
            }
        }
        //Close connection
        private bool CloseConnection(Queue<EventArgs> q)
        {
            try
            {
                connection.Close();
                //q.Enqueue(msg.chan(1, "Connection Closed."));
                return true;
            }
            catch (MySqlException ex)
            {
                q.Enqueue(msg.arena(ex.Message));
                return false;
            }
        }

        // ------------------------------------------------  INCOMING SUBSPACE EVENTS   ||
        // -----------------------------------------------------------------------------//
        // Monitor all incoming chat
        public void MonitorChatEvents(object sender, ChatEvent c)
        {
            if (c.ChatType == ChatTypes.Private && c.Message.StartsWith("@BotInfo@"))
            {
                // Catch and store bot info that core sends
                string[] data = c.Message.Split(':');
                BotName = data[1];
                Arena = data[2];
                // initialize bot and load cfg from file
                InitializeBot();
            }
            else
            {
                // spam control
                if (c.Message == DoubleMsgCheckSS)
                    return;
                DoubleMsgCheckSS = c.Message;

                if (AllowedMessage(c.Message))
                    ProcessIncomingSSMsg(c);
                else
                    ProcessIncomingSSCommand(c);
            }
        }

        // For freqchange event
        public void FreqChange(object sender, TeamChangeEvent t)
        {
            SQLPlayer player = GetPlayer(t.PlayerName, CurrentList);
            if (player != null)
                player.frequency = GetFreq(t.Frequency);
            else
                Game(msg.arena("FreqChange Error - Player not returned from GetPlayer()."));
        }

        // For shipchange event
        public void ShipChange(object sender, ShipChangeEvent s)
        {
            SQLPlayer player = GetPlayer(s.PlayerName, CurrentList);
            if (player != null)
                GetPlayer(s.PlayerName, CurrentList).status = s.ShipType.ToString();
            else
                Game(msg.arena("ShipChange Error - Player not returned from GetPlayer()."));
        }

        // For player enter evenT
        public void PlayerEntered(object sender, PlayerEnteredEvent p)
        {
            if (relaySSLogin)
                IrcChatQ.Enqueue(new MyIrcMsg(SendType.Notice, MyChannel, "\x03" + (int)ColorCode.DarkGreen + "[ " + p.PlayerName + " ] has just entered arena."));

            SQLPlayer player = GetPlayer(p.PlayerName, CurrentList);
            if (player == null)
                CurrentList.Add(new SQLPlayer(p.PlayerName, p.ShipType.ToString(), GetFreq(p.Frequency)));
        }

        // Player left event
        public void PlayerLeft(object sender, PlayerLeftEvent p)
        {
            if (relaySSLogin)
                IrcChatQ.Enqueue(new MyIrcMsg(SendType.Notice, MyChannel, "\x03" + (int)ColorCode.DarkGreen + "[ " + p.PlayerName + " ] has just left arena."));
            CurrentList.Remove(GetPlayer(p.PlayerName, CurrentList));
        }

        public void PlayerInfoEvent(object sender, PlayerInfoEvent p)
        {
            for (int i = 0; i < p.PlayerList.Count; i += 1)
            {
                if (GetPlayer(p.PlayerList[i].PlayerName, CurrentList) == null)
                {
                    CurrentList.Add(new SQLPlayer(p.PlayerList[i].PlayerName, p.PlayerList[i].Ship.ToString(), GetFreq(p.PlayerList[i].Frequency)));
                    BillerCmdQ.Enqueue(msg.chan(1, "Player Info was sent and received for [" + p.PlayerList[i].PlayerName + "]. Error was handled?"));
                }
            }
        }
        // ---------------------------------------------------  IRC FUNCTIONS/ EVENTS   ||
        // -----------------------------------------------------------------------------//

        public void ConnectIRC()
        {
            //Setup
            irc.Encoding = System.Text.Encoding.UTF8;
            irc.SendDelay = IRCSendDelay * 3;
            irc.AutoRetry = true;
            irc.ActiveChannelSyncing = true;

            //Event Handlers
            irc.OnJoin += new JoinEventHandler(irc_OnJoin);
            irc.OnError += new Meebey.SmartIrc4net.ErrorEventHandler(irc_OnError);
            irc.OnConnected += new EventHandler(irc_OnConnected);
            irc.OnRawMessage += new IrcEventHandler(OnRawMessage);
            irc.OnDisconnecting += new EventHandler(OnDisco);
            irc.OnQuit += new QuitEventHandler(OnQuit);
            irc.OnKick += new KickEventHandler(irc_OnKick);
            irc.OnBan += new BanEventHandler(irc_OnKick);
            irc.OnUnban += new UnbanEventHandler(irc_OnKick);

            try
            {
                //Connect, log in
                irc.Connect(MyServer, MyPort);
                irc.Login(MyNick, MyDescription);
                BillerCmdQ.Enqueue(msg.chan(1,"IRC Connected."));
                IRCJoinChan();
            }
            catch (Exception e)
            {
                BillerCmdQ.Enqueue(msg.chan(1, "IRC Login: " + "Could not connect, exception:" + Environment.NewLine
                    + e.Message + Environment.NewLine
                    + e.ToString()));
            }
        }

        public void DisconnectIRC()
        {    irc.Disconnect();   }

        public void IRCJoinChan()
        {
            irc.RfcJoin(MyChannel);
            irc.SendMessage(SendType.Message, "nickserv", "identify " + MyPassword);
            BillerCmdQ.Enqueue(msg.chan(1, "IRC Joined channel[ "+MyChannel+" ]."));
        }

        // Connection confirmation
        public void irc_OnConnected(object sender, EventArgs e)
        {
        }

        // ERROR message
        public void irc_OnError(object sender, Meebey.SmartIrc4net.ErrorEventArgs e)
        {
        }

        // irc join event
        public void irc_OnJoin(object sender, IrcEventArgs e)
        {
        }

        public void irc_OnKick(object sender, IrcEventArgs e)
        {
        }

        public void OnQuit(object sender, IrcEventArgs e)
        {
        }

        public void OnDisco(object sender, EventArgs e)
        {
            irc.RfcPing(MyServer);
            IRCreconnect = true;
            BillerCmdQ.Enqueue(msg.chan(1, "Connection lost, attempting to reconnect in (" + IRCreconnectDelay + ") seconds"));
        }

        // this method will get all IRC messages
        public void OnRawMessage(object sender, IrcEventArgs e)
        {
            if (e.Data.Message == null)
                return;

            string sentmsg = StripFormat(e.Data.Message);

            if (sentmsg == DoubleMsgCheckIRC)
                return;

            DoubleMsgCheckIRC = sentmsg;

            if (e.Data.Type == ReceiveType.ChannelMessage)
                if (AllowedMessage(sentmsg))
                    ProcessIncomingIRCMsg(e);
                else if (sentmsg.StartsWith("!") || sentmsg.StartsWith("."))
                    ProcessIncomingIRCCommand(e);
        }
        public void ProcessIncomingIRCMsg(IrcEventArgs e)
        {
            if (e.Data.Type == ReceiveType.ChannelMessage)
                SSChatQ.Enqueue(msg.pub( ssPrefix + " " + e.Data.Nick + "> " + StripFormat(e.Data.Message)));
        }
        private void ProcessIncomingSSMsg(ChatEvent c)
        {
            if (c.ChatType == ChatTypes.Public)
                IrcChatQ.Enqueue(new MyIrcMsg(SendType.Message, MyChannel, "\x03" + (int)ColorCode.Blue + ircPrefix + " " + c.PlayerName + "> " + c.Message));
        }
        public void ProcessIncomingIRCCommand(IrcEventArgs e)
        {
            if (!Initialized)
                return;

            // strip format and color from message
            string message = StripFormat(e.Data.Message).Trim().Remove(0, 1);
            // in case only a command is set we make: command = message
            string command = message;
            // placeholder for a compound command: to hold name or message
            string info = "~none~";

            // set compound variables here
            if (message.Contains(' '))
            {
                command = message.Split(' ')[0];
                info = message.Remove(0, command.Length).Trim();
            }

            // process command
            if (command.ToLower().Equals("help"))
                if (!info.Equals("~none~"))
                    SSChatQ.Enqueue(msg.pub("?help " + "[IRCHelp] ( "+ e.Data.Nick +" ) " + info));
                else
                    doHelpIRCMessage(HelpMsgIRC, e.Data.Nick);
        }
        private void ProcessIncomingSSCommand(ChatEvent c)
        {
            if (!Initialized)
                return;

            if (c.Message.StartsWith("!") || c.Message.StartsWith("."))
            {
                string command = c.Message.Trim().ToLower().Remove(0, 1);

                if (command.Contains(" "))
                {
                    // Parse command and name from command
                    command = command.Trim().Split(' ')[0];
                    string ircNick = c.Message.Trim().Remove(0, command.Length + 1).Trim();

                    if (command.Equals(IRCCommand[0]) || command.Equals(IRCCommand[1]) || command.Equals(IRCCommand[2]))
                    {
                        // Don't allow if they arent a mod.
                        if (!isMod(c)) return;
                        // Do the command on irc
                        doIrcCommand(command, ircNick);
                    }
                }
                else if (command.Equals(IRCCommand[3]))
                    doToggle(c);
                else if (command.Equals(IRCCommand[4]))
                    doStatus(c);
                else if (command.Equals(IRCCommand[5]))
                    doCmdList(c);
                else if (command.Equals("help"))
                    doHelpSSMessage(HelpMsgSS, c.PlayerName);
                else if ((command.StartsWith(IRCCommand[0]) || (command.StartsWith(IRCCommand[1]) || command.Equals(IRCCommand[2]))))
                    Game(msg.pm(c.PlayerName, "Syntax for command= !command [PlayerName]        EXAMPLE: !" + IRCCommand[0] + " PsyOps    (or)     !" + IRCCommand[1] + " PsyOps"));
            }
        }
        private bool isMod(ChatEvent c)
        {
            if (c.ModLevel >= ModLevels.Sysop)
                return true;

            Game(msg.pm(c.PlayerName, "Only staff members are allowed to use this command."));
            return false;
        }
        public void doCmdList(ChatEvent c)
        {
            Game(msg.pm(c.PlayerName, "./--------------------<[ IRCWeb Bot Command List ]--------------------\\"));
            Game(msg.pm(c.PlayerName, "|          Any of these commands can be started with . or !            |"));
            Game(msg.pm(c.PlayerName, ".\\----------+---------------------------------------------------------/"));
            Game(msg.pm(c.PlayerName, " "));
            for (int i = 0; i < IRCCommand.Length; i += 1 )
            {
                Game(msg.pm(c.PlayerName, "  " + IRCCommand[i].PadRight(11, ' ') + "|  " + IRCCommandDesc[i].PadRight(59, ' ')));
            }
            Game(msg.pm(c.PlayerName, " "));
            Game(msg.pm(c.PlayerName, ".>--------------------------------------------------------------------<"));
            Game(msg.pm(c.PlayerName, "/ Commands like " + (IRCCommand[0] + ", " + IRCCommand[1] + ", and " + IRCCommand[2] + " need a playername to follow").PadRight(55, ' ') + "\\"));
            Game(msg.pm(c.PlayerName, "\\                    EXAMPLE :      !" + IRCCommand[0] + " PsyOps                       /"));
        }
        public void doStatus(ChatEvent c)
        {
            if (IRCBridgeOn)
            {
                Game(msg.pm(c.PlayerName, "Irc Status. Bridge[ Active ] Server[ " + MyServer + " ] Channel[ " + MyChannel + " ] IRCBot[ " + MyNick + " ]"));

                int userint = 0;
                string userlist = "IRC User Chat List: ";

                // Return chatter list
                Meebey.SmartIrc4net.Channel chan = irc.GetChannel(MyChannel);
                foreach (Meebey.SmartIrc4net.ChannelUser user in chan.Users.Values)
                {
                    userint++;
                    userlist += user.IrcUser.Nick + ", ";
                }

                userlist = userlist.Remove(userlist.Length - 2, 2);

                Game(msg.pm(c.PlayerName, userlist));
                return;
            }
            Game(msg.pm(c.PlayerName, "Irc Status. Bridge[ Off ]"));
        }
        public void doToggle(ChatEvent c)
        {
            if (!isMod(c))
                return;

            if ((DateTime.Now - ToggleTimestamp).TotalSeconds > ToggleDelay)
                ToggleTimestamp = DateTime.Now;
            else
            {
                Game(msg.pm(c.PlayerName, "Toggle delay set to [ Off ]seconds. Please try again in [ " + Math.Ceiling(ToggleDelay - (DateTime.Now - ToggleTimestamp).TotalSeconds) + " ]seconds."));
                return;
            }

            IRCBridgeOn = !IRCBridgeOn;

            if (!IRCBridgeOn)
            {
                DisconnectIRC();
                IRCreconnect = false;
            }
            else
                ConnectIRC();

            BillerCmdQ.Enqueue(msg.chan(1,"IRC Bridge has been toggled [ On ]."));
        }
        private void doIrcCommand(string command, string ircNick)
        {
            irc.SendMessage(SendType.Message, "chanserv", command + " " + MyChannel + " " + ircNick);
        }
        private void doHelpIRCMessage(Queue<string> q, string nick)
        {
            Queue<string> reply = new Queue<string>(q.ToArray());
            for (int i = 0; i < q.Count; i += 1)
                //IrcChatQ.Enqueue(new MyIrcMsg(SendType.Message, nick, reply.Dequeue()));
                irc.SendMessage(SendType.Message, nick , reply.Dequeue());
        }
        private void doHelpSSMessage(Queue<string> q, string player)
        {
            Queue<string> reply = new Queue<string>(q.ToArray());
            for (int i = 0; i < q.Count; i += 1)
                Game(msg.pm(player, reply.Dequeue()));
        }
        // ------------------------------------------------  INITIALIZE BOT FUNCTIONS   ||
        // -----------------------------------------------------------------------------//
        public void InitializeBot()
        {
            switch (InitializePhase)
            {
                case 0:
                    StartGameTimer();
                    break;
                case 1:
                    loadCFG();
                    break;
                case 2:
                    SendCommands(ResetDatabase());
                    InitializePhase++;
                    break;
                case 3:
                    ConnectIRC();
                    InitializePhase++;
                    break;
                case 4:
                    Queue<string> reply = new Queue<string>(IntroMsgSS.ToArray());
                    for (int i = 0; i < IntroMsgSS.Count; i += 1)
                        Game(msg.arena(reply.Dequeue()));
                    BillerCmdQ.Enqueue(msg.chan(1, "[ " + BotName + " ] is now initialized."));
                    Initialized = true;
                    InitializePhase++;
                    break;
            }
        }
        public void StartGameTimer()
        {
            // Configure and start main game timer
            MainGameTimer.Elapsed += new ElapsedEventHandler(GameTimer);
            MainGameTimer.Interval = 50;
            MainGameTimer.Start();//and start it
            InitializePhase++;
        }
        public void loadCFG()
        {
            string fileToLoad = BotName + "/IRCWeb.cfg";

            // Looking for the CFG file
            if (File.Exists(fileToLoad))
            {
                try
                {   //Opening appropriate file
                    StreamReader SR = File.OpenText(fileToLoad);
                    //used to read each line
                    string S;
                    while ((S = SR.ReadLine()) != null)
                    {
                        // making sure it is a properly formatted setting
                        if (!S.StartsWith(";") && S.Contains(":"))
                        {
                            string[] info = S.Trim().Split(':');

                            switch (info[0])
                            {
                                case "cmdirc0": IRCCommand[0] = info[1]; break;
                                case "cmddesc0": IRCCommandDesc[0] = info[1]; break;
                                case "cmdirc1": IRCCommand[1] = info[1]; break;
                                case "cmddesc1": IRCCommandDesc[1] = info[1]; break;
                                case "cmdirc2": IRCCommand[2] = info[1]; break;
                                case "cmddesc2": IRCCommandDesc[2] = info[1]; break;
                                case "cmdirc3": IRCCommand[3] = info[1]; break;
                                case "cmddesc3": IRCCommandDesc[3] = info[1]; break;
                                case "cmdirc4": IRCCommand[4] = info[1]; break;
                                case "cmddesc4": IRCCommandDesc[4] = info[1]; break;
                                case "cmdirc5": IRCCommand[5] = info[1]; break;
                                case "cmddesc5": IRCCommandDesc[5] = info[1]; break;
                                case "ssloginrelay": relaySSLogin = ReturnBool(info[1]); break;
                                case "irctagprefix": ircPrefix = info[1]; break;
                                case "sstagprefix": ssPrefix = info[1]; break;
                                case "ircreconnectdelay": IRCreconnectDelay = double.Parse(info[1]); break;
                                case "intromsg": IntroMsgSS.Enqueue(info[1]); break;
                                case "irchelp": HelpMsgIRC.Enqueue(info[1]); break;
                                case "sshelp": HelpMsgSS.Enqueue(info[1]); break;
                                case "billermessagedelay": BillerCmdDelay = double.Parse(info[1]); break;
                                case "hideprivatefreqs": PrivateFreqs = ReturnBool(info[1]); break;
                                case "publicfreqs": PublicFreqs = int.Parse(info[1]); break;
                                case "botchats": Game(msg.pub("?chat=" + info[1])); break;
                                case "ircnick": MyNick = info[1]; break;
                                case "ircnickpass": MyPassword = info[1]; break;
                                case "ircchannel": MyChannel = info[1]; break;
                                case "ircnickdescription": MyDescription = info[1]; break;
                                case "ircserver": MyServer = info[1]; break;
                                case "ircport": MyPort = int.Parse(info[1]); break;
                                case "ircsenddelay": IRCSendDelay = int.Parse(info[1]); break;
                                case "dbupdateinterval": DBUpdateInterval = double.Parse(info[1]); break;
                                case "dbtablename": tablename = info[1]; break;
                                case "dbserver": server = info[1]; break;
                                case "dbname": database = info[1]; break;
                                case "dbuid": uid = info[1]; break;
                                case "dbpassword":
                                    connection = new MySqlConnection("SERVER="
                                    + server + ";" + "DATABASE=" + database
                                    + ";" + "UID=" + uid + ";" + "PASSWORD=" + info[1] + ";");
                                    break;
                            }
                        }
                    }
                    // Closing file
                    SR.Close();
                }
                catch (Exception x)
                {
                    Game(msg.arena("Error on file load: " + x));
                }
            }
            else
            {
                Game(msg.arena("File NOT Found"));
            }
            BillerCmdQ.Enqueue(msg.chan(1,"IRCWeb.cfg file loaded."));
            InitializePhase++;
        }

        // -----------------------------------------------------------  MISC FUNTIONS   ||
        // -----------------------------------------------------------------------------//
        // A way of hidding private freqs
        int GetFreq( ushort Freq)
        {
            if (!PrivateFreqs || Freq == 8025 || Freq <= PublicFreqs ) return (int)Freq;

            return 6969;
        }
        bool ReturnBool(string setting)
        {
            setting = setting.Trim().ToLower();
            if (setting.Equals("yes") || setting.Equals("true")) return true;
            return false;
        }

        public void SendCommands(Queue<EventArgs> q)
        {
            while (q.Count > 0)
            {
                EventArgs e = q.Dequeue();

                if (!(e is ChatEvent))
                {
                    Game(e);
                    return;
                }

                ChatEvent c = e as ChatEvent;

                if (c.ChatType == ChatTypes.Channel || (c.ChatType == ChatTypes.Public && c.Message.StartsWith("?")))
                    BillerCmdQ.Enqueue(c);
                else
                    Game(c);
            }
        }

        // Making sure we dont relay commands: IRC => SS or vice versa
        bool AllowedMessage(string m)
        {
            if (m.StartsWith("*") || m.StartsWith("?") || m.StartsWith("!") || m.StartsWith("/") || m.StartsWith(":") || m.StartsWith("."))
                return false;
            return true;
        }

        // Stripping any color code or fomat code - bold, underline, etc..
        string StripFormat(string OriginalMessage)
        {
            if (OriginalMessage == null)
                return null;

            string ircmsg = new Regex(@"\x03(\d{1,2}(,\d{1,2})?)?").Replace(OriginalMessage, "").Trim();
            ircmsg = ircmsg.Trim();
            return ircmsg;
        }

        public override void Dispose()
        {
            throw new NotImplementedException();
        }
    }
}