using System;
using System.Collections.Generic;
using System.Linq;
using Server.Engines.Craft;
using Server.Gumps;
using Server.Mobiles;
using Server.Network;
using Server.Prompts;

namespace Server.Items
{
    public class RecipeBookGump : Gump
    {
        private RecipeBook m_Book;
        private List<RecipeScrollDefinition> m_List;

        private int m_Page;

        private const int LabelColor = 0xFFFFFF;
        
        public bool CheckFilter(RecipeScrollDefinition recipe)
        {
            RecipeScrollFilter f = m_Book.Filter;
            
            if (f.IsDefault)
                return true;
            
            if (f.Skill == 1 && recipe.Skill != RecipeSkillName.Blacksmith )
            {
                return false;
            }
            else if (f.Skill == 2 && recipe.Skill != RecipeSkillName.Tailoring)
            {
                return false;
            }
            else if (f.Skill == 3 && recipe.Skill != RecipeSkillName.Fletching)
            {
                return false;
            }
            else if (f.Skill == 4 && recipe.Skill != RecipeSkillName.Carpentry && recipe.Skill != RecipeSkillName.Masonry)
            {
                return false;
            }
            else if (f.Skill == 5 && recipe.Skill != RecipeSkillName.Inscription)
            {
                return false;
            }
            else if (f.Skill == 6 && recipe.Skill != RecipeSkillName.Cooking)
            {
                return false;
            }
            else if (f.Skill == 7 && recipe.Skill != RecipeSkillName.Alchemy)
            {
                return false;
            }
            else if (f.Skill == 8 && recipe.Skill != RecipeSkillName.Tinkering)
            {
                return false;
            }
            else if (f.Skill == 9 && recipe.Skill != RecipeSkillName.Cartography)
            {
                return false;
            }

            if (f.Expansion == 1 && recipe.Expansion != Expansion.ML)
            {
                return false;
            }
            else if (f.Expansion == 2 && recipe.Expansion != Expansion.SA)
            {
                return false;
            }
            else if (f.Expansion == 3 && recipe.Expansion != Expansion.TOL)
            {
                return false;
            }

            
            if (f.Amount == 1 && recipe.Amount == 0)
            {
                return false;
            }

            return true;
        }

        public int GetIndexForPage(int page)
        {
            int index = 0;

            while (page-- > 0)
                index += GetCountForIndex(index);

            return index;
        }

        public int GetCountForIndex(int index)
        {
            int slots = 0;
            int count = 0;

            List<RecipeScrollDefinition> list = m_List;

            for (int i = index; i >= 0 && i < list.Count; ++i)
            {
                var recipe = list[i];

                if (CheckFilter(recipe))
                {
                    int add;

                    add = 1;

                    if ((slots + add) > 10)
                        break;

                    slots += add;
                }

                ++count;
            }

            return count;
        }
        
        public RecipeBookGump(Mobile from, RecipeBook book)
            : this(from, book, 0, null)
        {
        }        

        private class SetPricePrompt : Prompt
        {
            private RecipeBook m_Book;
            private RecipeScrollDefinition m_Recipe;
            private int m_Page;
            private List<RecipeScrollDefinition> m_List;

            public SetPricePrompt(RecipeBook book, RecipeScrollDefinition recipe, int page, List<RecipeScrollDefinition> list)
            {
                m_Book = book;
                m_Recipe = recipe;
                m_Page = page;
                m_List = list;
            }

            public override void OnResponse(Mobile from, string text)
            {
                int price = Utility.ToInt32(text);

                if (price < 0 || price > 250000000)
                {
                    from.SendLocalizedMessage(1062390);
                    m_Book.Using = false;
                }
                else
                {
                    m_Book.Recipes.Find(x => x.RecipeID == m_Recipe.RecipeID).Price = price;

                    from.SendLocalizedMessage(1158822); // Recipe price set.

                    from.SendGump(new RecipeBookGump((PlayerMobile)from, m_Book, m_Page, m_List));
                }
            }
        }

        private string GetExpansion(Expansion expansion)
        {
            switch (expansion)
            {
                default:
                case Expansion.ML:
                    return "Mondain's";
                case Expansion.SA:
                    return "Stygian";
                case Expansion.TOL:
                    return "ToL";                 
            }
        }

        private int GetSkillName(RecipeSkillName skill)
        {
            switch (skill)
            {
                default:
                case RecipeSkillName.Alchemy:
                    return 1002000;
                case RecipeSkillName.Blacksmith:
                    return 1150187;
                case RecipeSkillName.Carpentry:
                    return 1002054;
                case RecipeSkillName.Cartography:
                    return 1002057;
                case RecipeSkillName.Cooking:
                    return 1002063;
                case RecipeSkillName.Fletching:
                    return 1044068;
                case RecipeSkillName.Inscription:
                    return 1002090;
                case RecipeSkillName.Masonry:
                    return 1072392;
                case RecipeSkillName.Tailoring:
                    return 1150188;
                case RecipeSkillName.Tinkering:
                    return 1002162;
            }
        }

