using System;
using System.ComponentModel;
using CatchException.StreamJob.Settings;
using ChatSharp;
using CatchException.Logging;
using System.Net.Sockets;
using CatchException.Injection;
using ChatSharp.Events;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using CatchException.StreamJob.Common;

namespace CatchException.StreamJob.Services
{
    public class TwitchMessage
    {
        public string Username { get; internal set; }

        public string Message { get; internal set; }
    }

    public class IrcService
    {
        // sub notification
        // <twitchnotify> Beatemen just subscribed!

        private static Random random = new Random();
        private static Regex subscriptionNotificationRegex = new Regex("(.*) just subscribed!");
        private static Regex jtvMessage = new Regex(@"(?<type>.+) (?<user>.+) (?<arguments>.+)?");

        private IrcClient ircClient;
        private IrcChannel channel;

        [Inject]
        private Settings.Core coreSettings;

        [Inject]
        private Irc ircSettings;

        [Inject]
        private Logger log;

        private Dictionary<string, IrcMessageStager> messageStagers;

        protected class IrcMessageStager
        {
            public IrcMessageStager()
            {
                Emotes = new List<int>();
                Groups = new List<string>();
            }

            public string User { get; set; }
            public string Channel { get; set; }
            public string Message { get; set; }
            public string Color { get; set; }
            public bool IsRandomColor { get; set; }
            public List<int> Emotes { get; private set; }
            public List<string> Groups { get; private set; }

            public ChatMessageEventArgs Create()
            {
                string color = this.Color;
                bool isRandomColor = false;
                if (color == null)
                {
                    color = TwitchColors[Math.Abs(User.GetHashCode()) % (TwitchColors.Length - 1)];
                    isRandomColor = true;
                }
                ChatMessageEventArgs message = new ChatMessageEventArgs()
                {
                    User = this.User,
                    Channel = this.Channel,
                    Message = this.Message,
                    Color = color,
                    IsRandomColor = isRandomColor,
                    Emotes = new List<int>(this.Emotes),
                    Groups = new List<string>(this.Groups)
                };

                return message;
            }

            public void Clear()
            {
                User = null;
                Channel = null;
                Message = null;
                Color = null;
                Emotes.Clear();
                Groups.Clear();
            }

            public override string ToString()
            {
                return String.Format(@"User {0}[[{1}],[{2}]] to {3}{4}: {5}", User, string.Join(",", Groups), string.Join(",", Emotes), Channel, Color, Message);
            }
        }

        public class ChatMessageEventArgs : EventArgs
        {
            public string User { get; set; }
            public string Channel { get; set; }
            public string Message { get; set; }
            public string Color { get; set; }
            public bool IsRandomColor { get; set; }
            public List<int> Emotes { get; set; }
            public List<string> Groups { get; set; }

        }

        public IrcService()
        {
            messageStagers = new Dictionary<string, IrcMessageStager>(StringComparer.InvariantCultureIgnoreCase);
        }

        private IrcMessageStager GetMessageStager(string user)
        {
            IrcMessageStager messageStager;
            if (!messageStagers.TryGetValue(user, out messageStager))
            {
                log.Debug("No message stager found for {0}, creating", user);
                messageStager = new IrcMessageStager()
                {
                    User = user
                };

                messageStagers.Add(user, messageStager);
            }

            return messageStager;
        }

        private void PurgeMessageStager(string user)
        {
            log.Debug("Purging message stager for {0}", user);
            messageStagers.Remove(user);
        }

        public bool Start()
        {
            log.Debug("Starting service");

            IrcUser ircUser;

            if (ircSettings.Data.IsAnonymous)
            {
                log.Debug("Connection type set to anonymous");
                string nickname = GenerateRandomNickname();
                ircUser = new IrcUser(nickname, "justinfan");
            }
            else
            {
                log.Debug("Connection type set to registered user");
                ircUser = new IrcUser(
                    coreSettings.Data.TwitchUsername,
                    "justinfan",
                    coreSettings.Data.TwitchAuthorizationToken);
            }

            log.Debug("Connecting to {0} with username {1}", ircSettings.Data.Server, ircUser.Nick);

            ircClient = new IrcClient(ircSettings.Data.Server, ircUser);

            ircClient.ConnectionComplete += HandleConnectionComplete;
            ircClient.NetworkError += HandleNetworkError;
            ircClient.NickInUse += HandleNickInUse;
            ircClient.UserJoinedChannel += HandleUserJoinedChannel;
            ircClient.PrivateMessageRecieved += HandlePrivateMessageRecieved;

            ircClient.ConnectAsync();
            return true;
        }

