using System;
using System.Data;
using System.Text;
using System.Threading;
using System.Collections;

using Holo.Virtual.Users;
using Ion.Storage;
namespace Holo.Managers
{
    public static class eventManager
    {
        #region Declares
        private static Hashtable[] Events;
        private static Thread deadEventDropper;
        private static int deadEventDropInterval;
        internal static int categoryAmount;
        #endregion

        #region Manager voids

        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")) * 1000;
            deadEventDropper = new Thread(new ThreadStart(dropDeadEvents));
            deadEventDropper.Priority = ThreadPriority.BelowNormal;
            deadEventDropper.Start();
        }
  
        private static void dropDeadEvents()
        {
            while (true)
            {                
                for (int i = 0; i < categoryAmount; i++)
                {
                    foreach (virtualEvent Event in ((Hashtable)Events[i].Clone()).Values)
                    {
                        if (userManager.containsUser(Event.userID) == false)
                        {
                            using (DatabaseClient 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 (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                                {
                                    dbClient.runQuery("DELETE FROM events WHERE roomid = '" + Event.roomID + "'");
                                }
                                Events[i].Remove(Event.roomID);
                                Hoster._hostsEvent = false;
                            }
                        }
                    }
                }

                Thread.Sleep(deadEventDropInterval); // Sleep the configured amount of time before repeating
            }
        }
        #endregion

        #region Event management
        public static void createEvent(int categoryID, int userID, int roomID, string Name, string Description)
        {
            if (Events[categoryID - 1].Contains(roomID) == false)
            {
                virtualEvent Event = new virtualEvent(roomID, userID, Name, Description);
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    dbClient.AddParamWithValue("ename", Name);
                    dbClient.AddParamWithValue("edescription", Description);
                    dbClient.runQuery("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);
            }
        }

        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);
                    return;
                }
            }
        }

        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("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 bool categoryOK(int categoryID)
        {
            return (categoryID > 0 && categoryID <= categoryAmount);
        }

        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)) // Hoster is online
                    {
                        List.Append(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 string getEvent(int roomID)
        {
            try
            {
                for (int i = 0; i < categoryAmount; i++)
                {
                    if (Events[i].ContainsKey(roomID))
                    {
                        virtualEvent Event = (virtualEvent)Events[i][roomID];
                        return 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"; }
        }
        #endregion

        #region Private objects
        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();
            }
        }
        #endregion
    }
}