        public RecipeBookGump(Mobile from, RecipeBook book, int page, List<RecipeScrollDefinition> list)
            : base(12, 24)
        {
            from.CloseGump(typeof(RecipeBookGump));
            from.CloseGump(typeof(RecipeScrollFilterGump));

            m_Book = book;
            m_Page = page;

            if (list == null)
            {
                list = new List<RecipeScrollDefinition>();
                
                m_Book.Recipes.ForEach(x =>
                {
                    if (CheckFilter(x))
                    {
                        list.Add(x);
                    }
                });
            }

            m_List = list;

            int index = GetIndexForPage(page);
            int count = GetCountForIndex(index);

            int tableIndex = 0;

            PlayerVendor pv = book.RootParent as PlayerVendor;

            bool canLocked = book.IsLockedDown;
            bool canDrop = book.IsChildOf(from.Backpack);
            bool canBuy = (pv != null);
            bool canPrice = (canDrop || canBuy || canLocked);

            if (canBuy)
            {
                VendorItem vi = pv.GetVendorItem(book);

                canBuy = (vi != null && !vi.IsForSale);
            }

            int width = 600;

            if (!canPrice)
                width = 516;

            X = (624 - width) / 2;

            AddPage(0);

            AddBackground(10, 10, width, 439, 5054);
            AddImageTiled(18, 20, width - 17, 420, 2624);

            if (canPrice)
            {
                AddImageTiled(573, 64, 24, 352, 200);
                AddImageTiled(493, 64, 78, 352, 1416);
            }

            if (canDrop)
                AddImageTiled(24, 64, 32, 352, 1416);

            AddImageTiled(58, 64, 36, 352, 200);
            AddImageTiled(96, 64, 133, 352, 1416);
            AddImageTiled(231, 64, 80, 352, 200);
            AddImageTiled(313, 64, 100, 352, 1416);
            AddImageTiled(415, 64, 76, 352, 200);

            list = list.OrderBy(x => x.ID).ToList();

            for (int i = index; i < (index + count) && i >= 0 && i < list.Count; ++i)
            {
                var recipe = list[i];

                if (!CheckFilter(recipe))
                    continue;

                AddImageTiled(24, 94 + (tableIndex * 32), canPrice ? 573 : 489, 2, 2624);
                
                ++tableIndex;
            }

            AddAlphaRegion(18, 20, width - 17, 420);
            AddImage(0, 0, 10460);
            AddImage(width - 15, 5, 10460);
            AddImage(0, 429, 10460);
            AddImage(width - 15, 429, 10460);

            AddHtmlLocalized(266, 32, 200, 32, 1158810, LabelColor, false, false); // Recipe Book

            AddHtmlLocalized(147, 64, 200, 32, 1062214, LabelColor, false, false); // Item
            AddHtmlLocalized(246, 64, 200, 32, 1158814, LabelColor, false, false); // Expansion
            AddHtmlLocalized(336, 64, 200, 32, 1158816, LabelColor, false, false); // Crafting
            AddHtmlLocalized(429, 64, 100, 32, 1062217, LabelColor, false, false); // Amount
            
            AddHtmlLocalized(70, 32, 200, 32, 1062476, LabelColor, false, false); // Set Filter
            AddButton(35, 32, 4005, 4007, 1, GumpButtonType.Reply, 0);

            RecipeScrollFilter f = book.Filter;

            if (f.IsDefault)
                AddHtmlLocalized(canPrice ? 470 : 386, 32, 120, 32, 1062475, 16927, false, false); // Using No Filter
            else if (((PlayerMobile)from).UseOwnFilter)
                AddHtmlLocalized(canPrice ? 470 : 386, 32, 120, 32, 1062451, 16927, false, false); // Using Your Filter
            else
                AddHtmlLocalized(canPrice ? 470 : 386, 32, 120, 32, 1062230, 16927, false, false); // Using Book Filter

            AddButton(375, 416, 4017, 4018, 0, GumpButtonType.Reply, 0);
            AddHtmlLocalized(410, 416, 120, 20, 1011441, LabelColor, false, false); // EXIT

            if (canDrop)
                AddHtmlLocalized(26, 64, 50, 32, 1062212, LabelColor, false, false); // Drop

            if (canPrice)
            {
                AddHtmlLocalized(516, 64, 200, 32, 1062218, LabelColor, false, false); // Price

                if (canBuy)
                    AddHtmlLocalized(576, 64, 200, 32, 1062219, LabelColor, false, false); // Buy
                else
                    AddHtmlLocalized(576, 64, 200, 32, 1062227, LabelColor, false, false); // Set
            }

            tableIndex = 0;

            if (page > 0)
            {
                AddButton(75, 416, 4014, 4016, 2, GumpButtonType.Reply, 0);
                AddHtmlLocalized(110, 416, 150, 20, 1011067, LabelColor, false, false); // Previous page
            }

            if (GetIndexForPage(page + 1) < list.Count)
            {
                AddButton(225, 416, 4005, 4007, 3, GumpButtonType.Reply, 0);
                AddHtmlLocalized(260, 416, 150, 20, 1011066, LabelColor, false, false); // Next page
            }

            for (int i = index; i < (index + count) && i >= 0 && i < list.Count; ++i)
            {
                var recipe = list[i];

                if (!CheckFilter(recipe) || !Recipe.Recipes.ContainsKey(recipe.RecipeID))
                    continue;                

                int y = 96 + (tableIndex++ * 32);

                if (recipe.Amount > 0 && (canDrop || canLocked))
                    AddButton(35, y + 2, 5602, 5606, 4 + (i * 2), GumpButtonType.Reply, 0);                    

                AddLabel(61, y, 0x480, String.Format("{0}", recipe.ID));
                AddHtmlLocalized(103, y, 130, 32, Recipe.Recipes[recipe.RecipeID].TextDefinition.Number, "#103221", 0xFFFFFF, false, false); // ~1_val~
                AddLabel(235, y, 0x480, GetExpansion(recipe.Expansion));
                AddHtmlLocalized(316, y, 100, 20, GetSkillName(recipe.Skill), "#104409", 0xFFFFFF, false, false); // ~1_val~
                AddLabel(421, y, 0x480, recipe.Amount.ToString());

                if (canDrop || (canBuy && recipe.Price > 0))
                {
                    AddButton(579, y + 2, 2117, 2118, 5 + (i * 2), GumpButtonType.Reply, 0);
                    AddLabel(495, y, 1152, recipe.Price.ToString("N0"));
                }
            }
        }