        public void Stop()
        {
            log.Debug("Stopping service");
            ircClient.ConnectionComplete -= HandleConnectionComplete;
            ircClient.NetworkError -= HandleNetworkError;
            ircClient.NickInUse -= HandleNickInUse;
            ircClient.UserJoinedChannel -= HandleUserJoinedChannel;
            ircClient.PrivateMessageRecieved -= HandlePrivateMessageRecieved;

            try
            {
                ircClient.Quit();
            }
            catch (Exception ex)
            {
                log.Debug(ex, "IRC exited with an exception (99.99% ignorable)");
            }

            ircClient = null;
            channel = null;
        }

        void HandlePrivateMessageRecieved(object sender, PrivateMessageEventArgs e)
        {

            if (e.PrivateMessage.IsChannelMessage)
            {
                if ("twitchnotify".Equals(e.PrivateMessage.User.Nick))
                {
                    Match match = subscriptionNotificationRegex.Match(e.PrivateMessage.Message);
                    if (match.Success && match.Groups.Count == 2)
                    {
                        log.Info("{0} subscribed to {1}", match.Groups[1].ToString(), e.PrivateMessage.Source);
                        OnUserSubscribed(new ChatUserEventArgs(e.PrivateMessage.Source.Substring(1), match.Groups[1].ToString()));
                    }
                }
                else
                {
                    IrcMessageStager messageStager = GetMessageStager(e.PrivateMessage.User.Nick);

                    messageStager.Channel = e.PrivateMessage.Source;
                    if (channel.UsersByMode['o'].Contains(messageStager.User))
                    {
                        messageStager.Groups.Add("moderator");
                    }
                    messageStager.Message = e.PrivateMessage.Message;

                    log.Debug(messageStager.ToString());

                    OnChatMessage(messageStager.Create());

                    PurgeMessageStager(e.PrivateMessage.User.Nick);
                }
            }
            else
            {
                if (channel != null)
                {
                    if ("jtv".Equals(e.PrivateMessage.User.Nick))
                    {
                        Match match;
                        if (TryMatch(jtvMessage, e.PrivateMessage.Message, out match))
                        {
                            string type = match.Groups["type"].ToString().Trim();
                            string user = match.Groups["user"].ToString().Trim();
                            string arguments = match.Groups["arguments"].ToString().Trim();



                            switch (type)
                            {
                                case "USERCOLOR":
                                    {
                                        log.Debug("Color for user {0} set to {1}", user, arguments);

                                        IrcMessageStager messageStager = GetMessageStager(user);
                                        messageStager.Color = arguments;
                                        break;
                                    }
                                case "SPECIALUSER":
                                    {
                                        log.Debug("Set membership for user {0} to {1}", user, arguments);

                                        IrcMessageStager messageStager = GetMessageStager(user);
                                        messageStager.Groups.Add(arguments);
                                        break;
                                    }
                                case "EMOTESET":
                                    {
                                        arguments = arguments.Replace("[", "").Replace("]", "");

                                        string[] emoteStrings = arguments.Split(',');
                                        List<int> emotes = new List<int>();
                                        foreach (string emote in emoteStrings)
                                        {
                                            int result;
                                            if (!Int32.TryParse(emote, out result))
                                            {
                                                log.Debug("User {0} had invalid emote. (Message: '{1}', Invalid Emote: '{2}')", user, e.PrivateMessage.Message, emote);
                                                continue;
                                            }

                                            emotes.Add(result);
                                        }

                                        if (emotes.Count != emoteStrings.Length)
                                        {
                                            log.Debug("User {0} unexpected emote count. (Expected: {1}, Found: {2})", user, emoteStrings.Length, emotes.Count);
                                        }

                                        IrcMessageStager messageStager = GetMessageStager(user);
                                        messageStager.Emotes.AddRange(emotes);
                                        break;
                                    }
                                case "CLEARCHAT":
                                    {
                                        log.Debug("Users {0} had their chat cleared by a moderator", user);
                                        OnChatCleared(new ChatUserEventArgs(channel.Name, user));
                                        break;
                                    }
                            }
                        }
                        else
                        {
                            log.Debug("Unknown JTV message '{0}'", e.PrivateMessage.Message);
                            return;
                        }
                    }
                }
            }
        }

