using System;
using System.Collections.Generic;
using Server.ContextMenus;
using Server.Engines.Craft;
using Server.Gumps;
using Server.Mobiles;
using Server.Multis;
using Server.Network;

namespace Server.Items
{
    public class Runebook : Item, ISecurable, ICraftable
    {
        public override int LabelNumber { get { return 1041267; } } // runebook

        public static readonly TimeSpan UseDelay = TimeSpan.FromSeconds(7.0);

        private BookQuality m_Quality;

        [CommandProperty(AccessLevel.GameMaster)]
        public BookQuality Quality
        {
            get
            {
                return m_Quality;
            }
            set
            {
                m_Quality = value;
                InvalidateProperties();
            }
        }

        private List<RunebookEntry> m_Entries;
        private string m_Description;
        private Mobile m_Crafter;

        [CommandProperty(AccessLevel.GameMaster)]
        public DateTime NextUse { get; set; }

        [CommandProperty(AccessLevel.GameMaster)]
        public Mobile Crafter
        {
            get
            {
                return m_Crafter;
            }
            set
            {
                m_Crafter = value;
                InvalidateProperties();
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public SecureLevel Level { get; set; }

        [CommandProperty(AccessLevel.GameMaster)]
        public string Description
        {
            get
            {
                return m_Description;
            }
            set
            {
                m_Description = value;
                InvalidateProperties();
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public int CurCharges { get; set; }

        [CommandProperty(AccessLevel.GameMaster)]
        public int MaxCharges { get; set; }

        public List<Mobile> Openers { get; set; } = new List<Mobile>();

        public virtual int MaxEntries { get { return 16; } }

        [Constructable]
        public Runebook(int maxCharges, int id = 0x22C5)
            : base(Core.AOS ? id : 0xEFA)
        {
            Weight = (Core.SE ? 1.0 : 3.0);
            LootType = LootType.Blessed;
            Hue = 0x461;

            Layer = (Core.AOS ? Layer.Invalid : Layer.OneHanded);

            m_Entries = new List<RunebookEntry>();

            MaxCharges = maxCharges;

            DefaultIndex = -1;

            Level = SecureLevel.CoOwners;
        }

        [Constructable]
        public Runebook()
            : this(Core.SE ? 12 : 6)
        {
        }

        public List<RunebookEntry> Entries { get { return m_Entries; } }

        public int DefaultIndex { get; set; }

        public RunebookEntry Default
        {
            get
            {
                if (DefaultIndex >= 0 && DefaultIndex < m_Entries.Count)
                    return m_Entries[DefaultIndex];

                return null;
            }
            set
            {
                if (value == null)
                    DefaultIndex = -1;
                else
                    DefaultIndex = m_Entries.IndexOf(value);
            }
        }

        public Runebook(Serial serial)
            : base(serial)
        {
        }

        public override bool AllowEquipedCast(Mobile from)
        {
            return true;
        }

        public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
        {
            base.GetContextMenuEntries(from, list);
            SetSecureLevelEntry.AddTo(from, this, list);
        }

        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);
            writer.Write((int)3);

            writer.Write((byte)m_Quality);

            writer.Write(m_Crafter);

            writer.Write((int)Level);

            writer.Write(m_Entries.Count);

            for (int i = 0; i < m_Entries.Count; ++i)
                m_Entries[i].Serialize(writer);

            writer.Write(m_Description);
            writer.Write(CurCharges);
            writer.Write(MaxCharges);
            writer.Write(DefaultIndex);
        }

        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);
            int version = reader.ReadInt();

            LootType = LootType.Blessed;

            if (Core.SE && Weight == 3.0)
                Weight = 1.0;

            switch (version)
            {
                case 3:
                    {
                        m_Quality = (BookQuality)reader.ReadByte();
                        goto case 2;
                    }
                case 2:
                    {
                        m_Crafter = reader.ReadMobile();
                        goto case 1;
                    }
                case 1:
                    {
                        Level = (SecureLevel)reader.ReadInt();
                        goto case 0;
                    }
                case 0:
                    {
                        int count = reader.ReadInt();

                        m_Entries = new List<RunebookEntry>(count);

                        for (int i = 0; i < count; ++i)
                            m_Entries.Add(new RunebookEntry(reader));

                        m_Description = reader.ReadString();
                        CurCharges = reader.ReadInt();
                        MaxCharges = reader.ReadInt();
                        DefaultIndex = reader.ReadInt();

                        break;
                    }
            }
        }

        public void DropRune(Mobile from, RunebookEntry e, int index)
        {
            if (DefaultIndex > index)
                DefaultIndex -= 1;
            else if (DefaultIndex == index)
                DefaultIndex = -1;

            m_Entries.RemoveAt(index);


            RecallRune rune = new RecallRune();

            if (e.Galleon != null)
            {
                rune.Galleon = e.Galleon;
            }
            else if (e.House != null)
            {
                rune.Target = e.Location;
                rune.TargetMap = e.Map;
                rune.Description = e.Description;
                rune.House = e.House;
            }
            else
            {
                rune.Target = e.Location;
                rune.TargetMap = e.Map;
                rune.Description = e.Description;
            }

            rune.Type = e.Type;
            rune.Marked = true;

            from.AddToBackpack(rune);

            from.SendLocalizedMessage(502421, "", 0x35); // You have removed the rune.
        }

