using System;
using Server;
using Server.Mobiles;
using Server.Multis;
using System.Collections.Generic;
using Server.Network;
using Server.Targeting;
using Server.Items;
using Server.Gumps;
using Server.ContextMenus;

namespace Server.Engines.VeteranRewards
{
    public class DaviesLockerAddon : BaseAddon, ISecurable
    {
        public override BaseAddonDeed Deed { get { return new DaviesLockerAddonDeed(m_Entries); } }

        private List<DaviesLockerEntry> m_Entries = new List<DaviesLockerEntry>();
        public List<DaviesLockerEntry> Entries { get { return m_Entries; } }

        private bool m_South;
        private SecureLevel m_Level;

        [CommandProperty(AccessLevel.GameMaster)]
        public bool South
        {
            get { return m_South; }
        }

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

        [Constructable]
        public DaviesLockerAddon(bool south, List<DaviesLockerEntry> list)
        {
            m_South = south;
            m_Entries = list;
            m_Level = SecureLevel.CoOwners;

            if (south)
            {
                AddComponent(new DaviesLockerComponent(19455), 0, 0, 0);
                AddComponent(new DaviesLockerComponent(19456), 1, 0, 0);
                AddComponent(new DaviesLockerComponent(19457), 2, 0, 0);
                AddComponent(new DaviesLockerComponent(19453), 0, 1, 0);
                AddComponent(new DaviesLockerComponent(19452), 1, 1, 0);
                AddComponent(new DaviesLockerComponent(19454), 2, 1, 0);
            }
            else
            {
                AddComponent(new DaviesLockerComponent(19449), 0, 0, 0);
                AddComponent(new DaviesLockerComponent(19448), 1, 0, 0);
                AddComponent(new DaviesLockerComponent(19450), 0, 1, 0);
                AddComponent(new DaviesLockerComponent(19447), 1, 1, 0);
                AddComponent(new DaviesLockerComponent(19451), 0, 2, 0);
                AddComponent(new DaviesLockerComponent(19446), 1, 2, 0);
            }
        }

        /*public override void OnChop(Mobile from)
        {
            if (m_Entries.Count == 0)
                base.OnChop(from);
            else
                from.SendMessage("You cannot re-deed this addon unless it is emtpy!");
        }*/

        public override void OnComponentUsed(AddonComponent component, Mobile from)
        {
            if (from.InRange(component.Location, 2))
            {
                if (CanUse(from))
                {
                    from.CloseGump(typeof(DaviesLockerGump));
                    from.SendGump(new DaviesLockerGump(from, this));
                }
                else
                {
                    from.SendLocalizedMessage(503301, "", 0x22); // You don't have permission to do that.
                }
            }
        }

        public bool CanUse(Mobile from)
        {
            BaseHouse house = BaseHouse.FindHouseAt(this);

            return house != null && house.HasSecureAccess(from, m_Level);
        }

        public void TryAddEntry(Item item, Mobile from)
        {
            if (!CanUse(from) || item == null)
                return;

            if (!CheckRange(from))
                from.SendLocalizedMessage(3000268); // that is too far away.
            else if (!(item is TreasureMap || item is SOS || item is MessageInABottle))
                from.SendLocalizedMessage(1153564); // That is not a treasure map or message in a bottle.
            else if (!item.IsChildOf(from.Backpack))
                from.SendLocalizedMessage(1054107); // This item must be in your backpack.
            else if (m_Entries.Count >= 500)
                from.SendLocalizedMessage(1153565); // The locker is full
            else
            {
                DaviesLockerEntry entry = null;

                if (item is TreasureMap)
                    entry = new TreasureMapEntry((TreasureMap)item);
                else if (item is SOS)
                    entry = new SOSEntry((SOS)item);
                else if (item is MessageInABottle)
                    entry = new SOSEntry((MessageInABottle)item);

                if (entry != null)
                {
                    m_Entries.Add(entry);
                    from.CloseGump(typeof(DaviesLockerGump));
                    from.SendGump(new DaviesLockerGump(from, this));

                    item.Delete();

                    InvalidateProperties();
                }
            }
        }