        private bool TryMatch(Regex regex, string message, out Match match)
        {
            return (match = regex.Match(message)).Success;
        }

        void HandleConnectionComplete(object sender, EventArgs e)
        {
            log.Debug("Connected to server");
            ircClient.SendRawMessage("TWITCHCLIENT 2");
            ircClient.JoinChannel(ircSettings.Data.Channel);
            ircClient.SendRawMessage("JTVROOMS {0}", ircSettings.Data.Channel);
        }

        void HandleNickInUse(object sender, ChatSharp.Events.ErronousNickEventArgs e)
        {
            e.NewNick = GenerateRandomNickname();

            log.Debug("Nickname is use or invalid {0}, attempting to use {1}", e.InvalidNick, e.NewNick);
        }

        void HandleNetworkError(object sender, ChatSharp.Events.SocketErrorEventArgs e)
        {
            log.Debug("Disconnected from server ({0})", e.SocketError);
            OnChatDisconnected();
        }

        void HandleUserJoinedChannel(object sender, ChatSharp.Events.ChannelUserEventArgs e)
        {
            log.Debug("{0} joined channel {1}", e.User, e.Channel.Name);
            if (e.User.Nick.Equals(ircClient.User.Nick))
            {
                channel = e.Channel;
                OnChatConnected();
            }
        }

        public event EventHandler ChatConnected;

        protected internal virtual void OnChatConnected()
        {
            if (ChatConnected != null)
            {
                ChatConnected(this, new ChatConnectionEventArgs());
            }
        }

        public event EventHandler ChatDisconnected;

        protected internal virtual void OnChatDisconnected()
        {
            if (ChatDisconnected != null)
            {
                ChatDisconnected(this, new ChatConnectionEventArgs());
            }
        }

        public event EventHandler<ChatUserEventArgs> UserJoined;

        protected internal virtual void OnUserJoined(ChatUserEventArgs e)
        {
            if (UserJoined != null)
            {
                UserJoined(this, e);
            }
        }

        public event EventHandler<ChatUserEventArgs> UserSubscribed;

        protected internal virtual void OnUserSubscribed(ChatUserEventArgs e)
        {
            if (UserSubscribed != null)
            {
                UserSubscribed(this, e);
            }
        }

        public event EventHandler<ChatMessageEventArgs> ChatMessage;

        protected internal virtual void OnChatMessage(ChatMessageEventArgs e)
        {
            if (ChatMessage != null)
            {
                ChatMessage(this, e);
            }
        }

        public event EventHandler<ChatUserEventArgs> ChatCleared;

        protected internal virtual void OnChatCleared(ChatUserEventArgs e)
        {
            if (ChatCleared != null)
            {
                ChatCleared(this, e);
            }
        }

        private string GenerateRandomNickname()
        {
            return String.Format("justinfan{0}", random.Next());
        }


        //Red, Green, Blue, FireBrick, YellowGreen, OrangeRed,
        //SeaGreen, GoldenRod, Coral, Chocolate, CadetBlue, DodgerBlue, HotPink, BlueViolet, SpringGreen),
        private static string[] TwitchColors =
        {
            "#FF0000", // Red
            "#00FF00", // Green
            "#0000FF", // Blue
            "#B22222", // FireBrick
            "#9ACD32", // YellowGreen
            "#FF4500", // OrangeRed
            "#2E8B57", // SeaGreen
            "#DAA520", // GoldenRod
            "#FF7F50", // Coral
            "#D2691E", // Chocolate
            "#5F9EA0", // CadetBlue
            "#1E90FF", // DodgerBlue
            "#FF69B4", // HotPink
            "#8A2BE2", // BlueViolet
            "#00FF7F"  // SpringGreen ... :(
        };
    }

}