        public bool IsOpen(Mobile toCheck)
        {
            return HasGump(toCheck);
        }

        public virtual bool HasGump(Mobile toCheck)
        {
            var bookGump = toCheck.FindGump<RunebookGump>();

            if (bookGump != null && bookGump.Book == this)
            {
                return true;
            }

            return false;
        }

        public virtual void CloseGump(Mobile m)
        {
            m.CloseGump(typeof(RunebookGump));
        }

        public override bool DisplayLootType
        {
            get
            {
                return Core.AOS;
            }
        }

        public override void GetProperties(ObjectPropertyList list)
        {
            base.GetProperties(list);

            if (m_Quality == BookQuality.Exceptional)
                list.Add(1063341); // exceptional

            if (m_Crafter != null)
                list.Add(1050043, m_Crafter.TitleName); // crafted by ~1_NAME~

            if (m_Description != null && m_Description.Length > 0)
                list.Add(m_Description);
        }

        public override bool OnDragLift(Mobile from)
        {
            if (HasGump(from))
            {
                from.SendLocalizedMessage(500169); // You cannot pick that up.
                return false;
            }

            foreach (Mobile m in Openers)
            {
                if (IsOpen(m))
                {
                    CloseGump(m);
                }
            }

            Openers.Clear();

            return true;
        }

        public override void OnSingleClick(Mobile from)
        {
            if (m_Description != null && m_Description.Length > 0)
                LabelTo(from, m_Description);

            base.OnSingleClick(from);

            if (m_Crafter != null)
                LabelTo(from, 1050043, m_Crafter.TitleName);
        }

        public override void OnDoubleClick(Mobile from)
        {
            if (from.InRange(GetWorldLocation(), (Core.ML ? 3 : 1)) && CheckAccess(from))
            {
                if (RootParent is BaseCreature)
                {
                    from.SendLocalizedMessage(502402); // That is inaccessible.
                    return;
                }

                if (DateTime.UtcNow < NextUse)
                {
                    from.SendLocalizedMessage(502406); // This book needs time to recharge.
                    return;
                }

                from.CloseGump(typeof(RunebookGump));
                from.SendGump(new RunebookGump(from, this));

                Openers.Add(from);
            }
        }

        public virtual void OnTravel()
        {
            if (!Core.SA)
                NextUse = DateTime.UtcNow + UseDelay;
        }

        public override void OnAfterDuped(Item newItem)
        {
            Runebook book = newItem as Runebook;

            if (book == null)
                return;

            book.m_Entries = new List<RunebookEntry>();

            for (int i = 0; i < m_Entries.Count; i++)
            {
                RunebookEntry entry = m_Entries[i];

                book.m_Entries.Add(new RunebookEntry(entry.Location, entry.Map, entry.Description, entry.House, entry.Type));
            }

            base.OnAfterDuped(newItem);
        }

        public bool CheckAccess(Mobile m)
        {
            if (!IsLockedDown || m.AccessLevel >= AccessLevel.GameMaster)
                return true;

            BaseHouse house = BaseHouse.FindHouseAt(this);

            if (house != null && house.IsAosRules && (house.Public ? house.IsBanned(m) : !house.HasAccess(m)))
                return false;

            return house != null && house.HasSecureAccess(m, Level);
        }

        public override bool OnDragDrop(Mobile from, Item dropped)
        {
            if (dropped is RecallRune)
            {
                if (IsLockedDown && from.AccessLevel < AccessLevel.GameMaster)
                {
                    from.SendLocalizedMessage(502413, null, 0x35); // That cannot be done while the book is locked down.
                }
                else if (IsOpen(from))
                {
                    from.SendLocalizedMessage(1005571); // You cannot place objects in the book while viewing the contents.
                }
                else if (m_Entries.Count < MaxEntries)
                {
                    if (dropped is RecallRune)
                    {
                        RecallRune rune = (RecallRune)dropped;

                        if (rune.Marked)
                        {
                            if (rune.Type == RecallRuneType.Ship)
                            {
                                RunebookEntry entry = new RunebookEntry(Point3D.Zero, null, null, null, rune.Type, rune.Galleon);
                                m_Entries.Add(entry);

                                dropped.Delete();

                                from.Send(new PlaySound(0x42, GetWorldLocation()));

                                from.SendAsciiMessage(entry.Description);

                                return true;
                            }
                            else if (rune.TargetMap != null)
                            {
                                m_Entries.Add(new RunebookEntry(rune.Target, rune.TargetMap, rune.Description, rune.House, rune.Type));

                                dropped.Delete();

                                from.Send(new PlaySound(0x42, GetWorldLocation()));

                                string desc = rune.Description;

                                if (desc == null || (desc = desc.Trim()).Length == 0)
                                    desc = "(indescript)";

                                from.SendAsciiMessage(desc);

                                return true;
                            }
                        }
                        else
                        {
                            from.SendLocalizedMessage(502409); // This rune does not have a marked location.
                        }
                    }
                }
                else
                {
                    from.SendLocalizedMessage(502401); // This runebook is full.
                }
            }
            else if (dropped is RecallScroll)
            {
                if (CurCharges < MaxCharges)
                {
                    from.Send(new PlaySound(0x249, GetWorldLocation()));

                    int amount = dropped.Amount;

                    if (amount > (MaxCharges - CurCharges))
                    {
                        dropped.Consume(MaxCharges - CurCharges);
                        CurCharges = MaxCharges;
                    }
                    else
                    {
                        CurCharges += amount;
                        dropped.Delete();

                        return true;
                    }
                }
                else
                {
                    from.SendLocalizedMessage(502410); // This book already has the maximum amount of charges.
                }
            }

            return false;
        }