        public override void OnResponse(NetState sender, RelayInfo info)
        {
            Mobile from = sender.Mobile;

            int index = info.ButtonID;

            switch (index)
            {
                case 0: { m_Book.Using = false; break; }
                case 1: 
                    {
                        from.SendGump(new RecipeScrollFilterGump(from, m_Book));
                        break;
                    }
                case 2: 
                    {
                        if (m_Page > 0)
                            from.SendGump(new RecipeBookGump(from, m_Book, m_Page - 1, m_List));

                        return;
                    }
                case 3: 
                    {
                        if (GetIndexForPage(m_Page + 1) < m_List.Count)
                            from.SendGump(new RecipeBookGump(from, m_Book, m_Page + 1, m_List));

                        break;
                    }
                default:
                    {
                        bool canDrop = m_Book.IsChildOf(from.Backpack);
                        bool canPrice = canDrop || (m_Book.RootParent is PlayerVendor);

                        index -= 4;

                        int type = index % 2;
                        index /= 2;

                        if (index < 0 || index >= m_List.Count)
                            break;

                        var recipe = m_List[index];                       

                        if (type == 0)
                        {
                            if (!m_Book.CheckAccessible(from, m_Book))
                            {
                                m_Book.SendLocalizedMessageTo(from, 1061637); // You are not allowed to access this.
                                m_Book.Using = false;
                                break;
                            }

                            if (m_Book.IsChildOf(from.Backpack) || m_Book.IsLockedDown)
                            {
                                if (recipe.Amount == 0)
                                {
                                    from.SendLocalizedMessage(1158821); // The recipe selected is not available.
                                    m_Book.Using = false;
                                    break;
                                }

                                Item item = new RecipeScroll(recipe.RecipeID);

                                if (from.AddToBackpack(item))
                                {
                                    m_Book.Recipes.ForEach(x =>
                                    {
                                        if (x.RecipeID == recipe.RecipeID)
                                            x.Amount = x.Amount - 1;
                                    });

                                    m_Book.InvalidateProperties();

                                    from.SendLocalizedMessage(1158820); // The recipe has been placed in your backpack.

                                    from.SendGump(new RecipeBookGump(from, m_Book, m_Page, null));
                                }
                                else
                                {
                                    m_Book.Using = false;
                                    item.Delete();
                                    from.SendLocalizedMessage(1158819); // There is not enough room in your backpack for the recipe.                                    
                                }
                            }
                            else
                            {
                                m_Book.Using = false;
                            }
                        }
                        else 
                        {
                            if (m_Book.IsChildOf(from.Backpack))
                            {
                                from.Prompt = new SetPricePrompt(m_Book, recipe, m_Page, m_List);
                                from.SendLocalizedMessage(1062383); // Type in a price for the deed:
                            }
                            else if (m_Book.RootParent is PlayerVendor)
                            {                                
                                if (recipe.Amount > 0)
                                {
                                    from.SendGump(new RecipeScrollBuyGump(from, m_Book, recipe, recipe.Price));
                                }
                                else
                                {
                                    m_Book.Using = false;
                                }
                            }
                        }

                        break;
                    }
            }
        }
    }
}