        private bool CheckRange(Mobile m)
        {
            if (Components == null || m.Map != this.Map)
                return false;

            foreach (AddonComponent c in Components)
            {
                if (m.InRange(c.Location, 2))
                    return true;
            }

            return false;
        }

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

        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);
            writer.Write(0); // Version

            writer.Write(m_South);
            writer.Write((int)m_Level);

            writer.Write(m_Entries.Count);
            foreach (DaviesLockerEntry entry in m_Entries)
            {
                if (entry is SOSEntry)
                    writer.Write((int)0);
                else if (entry is TreasureMapEntry)
                    writer.Write((int)1);
                else
                {
                    writer.Write((int)2);
                    continue;
                }

                entry.Serialize(writer);
            }
        }

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

            m_Entries = new List<DaviesLockerEntry>();

            m_South = reader.ReadBool();
            m_Level = (SecureLevel)reader.ReadInt();

            int count = reader.ReadInt();
            for (int i = 0; i < count; i++)
            {
                switch (reader.ReadInt())
                {
                    case 0:
                        m_Entries.Add(new SOSEntry(reader));
                        break;
                    case 1:
                        m_Entries.Add(new TreasureMapEntry(reader));
                        break;
                    case 2: break;
                }
            }
        }

        public class DaviesLockerComponent : LocalizedAddonComponent
        {
            public override bool ForceShowProperties { get { return true; } }

            public DaviesLockerComponent(int id)
                : base(id, 1153534) // Davies' Locker
            {
            }

            public override bool OnDragDrop(Mobile from, Item dropped)
            {
                if (this.Addon is DaviesLockerAddon && (dropped is SOS || dropped is TreasureMap))
                    ((DaviesLockerAddon)this.Addon).TryAddEntry(dropped as Item, from);

                return false;
            }

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

                if(Addon is DaviesLockerAddon)
                    SetSecureLevelEntry.AddTo(from, (DaviesLockerAddon)Addon, list);
            }

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

                if (Addon is DaviesLockerAddon)
                {
                    list.Add(1153648, ((DaviesLockerAddon)Addon).Entries.Count.ToString());
                }
            }

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

            public override void Serialize(GenericWriter writer)
            {
                base.Serialize(writer);
                writer.Write(0); // Version
            }

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

    public class DaviesLockerAddonDeed : BaseAddonDeed, IRewardOption
    {
        public override BaseAddon Addon { get { return new DaviesLockerAddon(m_South, m_Entries); } }
        public override int LabelNumber { get { return 1153535; } } // deed to davies' locker

        private List<DaviesLockerEntry> m_Entries;
        public List<DaviesLockerEntry> Entries { get { return m_Entries; } }

        private bool m_South;

        [CommandProperty(AccessLevel.GameMaster)]
        public bool South
        {
            get { return m_South; }
        }

        [Constructable]
        public DaviesLockerAddonDeed() : this(null)
        {
        }

        public override void OnDoubleClick(Mobile from)
        {
            if (IsChildOf(from.Backpack))
            {
                from.CloseGump(typeof(RewardOptionGump));
                from.SendGump(new RewardOptionGump(this));
            }
            else
                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.
        }

        public DaviesLockerAddonDeed(List<DaviesLockerEntry> list)
        {
            if (list == null)
                m_Entries = new List<DaviesLockerEntry>();
            else
                m_Entries = list;

            LootType = LootType.Blessed;
        }

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

            list.Add(1153648, m_Entries.Count.ToString()); // ~1_COUNT~ maps
        }

        public void GetOptions(RewardOptionList list)
        {
            list.Add(0, 1116332); // South 
            list.Add(1, 1116333); // East
        }

        public void OnOptionSelected(Mobile from, int choice)
        {
            m_South = choice == 0;

            if (!Deleted)
                base.OnDoubleClick(from);
        }

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

        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);
            writer.Write(0); // Version

            writer.Write(m_South);

            writer.Write(m_Entries.Count);
            foreach (DaviesLockerEntry entry in m_Entries)
            {
                if (entry is SOSEntry)
                    writer.Write((int)0);
                else if (entry is TreasureMapEntry)
                    writer.Write((int)1);
                else
                {
                    writer.Write((int)2);
                    continue;
                }

                entry.Serialize(writer);
            }
        }

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

            m_Entries = new List<DaviesLockerEntry>();
            m_South = reader.ReadBool();

            int count = reader.ReadInt();
            for (int i = 0; i < count; i++)
            {
                switch (reader.ReadInt())
                {
                    case 0:
                        m_Entries.Add(new SOSEntry(reader));
                        break;
                    case 1:
                        m_Entries.Add(new TreasureMapEntry(reader));
                        break;
                    case 2: break;
                }
            }
        }
    }

    public class DaviesLockerEntry
    {
        public Map Map { get; set; }
        public Point3D Location { get; set; }
        public int Level { get; set; }
        public bool QuestItem { get; set; }

        public DaviesLockerEntry(Map map, Point3D location, int level)
        {
            Map = map;
            Location = location;
            Level = level;
        }

        public DaviesLockerEntry(GenericReader reader)
        {
            int v = reader.ReadInt();

            switch (v)
            {
                case 1:
                    QuestItem = reader.ReadBool();
                    goto case 0;
                case 0:
                    Map = reader.ReadMap();
                    Location = reader.ReadPoint3D();
                    Level = reader.ReadInt();
                    break;
            }
        }

        public virtual void Serialize(GenericWriter writer)
        {
            writer.Write((int)1);

            writer.Write(QuestItem);

            writer.Write(Map);
            writer.Write(Location);
            writer.Write(Level);
        }
    }

    public class SOSEntry : DaviesLockerEntry
    {
        public bool IsAncient { get; set; }
        public int MessageIndex { get; set; }
        public bool Opened { get; set; }

        public SOSEntry(MessageInABottle mib) : base(mib.TargetMap, Point3D.Zero, mib.Level)
        {
            Opened = false;
            IsAncient = false;
            MessageIndex = -1;

            if (mib is SaltySeaMIB)
                QuestItem = true;
        }

        public SOSEntry(SOS sos) : base(sos.TargetMap, sos.TargetLocation, sos.Level)
        {
            Opened = true;
            IsAncient = sos.IsAncient;
            MessageIndex = sos.MessageIndex;

            if (sos is SaltySeaSOS)
                QuestItem = true;
        }

        public SOSEntry(GenericReader reader) : base(reader)
        {
            int v = reader.ReadInt();

            IsAncient = reader.ReadBool();
            MessageIndex = reader.ReadInt();
            Opened = reader.ReadBool();
        }

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

            writer.Write(IsAncient);
            writer.Write(MessageIndex);
            writer.Write(Opened);
        }
    }

    public class TreasureMapEntry : DaviesLockerEntry
    {
        public bool Completed { get; set; }
        public Mobile CompletedBy { get; set; }
        public Mobile Decoder { get; set; }
        public DateTime NextReset { get; set; }
        public TreasurePackage Package { get; set; }

        public TreasureMapEntry(TreasureMap map) : base(map.Facet, new Point3D(map.ChestLocation.X, map.ChestLocation.Y, 0), map.Level)
        {
            Completed = map.Completed;
            CompletedBy = map.CompletedBy;
            Decoder = map.Decoder;
            NextReset = map.NextReset;
            Package = map.Package;

            if (map is HiddenTreasuresTreasureMap)
                QuestItem = true;
        }

        public TreasureMapEntry(GenericReader reader) : base(reader)
        {
            int v = reader.ReadInt();

            switch (v)
            {
                case 1:
                    Package = (TreasurePackage)reader.ReadInt();
                    goto case 0;
                case 0:
                    Completed = reader.ReadBool();
                    CompletedBy = reader.ReadMobile();
                    Decoder = reader.ReadMobile();
                    NextReset = reader.ReadDateTime();
                    break;
            }

            if (v == 0)
            {
                Package = (TreasurePackage)Utility.RandomMinMax(0, 4);
            }
        }

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

            writer.Write((int)Package);

            writer.Write(Completed);
            writer.Write(CompletedBy);
            writer.Write(Decoder);
            writer.Write(NextReset);
        }
    }

    public class DaviesLockerGump : Gump
    {
        private readonly int Blue = 0x99FF;
        private readonly int AquaGreen = 0x03EF;
        private readonly int Yellow = 0xFFE0;

        private List<DaviesLockerEntry> m_List = new List<DaviesLockerEntry>();
        private int m_Page;
        private DaviesLockerAddon m_Addon;

        public DaviesLockerGump(Mobile from, DaviesLockerAddon addon) : this(from, addon, 0)
        {
        }

        public DaviesLockerGump(Mobile from, DaviesLockerAddon addon, int page) : base(50, 50)
        {
            if (addon == null || addon.Deleted)
                return;

            AddImage(0, 0, 0x5C1);
            m_List = addon.Entries;
            m_Addon = addon;

            AddHtmlLocalized(0, 10, 600, 20, 1153552, AquaGreen, false, false); // <DIV ALIGN="CENTER">Davies' Locker</DIV>

            AddHtmlLocalized(30, 35, 40, 20, 1153554, Blue, false, false); // <DIV ALIGN="CENTER">Get</DIV>
            AddHtmlLocalized(75, 35, 90, 20, 1153555, Blue, false, false); // <DIV ALIGN="CENTER">Facet</DIV>
            AddHtmlLocalized(170, 35, 200, 20, 1153556, Blue, false, false); // <DIV ALIGN="CENTER">Level</DIV>
            AddHtmlLocalized(365, 35, 105, 20, 1153557, Blue, false, false); // <DIV ALIGN="CENTER">Coords</DIV>
            AddHtmlLocalized(470, 35, 120, 20, 1153558, Blue, false, false); // <DIV ALIGN="CENTER">Status</DIV>

            int perPage = 10;
            int totalPages = (int)Math.Ceiling((double)m_List.Count / 10.0);

            if (totalPages < 1) totalPages = 1;

            if(page < 0) page = 0;
            if(page + 1 > totalPages) page = totalPages - 1;
            m_Page = page;

            int start = page * perPage;

            AddHtmlLocalized(40, 428, 200, 20, 1153560, String.Format("{0}\t{1}", m_List.Count, "500"), Blue, false, false); // Maps: ~1_NUM~ of ~2_MAX~
            AddHtmlLocalized(40, 450, 200, 20, 1153561, String.Format("{0}\t{1}", (page + 1).ToString(), (totalPages).ToString()), Blue, false, false); // Page ~1_CUR~ of ~2_MAX~

            AddHtmlLocalized(380, 427, 72, 20, 1153553, Yellow, false, false); // <DIV ALIGN="CENTER">ADD MAPS</DIV>
            AddButton(340, 428, 4011, 4013, 1, GumpButtonType.Reply, 0); 

            AddHtmlLocalized(377, 450, 40, 20, 1153562, Yellow, false, false); // <DIV ALIGN="CENTER">PAGE</DIV>
            AddButton(340, 450, 4014, 4016, 2, GumpButtonType.Reply, 0);
            AddButton(502, 450, 4005, 4007, 3, GumpButtonType.Reply, 0);
            AddImage(320, 455, 5603);
            AddImage(537, 455, 5601);

            int y = 72;
            int index = 0;

            for (int i = start; i >= 0 && i < m_List.Count && index < perPage; i++)
            {
                DaviesLockerEntry entry = m_List[i];

                if (entry == null)
                    continue;

                if(addon.CanUse(from))
                    AddButton(45, y + 3, 1209, 1210, 5 + i, GumpButtonType.Reply, 0);

                AddHtml(80, y, 100, 20, String.Format("<basefont color=yellow>{0}", GetFacet(entry)), false, false);

                if (TreasureMapInfo.NewSystem && entry is TreasureMapEntry)
                {
                    AddHtmlLocalized(175, y, 220, 20, 1060847, String.Format("{0}\t{1}", "#" + GetPackage((TreasureMapEntry)entry), "#" + GetLevel((TreasureMapEntry)entry)), Yellow, false, false);
                }
                else
                {
                    AddHtmlLocalized(175, y, 220, 20, GetLevel(entry), Yellow, false, false);
                }

                if ((entry is TreasureMapEntry && ((TreasureMapEntry)entry).Decoder == null) || (entry is SOSEntry && !((SOSEntry)entry).Opened))
                    AddHtmlLocalized(370, y, 100, 20, 1153569, Yellow, false, false); // Unknown
                else
                    AddHtmlLocalized(370, y, 100, 20, 1060847, String.Format("{0}\t{1}", entry.Location.X.ToString(), entry.Location.Y.ToString()), Yellow, false, false); // ~1_val~ ~2_val~
                
                AddHtmlLocalized(475, y, 100, 20, GetStatus(entry), Yellow, false, false);

                y += 35;
                index++;
            }
        }

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

            if (!m_Addon.CanUse(from))
                return;

            switch (info.ButtonID)
            {
                case 0: return;
                case 1: // ADD MAPS
                    {
                        from.Target = new InternalTarget(from, m_Addon, m_Page);
                        from.SendLocalizedMessage(1153563); // Target maps in your backpack or a sub-container to add them to the Locker. When done, press ESC.
                        return;
                    }
                case 2: // PAGE BACK
                    m_Page--;
                    break;
                case 3: // PAGE FORWARD
                    m_Page++;
                    break;
                default:
                    {
                        int index = info.ButtonID - 5;

                        if (index >= 0 && index < m_List.Count)
                        {
                            DaviesLockerEntry entry = m_List[index];

                            if (entry != null)
                                ConstructEntry(from, entry);
                        }
                    }
                    break;
            }

            from.SendGump(new DaviesLockerGump(from, m_Addon, m_Page));
        }

        private string GetPackage(TreasureMapEntry entry)
        {
            switch (entry.Package)
            {
                default:
                case TreasurePackage.Artisan: return "1159000";
                case TreasurePackage.Assassin: return "1158998";
                case TreasurePackage.Mage: return "1158997";
                case TreasurePackage.Ranger: return "1159002";
                case TreasurePackage.Warrior: return "1158999";
            }
        }

        private string GetLevel(TreasureMapEntry entry)
        {
            return (1158992 + Math.Min(4, entry.Level)).ToString();
        }

        private string GetFacet(DaviesLockerEntry entry)
        {
            if (entry is TreasureMapEntry && Server.Spells.SpellHelper.IsEodon(entry.Map, entry.Location))
            {
                return "Eodon";
            }

            return entry.Map.ToString();
        }

        private void ConstructEntry(Mobile from, DaviesLockerEntry entry)
        {
            Item item = null;

            if (entry is SOSEntry)
                item = Construct((SOSEntry)entry);
            else if (entry is TreasureMapEntry)
                item = Construct((TreasureMapEntry)entry);

            if (item != null)
            {
                Container pack = from.Backpack;

                if (pack == null || !pack.TryDropItem(from, item, false))
                    item.Delete();
                else
                {
                    if (m_List.Contains(entry))
                        m_List.Remove(entry);
                    //TODO: Message?
                }
            }
        }

        private Item Construct(SOSEntry entry)
        {
            if (entry == null)
                return null;

            if (entry.Opened)
            {
                SOS sos;

                if (entry.QuestItem)
                    sos = new SaltySeaSOS(entry.Map, entry.Level);
                else
                    sos = new SOS(entry.Map, entry.Level);

                sos.MessageIndex = entry.MessageIndex;
                sos.TargetLocation = entry.Location;
                return sos;
            }
            else
            {
                MessageInABottle mib;

                if (entry.QuestItem)
                    mib = new SaltySeaMIB(entry.Map, entry.Level);
                else
                    mib = new MessageInABottle(entry.Map, entry.Level);

                return mib;
            }
        }

        private TreasureMap Construct(TreasureMapEntry entry)
        {
            if (entry == null)
                return null;

            
            TreasureMap map;

            if (entry.QuestItem)
                map = new HiddenTreasuresTreasureMap(entry.Level, entry.Map, new Point2D(entry.Location.X, entry.Location.Y));
            else
            {
                map = new TreasureMap();

                map.Facet = entry.Map;
                map.Level = entry.Level;
                map.Package = (TreasurePackage)entry.Package;
                map.ChestLocation = new Point2D(entry.Location.X, entry.Location.Y);
            }

            bool eodon = map.TreasureFacet == TreasureFacet.Eodon;

            map.Completed = entry.Completed;
            map.CompletedBy = entry.CompletedBy;
            map.Decoder = entry.Decoder;
            map.NextReset = entry.NextReset;

            map.Width = 300;
            map.Height = 300;
            int x = entry.Location.X;
            int y = entry.Location.Y;
            int width, height;
            Map facet = entry.Map;

            map.GetWidthAndHeight(facet, out width, out height);

            int x1 = x - Utility.RandomMinMax(width / 4, (width / 4) * 3);
            int y1 = y - Utility.RandomMinMax(height / 4, (height / 4) * 3);

            if (x1 < 0) x1 = 0;
            if (y1 < 0) y1 = 0;

            int x2, y2;

            map.AdjustMap(facet, out x2, out y2, x1, y1, width, height, eodon);

            x1 = x2 - width;
            y1 = y2 - height;

            map.Bounds = new Rectangle2D(x1, y1, width, height);
            map.Protected = true;

            map.AddWorldPin(x, y);

            return map;
        }

        private int GetLevel(DaviesLockerEntry entry)
        {
            if (entry is SOSEntry)
                return 1153568;             // S-O-S
            else if(entry is TreasureMapEntry)
                return 1153572 + entry.Level;

            return 1153569; // Unknown
        }

        private int GetStatus(DaviesLockerEntry entry)
        {
            if (entry is SOSEntry)
            {
                SOSEntry sosEntry = (SOSEntry)entry;

                if (!sosEntry.Opened)
                    return 1153570; // Unopened

                if (sosEntry.IsAncient)
                    return 1153572; // Ancient

                return 1153571;     // Opened
            }
            else if (entry is TreasureMapEntry)
            {
                TreasureMapEntry mapEntry = (TreasureMapEntry)entry;

                if (mapEntry.Completed)
                    return 1153582; // Completed
                else if (mapEntry.Decoder != null)
                    return 1153581; // Decoded
                else
                    return 1153580; // Not Decoded
            }

            return 1153569; // Unknown
        }

        private class InternalTarget : Target
        {
            private DaviesLockerAddon m_Addon;
            private int m_Page;

            public InternalTarget(Mobile from, DaviesLockerAddon addon, int page) : base(-1, false, TargetFlags.None)
            {
                m_Addon = addon;
                m_Page = page;
            }

            protected override void OnTarget(Mobile from, object targeted)
            {
                if (m_Addon != null && !m_Addon.Deleted && targeted is Item)
                {
                    m_Addon.TryAddEntry(targeted as Item, from);
                    from.Target = new InternalTarget(from, m_Addon, m_Page);
                }
            }

            protected override void OnTargetCancel(Mobile from, TargetCancelType cancelType)
            {
                if (m_Addon != null && !m_Addon.Deleted)
                {
                    from.CloseGump(typeof(DaviesLockerGump));
                    from.SendGump(new DaviesLockerGump(from, m_Addon, m_Page));
                }
            }
        }
    }
}