        #region ICraftable Members

        public virtual int OnCraft(int quality, bool makersMark, Mobile from, CraftSystem craftSystem, Type typeRes, ITool tool, CraftItem craftItem, int resHue)
        {
            int charges = 5 + quality + (int)(from.Skills[SkillName.Inscribe].Value / 30);

            if (charges > 10)
                charges = 10;

            MaxCharges = (Core.SE ? charges * 2 : charges);

            if (makersMark)
                Crafter = from;

            m_Quality = (BookQuality)(quality - 1);

            return quality;
        }
        #endregion
    }

    public class RunebookEntry
    {
        private readonly Point3D m_Location;
        private readonly Map m_Map;
        private readonly string m_Description;

        public Point3D Location
        {
            get
            {
                if (Galleon != null && !Galleon.Deleted)
                {
                    return Galleon.GetMarkedLocation();
                }

                return m_Location;
            }
        }

        public Map Map
        {
            get
            {
                if (Galleon != null && !Galleon.Deleted && Galleon.Map != Map.Internal && Galleon.Map != null)
                {
                    return Galleon.Map;
                }

                return m_Map;
            }
        }

        public string Description
        {
            get
            {
                if (Type == RecallRuneType.Ship)
                {
                    string ownername;
                    string shipname;

                    if (Galleon == null)
                    {
                        ownername = "unknown owner";
                        shipname = "unknown ship";
                    }
                    else
                    {
                        if (Galleon.Owner != null)
                        {
                            ownername = Galleon.Owner.Name;
                        }
                        else
                        {
                            ownername = "unknown owner";
                        }

                        if (Galleon.ShipName != null)
                        {
                            shipname = Galleon.ShipName;
                        }
                        else
                        {
                            shipname = "unnamed ship";
                        }
                    }

                    return string.Format("{0}'s ship, the {1}", ownername, shipname);
                }

                return m_Description;
            }
        }

        public BaseHouse House { get; }

        public BaseGalleon Galleon { get; }

        public RecallRuneType Type { get; }

        public RunebookEntry(Point3D loc, Map map, string desc, BaseHouse house, RecallRuneType type = 0, BaseGalleon g = null)
        {
            m_Location = loc;
            m_Map = map;
            m_Description = desc;
            House = house;
            Galleon = g;
            Type = type;
        }

        public RunebookEntry(GenericReader reader)
        {
            int version = reader.ReadByte();

            switch (version)
            {
                case 3:
                    {
                        Type = (RecallRuneType)reader.ReadInt();
                        Galleon = reader.ReadItem() as BaseGalleon;
                        House = reader.ReadItem() as BaseHouse;
                        m_Location = reader.ReadPoint3D();
                        m_Map = reader.ReadMap();
                        m_Description = reader.ReadString();

                        break;
                    }
                case 2:
                    {
                        Galleon = reader.ReadItem() as BaseGalleon;
                        goto case 0;
                    }
                case 1:
                    {
                        House = reader.ReadItem() as BaseHouse;
                        goto case 0;
                    }
                case 0:
                    {
                        m_Location = reader.ReadPoint3D();
                        m_Map = reader.ReadMap();
                        m_Description = reader.ReadString();

                        break;
                    }
            }

            if (version < 3)
            {
                if (Galleon != null)
                    Type = RecallRuneType.Ship;
                else if (House != null)
                    Type = RecallRuneType.Shop;
                else
                    Type = RecallRuneType.Normal;
            }
        }

        public void Serialize(GenericWriter writer)
        {
            writer.Write((byte)3);

            writer.Write((int)Type);
            writer.Write(Galleon);
            writer.Write(House);
            writer.Write(m_Location);
            writer.Write(m_Map);
            writer.Write(m_Description);
        }
    }
}