namespace Holo.Managers
{
    using Holo;
    using Holo.Virtual.Users;
    using Ion.Storage;
    using System;
    using System.Collections;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading;

    public static class eventManager
    {
        internal static int categoryAmount;
        private static int deadEventDropInterval;
        private static Thread deadEventDropper;
        private static Hashtable[] Events;

        public static bool categoryOK(int categoryID)
        {
            return ((categoryID > 0) && (categoryID <= categoryAmount));
        }

        public static void createEvent(int categoryID, int userID, int roomID, string Name, string Description)
        {
            if (!Events[categoryID - 1].Contains(roomID))
            {
                virtualEvent Event = new virtualEvent(roomID, userID, Name, Description);
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    dbClient.AddParamWithValue("ename", Name);
                    dbClient.AddParamWithValue("edescription", Description);
                    dbClient.runQuery(string.Concat(new object[] { "INSERT INTO events (name,description,userid,roomid,category,date) VALUES (@ename, @edescription, '", userID, "', '", roomID, "', '", categoryID, "', '", DateTime.Now.TimeOfDay.ToString(), "')" }));
                }
                Events[categoryID - 1].Add(roomID, Event);
            }
        }

        private static void dropDeadEvents()
        {
            while (true)
            {
                for (int i = 0; i < categoryAmount; i++)
                {
                    foreach (virtualEvent Event in ((Hashtable) Events[i].Clone()).Values)
                    {
                        DatabaseClient dbClient;
                        if (!userManager.containsUser(Event.userID))
                        {
                            using (dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dbClient.runQuery("DELETE FROM events WHERE roomid = '" + Event.roomID + "'");
                            }
                            Events[i].Remove(Event.roomID);
                        }
                        else
                        {
                            virtualUser Hoster = userManager.getUser(Event.userID);
                            if (Hoster._roomID != Event.roomID)
                            {
                                using (dbClient = Eucalypt.dbManager.GetClient())
                                {
                                    dbClient.runQuery("DELETE FROM events WHERE roomid = '" + Event.roomID + "'");
                                }
                                Events[i].Remove(Event.roomID);
                                Hoster._hostsEvent = false;
                            }
                        }
                    }
                }
                Thread.Sleep(deadEventDropInterval);
                Out.WriteTrace("Drop dead event loop");
            }
        }

        public static void editEvent(int categoryID, int roomID, string Name, string Description)
        {
            if (Events[categoryID - 1].Contains(roomID))
            {
                virtualEvent Event = (virtualEvent) Events[categoryID - 1][roomID];
                Event.Name = Name;
                Event.Description = Description;
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    dbClient.AddParamWithValue("name", Name);
                    dbClient.AddParamWithValue("desc", Description);
                    dbClient.runQuery(string.Concat(new object[] { "UPDATE events SET name = @name ,description = @desc ,category = '", categoryID, "',date = '", DateTime.Now.TimeOfDay.ToString(), "' WHERE roomid = '", roomID, "'" }));
                }
                Events[categoryID - 1].Remove(roomID);
                Events[categoryID - 1].Add(roomID, Event);
            }
        }

        public static string getEvent(int roomID)
        {
            try
            {
                for (int i = 0; i < categoryAmount; i++)
                {
                    if (Events[i].ContainsKey(roomID))
                    {
                        virtualEvent Event = (virtualEvent) Events[i][roomID];
                        return string.Concat(new object[] { Event.userID, Convert.ToChar(2).ToString(), userManager.getUser(Event.userID)._Username, Convert.ToChar(2).ToString(), Event.roomID, Convert.ToChar(2).ToString(), Encoding.encodeVL64(i + 1), Event.Name, Convert.ToChar(2).ToString(), Event.Description, Convert.ToChar(2).ToString(), Event.Started, Convert.ToChar(2).ToString() });
                    }
                }
                return "-1";
            }
            catch
            {
                return "-1";
            }
        }

        public static string getEvents(int categoryID)
        {
            try
            {
                int Count = 0;
                StringBuilder List = new StringBuilder();
                foreach (virtualEvent Event in ((Hashtable) Events[categoryID - 1].Clone()).Values)
                {
                    if (userManager.containsUser(Event.userID))
                    {
                        List.Append(string.Concat(new object[] { Event.roomID, Convert.ToChar(2).ToString(), userManager.getUser(Event.userID)._Username, Convert.ToChar(2), Event.Name, Convert.ToChar(2), Event.Description, Convert.ToChar(2), Event.Started, Convert.ToChar(2) }));
                        Count++;
                    }
                }
                return (Encoding.encodeVL64(Count) + List.ToString());
            }
            catch
            {
                return "H";
            }
        }

        public static void Init()
        {
            try
            {
                deadEventDropper.Abort();
            }
            catch
            {
            }
            categoryAmount = int.Parse(Config.getTableEntry("events_categorycount"));
            Events = new Hashtable[categoryAmount];
            for (int i = 0; i < categoryAmount; i++)
            {
                Events[i] = new Hashtable();
            }
            deadEventDropInterval = int.Parse(Config.getTableEntry("events_deadevents_removeinterval")) * 0x3e8;
            deadEventDropper = new Thread(new ThreadStart(eventManager.dropDeadEvents));
            deadEventDropper.Priority = ThreadPriority.BelowNormal;
            deadEventDropper.Start();
        }

        public static void removeEvent(int roomID)
        {
            for (int i = 0; i < categoryAmount; i++)
            {
                if (Events[i].ContainsKey(roomID))
                {
                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery("DELETE FROM events WHERE roomid = '" + roomID + "'");
                    }
                    Events[i].Remove(roomID);
                    break;
                }
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct virtualEvent
        {
            internal int roomID;
            internal int userID;
            internal string Name;
            internal string Description;
            internal string Started;
            internal virtualEvent(int roomID, int userID, string Name, string Description)
            {
                this.roomID = roomID;
                this.userID = userID;
                this.Name = Name;
                this.Description = Description;
                this.Started = DateTime.Now.ToShortTimeString();
            }
        }
    }
}