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

    public static class catalogueManager
    {
        private static Hashtable cataloguePages;
        private static Hashtable itemCache;

        private static void cachePage(int pageID)
        {
            DataRow dRow;
            DatabaseClient dbClient;
            using (dbClient = Eucalypt.dbManager.GetClient())
            {
                dRow = dbClient.getRow("SELECT indexname,minrank,displayname,style_layout,img_header,img_side,label_description,label_misc,label_moredetails FROM catalogue_pages WHERE indexid = '" + pageID + "' LIMIT 1");
            }
            if ((pageID <= 0) || (dRow.Table.Rows.Count != 0))
            {
                DataTable dTable;
                object[] pageObject = dRow.ItemArray;
                string[] pageData = new string[pageObject.Length];
                for (int a = 0; a < pageData.Length; a++)
                {
                    pageData[a] = pageObject[a].ToString();
                }
                string pageIndexName = "";
                StringBuilder pageBuilder = new StringBuilder();
                cataloguePage objPage = new cataloguePage();
                if (pageID > 0)
                {
                    pageIndexName = pageData[0];
                    objPage.displayName = pageData[2];
                    objPage.minRank = Convert.ToByte(bool.Parse(pageData[1]));
                    pageBuilder.Append(string.Concat(new object[] { "i:", pageIndexName, Convert.ToChar(13), "n:", pageData[2], Convert.ToChar(13), "l:", pageData[3], Convert.ToChar(13) }));
                    if (pageData[4] != "")
                    {
                        pageBuilder.Append("g:" + pageData[4] + Convert.ToChar(13));
                    }
                    if (pageData[5] != "")
                    {
                        pageBuilder.Append("e:" + pageData[5] + Convert.ToChar(13));
                    }
                    if (pageData[6] != "")
                    {
                        pageBuilder.Append("h:" + pageData[6] + Convert.ToChar(13));
                    }
                    if (pageData[8] != "")
                    {
                        pageBuilder.Append("w:" + pageData[8] + Convert.ToChar(13));
                    }
                    if (pageData[7] != "")
                    {
                        string[] miscDetail = pageData[7].Split(new char[] { Convert.ToChar(13) });
                        for (int m = 0; m < miscDetail.Length; m++)
                        {
                            pageBuilder.Append(miscDetail[m] + Convert.ToChar(13));
                        }
                    }
                }
                using (dbClient = Eucalypt.dbManager.GetClient())
                {
                    dTable = dbClient.getTable("SELECT tid, typeid, length, width, catalogue_cost, door, tradeable, recycleable, catalogue_name, catalogue_description, name_cct, colour, top FROM catalogue_items WHERE catalogue_id_page = '" + pageID + "' ORDER BY catalogue_id_index ASC");
                }
                int count = dTable.Rows.Count;
                int[] itemTemplateIDs = new int[count];
                int[] itemTypeIDs = new int[count];
                int[] itemLengths = new int[count];
                int[] itemWidths = new int[count];
                int[] itemCosts = new int[count];
                int[] itemDoorFlags = new int[count];
                int[] itemTradeableFlags = new int[count];
                int[] itemRecycleableFlags = new int[count];
                string[] itemNames = new string[count];
                string[] itemDescs = new string[count];
                string[] itemCCTs = new string[count];
                string[] itemColours = new string[count];
                string[] itemTopHs = new string[count];
                int i = 0;
                foreach (DataRow dbRow in dTable.Rows)
                {
                    itemTemplateIDs[i] = Convert.ToInt32(dbRow["tid"]);
                    itemTypeIDs[i] = Convert.ToInt32(dbRow["typeid"]);
                    itemLengths[i] = Convert.ToInt32(dbRow["length"]);
                    itemWidths[i] = Convert.ToInt32(dbRow["width"]);
                    itemCosts[i] = Convert.ToInt32(dbRow["catalogue_cost"]);
                    itemDoorFlags[i] = Convert.ToInt32(dbRow["door"]);
                    itemTradeableFlags[i] = Convert.ToInt32(dbRow["tradeable"]);
                    itemRecycleableFlags[i] = Convert.ToInt32(dbRow["recycleable"]);
                    itemNames[i] = Convert.ToString(dbRow["catalogue_name"]);
                    itemDescs[i] = Convert.ToString(dbRow["catalogue_description"]);
                    itemCCTs[i] = Convert.ToString(dbRow["name_cct"]);
                    itemColours[i] = Convert.ToString(dbRow["colour"]);
                    itemTopHs[i] = Convert.ToString(dbRow["top"]);
                    i++;
                }
                for (i = 0; i < itemTemplateIDs.Length; i++)
                {
                    if (stringManager.getStringPart(itemCCTs[i], 0, 4) != "deal")
                    {
                        itemCache.Add(itemTemplateIDs[i], new itemTemplate(itemCCTs[i], Convert.ToByte(itemTypeIDs[i]), itemColours[i], itemLengths[i], itemWidths[i], double.Parse(itemTopHs[i]), itemDoorFlags[i] == 1, itemTradeableFlags[i] == 1, itemRecycleableFlags[i] == 1));
                        if (pageID != -1)
                        {
                            pageBuilder.Append(string.Concat(new object[] { "p:", itemNames[i], Convert.ToChar(9), itemDescs[i], Convert.ToChar(9), itemCosts[i], Convert.ToChar(9), Convert.ToChar(9) }));
                            if (itemTypeIDs[i] == 0)
                            {
                                pageBuilder.Append("i");
                            }
                            else
                            {
                                pageBuilder.Append("s");
                            }
                            pageBuilder.Append(Convert.ToChar(9) + itemCCTs[i] + Convert.ToChar(9));
                            if (itemTypeIDs[i] == 0)
                            {
                                pageBuilder.Append(Convert.ToChar(9));
                            }
                            else
                            {
                                pageBuilder.Append("0" + Convert.ToChar(9));
                            }
                            if (itemTypeIDs[i] == 0)
                            {
                                pageBuilder.Append(Convert.ToChar(9));
                            }
                            else
                            {
                                pageBuilder.Append(string.Concat(new object[] { itemLengths[i], ",", itemWidths[i], Convert.ToChar(9) }));
                            }
                            pageBuilder.Append(itemCCTs[i] + Convert.ToChar(9));
                            if (itemTypeIDs[i] > 0)
                            {
                                pageBuilder.Append(itemColours[i]);
                            }
                            pageBuilder.Append(Convert.ToChar(13));
                        }
                    }
                    else
                    {
                        int dealID = int.Parse(itemCCTs[i].Substring(4));
                        using (dbClient = Eucalypt.dbManager.GetClient())
                        {
                            dTable = dbClient.getTable("SELECT tid, amount FROM catalogue_deals WHERE id = '" + dealID + "'");
                        }
                        count = dTable.Rows.Count;
                        int[] dealItemIDs = new int[count];
                        int[] dealItemAmounts = new int[count];
                        int n = 0;
                        foreach (DataRow dbRow in dTable.Rows)
                        {
                            dealItemIDs[n] = Convert.ToInt32(dbRow["tid"]);
                            dealItemAmounts[n] = Convert.ToInt32(dbRow["amount"]);
                            n++;
                        }
                        pageBuilder.Append(string.Concat(new object[] { "p:", itemNames[i], Convert.ToChar(9), itemDescs[i], Convert.ToChar(9), itemCosts[i], Convert.ToChar(9), Convert.ToChar(9), "d" }));
                        pageBuilder.Append(Convert.ToChar(9), 4);
                        pageBuilder.Append(string.Concat(new object[] { "deal", dealID, Convert.ToChar(9), Convert.ToChar(9), dealItemIDs.Length, Convert.ToChar(9) }));
                        for (int l = 0; l < dealItemIDs.Length; l++)
                        {
                            using (dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dRow = dbClient.getRow("SELECT name_cct, colour FROM catalogue_items WHERE tid = '" + dealItemIDs[l] + "' LIMIT 1");
                            }
                            string itemCCT = Convert.ToString(dRow["name_cct"]);
                            string itemColour = Convert.ToString(dRow["colour"]);
                            pageBuilder.Append(string.Concat(new object[] { itemCCT, Convert.ToChar(9), dealItemAmounts[l], Convert.ToChar(9), itemColour, Convert.ToChar(9) }));
                        }
                    }
                }
                if (pageID != -1)
                {
                    objPage.pageData = pageBuilder.ToString();
                    cataloguePages.Add(pageIndexName, objPage);
                }
            }
        }

        public static string getPage(string pageName, byte userRank)
        {
            try
            {
                cataloguePage objPage = (cataloguePage) cataloguePages[pageName];
                if (userRank < objPage.minRank)
                {
                    return "holo.cast.catalogue.access_denied";
                }
                return objPage.pageData;
            }
            catch
            {
                return "cast_catalogue.access_denied";
            }
        }

        public static bool getPageExists(string pageName)
        {
            return cataloguePages.ContainsKey(cataloguePages.ContainsKey(pageName));
        }

        public static string getPageIndex(byte userRank)
        {
            try
            {
                DataColumn dCol;
                StringBuilder listBuilder = new StringBuilder();
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    dCol = dbClient.getColumn("SELECT indexname FROM catalogue_pages WHERE minrank <= '" + userRank + "' ORDER BY indexid ASC");
                }
                string[] pageNames = dataHandling.dColToArray(dCol);
                for (int i = 0; i < pageNames.Length; i++)
                {
                    if (cataloguePages.ContainsKey(pageNames[i]))
                    {
                        listBuilder.Append(string.Concat(new object[] { pageNames[i], Convert.ToChar(9), ((cataloguePage) cataloguePages[pageNames[i]]).displayName, Convert.ToChar(13) }));
                    }
                }
                return listBuilder.ToString();
            }
            catch
            {
                return Convert.ToChar(13).ToString();
            }
        }

        public static itemTemplate getTemplate(int templateID)
        {
            try
            {
                return (itemTemplate) itemCache[templateID];
            }
            catch
            {
                return new itemTemplate();
            }
        }

        public static void handlePurchase(int templateID, int receiverID, int roomID, string decorID, int presentBoxID, int teleportID1)
        {
            int itemID;
            DatabaseClient dbClient;
            string Sprite = getTemplate(templateID).Sprite;
            bool handlePresentbox = true;
            switch (Sprite)
            {
                case "landscape":
                case "wallpaper":
                case "floor":
                    itemID = lastItemID;
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", decorID, "' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                    break;

                case "roomdimmer":
                {
                    itemID = lastItemID;
                    string defaultPreset = "1,#000000,155";
                    string defaultSetPreset = "1,1,1,#000000,155";
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_moodlight(id,roomid,preset_cur,preset_1,preset_2,preset_3) VALUES ('", itemID, "','0','1','", defaultPreset, "','", defaultPreset, "','", defaultPreset, "')" }));
                        dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", defaultSetPreset, "' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                    break;
                }
                case "door":
                case "env_telep":
                case "lostc_teleport":
                case "doorB":
                case "xmas08_telep":
                case "ads_cltele":
                case "ads_mall_tele":
                case "ads_idol_tele":
                case "doorC":
                case "doorD":
                case "teleport_door":
                {
                    int itemID1 = teleportID1;
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,ownerid,roomid,teleportid) VALUES ('", templateID, "','", receiverID, "','", roomID, "','", itemID1, "')" }));
                        int itemID2 = lastItemID;
                        dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET teleportid = '", itemID2, "' WHERE id = '", itemID1, "' LIMIT 1" }));
                        if (presentBoxID > 0)
                        {
                            dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", presentBoxID, "','", itemID1, "')" }));
                            dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", presentBoxID, "','", itemID2, "')" }));
                        }
                    }
                    handlePresentbox = false;
                    break;
                }
                case "post.it":
                case "post.it.vd":
                    itemID = lastItemID;
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery("UPDATE furniture SET var = '20' WHERE id = '" + itemID + "' LIMIT 1");
                    }
                    break;

                default:
                    if (stringManager.getStringPart(Sprite, 0, 10) == "sound_set_")
                    {
                        itemID = lastItemID;
                        int soundSet = int.Parse(Sprite.Substring(10));
                        using (dbClient = Eucalypt.dbManager.GetClient())
                        {
                            dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET soundmachine_soundset = '", soundSet, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                    }
                    break;
            }
            if ((presentBoxID > 0) && handlePresentbox)
            {
                using (dbClient = Eucalypt.dbManager.GetClient())
                {
                    dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", presentBoxID, "','", lastItemID, "')" }));
                }
            }
        }

        public static void Init(bool Update)
        {
            DataColumn dCol;
            Out.WriteLine("Starting caching of catalogue + items...");
            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {
                dCol = dbClient.getColumn("SELECT indexid FROM catalogue_pages ORDER BY indexid");
            }
            cataloguePages = new Hashtable();
            itemCache = new Hashtable();
            foreach (DataRow dRow in dCol.Table.Rows)
            {
                cachePage(Convert.ToInt32(dRow["indexid"]));
            }
            cachePage(-1);
            Out.WriteLine(string.Concat(new object[] { "Successfully cached ", cataloguePages.Count, " catalogue pages and ", itemCache.Count, " item templates!" }));
            if (Update)
            {
                Thread.CurrentThread.Abort();
            }
        }

        public static string tradeItemList(int[] itemIDs)
        {
            StringBuilder List = new StringBuilder();
            for (int i = 0; i < itemIDs.Length; i++)
            {
                if (itemIDs[i] != 0)
                {
                    DataRow dRow;
                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dRow = dbClient.getRow("SELECT tid, var FROM furniture WHERE id = '" + itemIDs[i] + "'");
                    }
                    itemTemplate Template = getTemplate(Convert.ToInt32(dRow["tid"]));
                    List.Append(string.Concat(new object[] { "SI", Convert.ToChar(30).ToString(), itemIDs[i], Convert.ToChar(30).ToString(), i, Convert.ToChar(30) }));
                    if (Template.typeID > 0)
                    {
                        List.Append("S");
                    }
                    else
                    {
                        List.Append("I");
                    }
                    List.Append(string.Concat(new object[] { Convert.ToChar(30).ToString(), itemIDs[i], Convert.ToChar(30).ToString(), Template.Sprite, Convert.ToChar(30) }));
                    if (Template.typeID > 0)
                    {
                        List.Append(string.Concat(new object[] { Template.Length, Convert.ToChar(30).ToString(), Template.Width, Convert.ToChar(30).ToString(), Convert.ToString(dRow["var"]), Convert.ToChar(30).ToString() }));
                    }
                    List.Append(string.Concat(new object[] { Template.Colour, Convert.ToChar(30).ToString(), i, Convert.ToChar(30).ToString(), "/" }));
                }
            }
            return List.ToString();
        }

        public static string wallPositionOK(string wallPosition)
        {
            try
            {
                string[] posD = wallPosition.Split(new char[] { ' ' });
                if ((posD[2] != "l") && (posD[2] != "r"))
                {
                    return "";
                }
                string[] widD = posD[0].Substring(3).Split(new char[] { ',' });
                int widthX = int.Parse(widD[0]);
                int widthY = int.Parse(widD[1]);
                if ((((widthX < 0) || (widthY < 0)) || (widthX > 200)) || (widthY > 200))
                {
                    return "";
                }
                string[] lenD = posD[1].Substring(2).Split(new char[] { ',' });
                int lengthX = int.Parse(lenD[0]);
                int lengthY = int.Parse(lenD[1]);
                if ((((lengthX < 0) || (lengthY < 0)) || (lengthX > 200)) || (lengthY > 200))
                {
                    return "";
                }
                return string.Concat(new object[] { ":w=", widthX, ",", widthY, " l=", lengthX, ",", lengthY, " ", posD[2] });
            }
            catch
            {
                return "";
            }
        }

        public static int lastItemID
        {
            get
            {
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    return dbClient.getInt("SELECT MAX(id) FROM furniture");
                }
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct cataloguePage
        {
            internal string displayName;
            internal string pageData;
            internal byte minRank;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct itemTemplate
        {
            internal byte typeID;
            internal string Sprite;
            internal string Colour;
            internal int Length;
            internal int Width;
            internal double topH;
            internal bool isDoor;
            internal bool isTradeable;
            internal bool isRecycleable;
            public itemTemplate(bool b)
            {
                this.typeID = 1;
                this.Sprite = "";
                this.Colour = "null";
                this.Length = 1;
                this.Width = 1;
                this.topH = 0.0;
                this.isDoor = false;
                this.isTradeable = true;
                this.isRecycleable = false;
            }

            public itemTemplate(string Sprite, byte typeID, string Colour, int Length, int Width, double topH, bool isDoor, bool isTradeable, bool isRecycleable)
            {
                if (Sprite.Contains(" "))
                {
                    this.Sprite = Sprite.Split(new char[] { ' ' })[0];
                    this.Colour = Sprite.Split(new char[] { ' ' })[1];
                }
                else
                {
                    this.Sprite = Sprite;
                    this.Colour = Colour;
                }
                this.typeID = typeID;
                this.Length = Length;
                this.Width = Width;
                this.topH = topH;
                this.isDoor = isDoor;
                this.isTradeable = isTradeable;
                this.isRecycleable = isRecycleable;
            }
        }
    }
}