TwitchIRC.cs

//Much Code Boworroed/Stolen from https://github.com/Phoinx/PhoinxBot/blob/master/PhoinxBot/IRC.cs
// ReSharper disable once CommentTypo
//Thank you to Phoinx for making this avaliable

using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace TwitchChatinator.Libs
{
    public class TwitchIrc : IDisposable
    {
        public delegate void Connected(string channel);

        public delegate void Disconnected();

        public delegate void ReceiveMessage(TwitchMessageObject message);

        private bool _shouldStop;

        private string _channel;
        private TcpClient _client;

        private bool _isConnected;
        private Thread _listen;
        private NetworkStream _nwStream;
        private StreamReader _reader;
        private StreamWriter _writer;

        public TwitchIrc()
        {
            CreateListenThread();
        }

        public void Dispose()
        {
            try
            {
                _writer.Dispose();
                _reader.Dispose();
                _nwStream.Dispose();
            }
            catch (Exception e)
            {
                Log.LogException(e);
            }
        }

        public event ReceiveMessage OnReceiveMessage;
        public event Connected OnConnected;
        public event Disconnected OnDisconnected;

        private void CreateListenThread()
        {
            _listen = new Thread(ListenThread);
        }

        private void Login()
        {
            var username = Settings.Default.TwitchUsername.ToLower();
            var password = Settings.Default.TwitchPassword;

//            Write("USER " + username + "tmi " + password);
            Write("PASS oauth:" + password);
            Write("NICK " + username);
        }

        private void JoinChannel()
        {
            _channel = Settings.Default.TwitchChannel;

            Write("JOIN #" + _channel + "\n");
        }

        private void SetConnected()
        {
            _isConnected = true;
            OnConnected?.Invoke(_channel);
        }

        public void Start()
        {
            _shouldStop = false;
            switch (_listen.ThreadState)
            {
                case ThreadState.Unstarted:
                    _listen.Start();
                    break;
                case ThreadState.Running:
                    //TODO SOMETHING
                    break;
                case ThreadState.AbortRequested:
                    OnDisconnected?.Invoke();
                    break;
                default:
                    CreateListenThread();
                    _listen.Start();
                    break;
            }
        }

        public void Stop()
        {
            _shouldStop = true;
            Write("QUIT");
        }

        public void DoReceiveMessage(TwitchMessageObject message)
        {
            OnReceiveMessage?.Invoke(message);
        }

        public void ListenThread()
        {
            _isConnected = false;
            try
            {
                Log.LogInfo("Pre - Client");
                using (_client = new TcpClient("irc.chat.twitch.tv", 6667))
                {
                    _nwStream = _client.GetStream();
                    _reader = new StreamReader(_nwStream, Encoding.GetEncoding("iso8859-1"));
                    _writer = new StreamWriter(_nwStream, Encoding.GetEncoding("iso8859-1"));

                    Login();

                    var loginResult = _reader.ReadLine();

                    Console.WriteLine("TwitchIRC Login Result: " + loginResult);

                    if (loginResult != null && loginResult.Contains(":Login authentication failed"))
                    {
                        _shouldStop = true;
                    }
                    else
                    {
                        SetConnected();
                        JoinChannel();
                    }


                    string data;
                    var msgStringIdentifier = "PRIVMSG #" + Settings.Default.TwitchChannel;
                    while (!_shouldStop && (data = _reader.ReadLine()) != null)
                    {
                        Log.LogInfo("TwitchMessageReceived\t" + data);

                        //Check for Pings, and Pong them back
                        var ex = data.Split(new[] {' '}, 5);
                        if (ex[0] == "PING")
                        {
                            Write("PONG " + ex[1]);
                        }

                        //Check for and Handle Message Object
                        if (OnReceiveMessage != null)
                        {
                            if (data.Contains(msgStringIdentifier))
                            {
                                var usrStart = data.IndexOf("!", StringComparison.Ordinal);
                                var username = data.Substring(1, usrStart - 1);
                                var msgStart = data.IndexOf(msgStringIdentifier, StringComparison.Ordinal);
                                var message = data.Substring(msgStart + msgStringIdentifier.Length + 2);
                                DoReceiveMessage(new TwitchMessageObject(_channel, username, message));
                            }
                        }
                    }
                    OnDisconnected?.Invoke();

                    _writer.Dispose();
                    _reader.Dispose();
                    _nwStream.Dispose();
                }
            }
            catch (Exception e)
            {
                Log.LogException(e);
                if (_listen.ThreadState == ThreadState.Running)
                {
                    _listen.Abort();
                }

                OnDisconnected?.Invoke();
                _isConnected = false;
            }
        }

        private void Write(string s)
        {
            try
            {
                if (_writer != null && _listen.ThreadState == ThreadState.Running)
                {
                    Log.LogInfo("TwitchMessageSent\t" + s);
                    _writer.WriteLine(s);
                    _writer.Flush();
                }
            }
            catch (Exception e)
            {
                //We do not throw here because this bot is a listen only. May look into this later
                Log.LogException(e);
            }
        }
    }

    public class TwitchMessageObject
    {
        public string Channel;
        public string Message;
        public string Username;

        public TwitchMessageObject(string c, string u, string m)
        {
            Channel = c;
            Username = u;
            Message = m;
        }
    }
}