using System;
using System.Collections;
using Server.Engines.Craft;
using Server.Mobiles;
using Server.Network;
using Server.Targeting;

namespace Server.Items
{
    public delegate void InstrumentPickedCallback(Mobile from, BaseInstrument instrument);

    public abstract class BaseInstrument : Item, ISlayer, IQuality, IResource
    {
        public static readonly double MaxBardingDifficulty = 160.0;

        private int m_WellSound, m_BadlySound;
        private SlayerName m_Slayer, m_Slayer2;
        private ItemQuality m_Quality;
        private Mobile m_Crafter;
        private int m_UsesRemaining;
        private CraftResource m_Resource;

        [CommandProperty(AccessLevel.GameMaster)]
        public int SuccessSound
        {
            get
            {
                return m_WellSound;
            }
            set
            {
                m_WellSound = value;
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public int FailureSound
        {
            get
            {
                return m_BadlySound;
            }
            set
            {
                m_BadlySound = value;
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public SlayerName Slayer
        {
            get
            {
                return m_Slayer;
            }
            set
            {
                m_Slayer = value;
                InvalidateProperties();
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public SlayerName Slayer2
        {
            get
            {
                return m_Slayer2;
            }
            set
            {
                m_Slayer2 = value;
                InvalidateProperties();
            }
        }

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

        [CommandProperty(AccessLevel.GameMaster)]
        public bool PlayerConstructed { get { return m_Crafter != null; } }

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

        [CommandProperty(AccessLevel.GameMaster)]
        public CraftResource Resource
        {
            get { return m_Resource; }
            set
            {
                m_Resource = value;
                Hue = CraftResources.GetHue(m_Resource);
                InvalidateProperties();
            }
        }

        public virtual int InitMinUses
        {
            get
            {
                return 350;
            }
        }
        public virtual int InitMaxUses
        {
            get
            {
                return 450;
            }
        }

        public virtual TimeSpan ChargeReplenishRate
        {
            get
            {
                return TimeSpan.FromMinutes(5.0);
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public int UsesRemaining
        {
            get
            {
                CheckReplenishUses();
                return m_UsesRemaining;
            }
            set
            {
                m_UsesRemaining = value;
                InvalidateProperties();
            }
        }

        private DateTime m_LastReplenished;

        [CommandProperty(AccessLevel.GameMaster)]
        public DateTime LastReplenished
        {
            get
            {
                return m_LastReplenished;
            }
            set
            {
                m_LastReplenished = value;
                CheckReplenishUses();
            }
        }

        private bool m_ReplenishesCharges;
        [CommandProperty(AccessLevel.GameMaster)]
        public bool ReplenishesCharges
        {
            get
            {
                return m_ReplenishesCharges;
            }
            set 
            {
                if (value != m_ReplenishesCharges && value)
                    m_LastReplenished = DateTime.UtcNow;

                m_ReplenishesCharges = value; 
            }
        }

        public void RandomInstrument()
        {
            switch (Utility.Random(3))
            {
                case 0:
                    {
                        ItemID = 0xEB2;
                        SuccessSound = 0x45;
                        FailureSound = 0x46;
                        break;
                    }
                case 1:
                    {
                        ItemID = 0xEB3;
                        SuccessSound = 0x4C;
                        FailureSound = 0x4D;
                        break;
                    }
                default:
                    {
                        ItemID = 0xE9C;
                        SuccessSound = 0x38;
                        FailureSound = 0x39;
                        break;
                    }
            }
        }

        public void CheckReplenishUses()
        {
            CheckReplenishUses(true);
        }

        public void CheckReplenishUses(bool invalidate)
        {
            if (!m_ReplenishesCharges || m_UsesRemaining >= InitMaxUses)
                return;

            if (m_LastReplenished + ChargeReplenishRate < DateTime.UtcNow)
            {
                TimeSpan timeDifference = DateTime.UtcNow - m_LastReplenished;

                m_UsesRemaining = Math.Min(m_UsesRemaining + (int)(timeDifference.Ticks / ChargeReplenishRate.Ticks), InitMaxUses);	//How rude of TimeSpan to not allow timespan division.
                m_LastReplenished = DateTime.UtcNow;

                if (invalidate)
                    InvalidateProperties();
            }
        }

        public void ScaleUses()
        {
            UsesRemaining = (UsesRemaining * GetUsesScalar()) / 100;
            //InvalidateProperties();
        }

        public void UnscaleUses()
        {
            UsesRemaining = (UsesRemaining * 100) / GetUsesScalar();
        }

        public int GetUsesScalar()
        {
            if (m_Quality == ItemQuality.Exceptional)
                return 200;

            return 100;
        }

        public void ConsumeUse(Mobile from)
        {
            // TODO: Confirm what must happen here?
            if (UsesRemaining > 1)
            {
                --UsesRemaining;
            }
            else
            {
                if (from != null)
                    from.SendLocalizedMessage(502079); // The instrument played its last tune.

                Delete();
            }
        }

        private static readonly Hashtable m_Instruments = new Hashtable();

        public static BaseInstrument GetInstrument(Mobile from)
        {
            BaseInstrument item = m_Instruments[from] as BaseInstrument;

            if (item == null)
                return null;

            if (!item.IsChildOf(from.Backpack))
            {
                m_Instruments.Remove(from);
                return null;
            }

            return item;
        }

        public static int GetBardRange(Mobile bard, SkillName skill)
        {
            return 8 + (int)(bard.Skills[skill].Value / 15);
        }

        public static void PickInstrument(Mobile from, InstrumentPickedCallback callback)
        {
            BaseInstrument instrument = GetInstrument(from);

            if (instrument != null)
            {
                if (callback != null)
                    callback(from, instrument);
            }
            else
            {
                from.SendLocalizedMessage(500617); // What instrument shall you play?
                from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(OnPickedInstrument), callback);
            }
        }

        public static void OnPickedInstrument(Mobile from, object targeted, object state)
        {
            BaseInstrument instrument = targeted as BaseInstrument;

            if (instrument == null)
            {
                from.SendLocalizedMessage(500619); // That is not a musical instrument.
            }
            else
            {
                SetInstrument(from, instrument);

                InstrumentPickedCallback callback = state as InstrumentPickedCallback;

                if (callback != null)
                    callback(from, instrument);
            }
        }

        public static bool IsMageryCreature(BaseCreature bc)
        {
            return (bc != null && bc.AI == AIType.AI_Mage && bc.Skills[SkillName.Magery].Base > 5.0);
        }

        public static bool IsFireBreathingCreature(BaseCreature bc)
        {
            if (bc == null)
                return false;

            var profile = bc.AbilityProfile;

            if (profile != null)
            {
                return profile.HasAbility(SpecialAbility.DragonBreath);
            }

            return false;
        }

        public static bool IsPoisonImmune(BaseCreature bc)
        {
            return (bc != null && bc.PoisonImmune != null);
        }

        public static int GetPoisonLevel(BaseCreature bc)
        {
            if (bc == null)
                return 0;

            Poison p = bc.HitPoison;

            if (p == null)
                return 0;

            return p.Level + 1;
        }

        public static double GetBaseDifficulty(Mobile targ)
        {
            /* Difficulty TODO: Add another 100 points for each of the following abilities:
            - Radiation or Aura Damage (Heat, Cold etc.)
            - Summoning Undead
            */
            double val = (targ.HitsMax * 1.6) + targ.StamMax + targ.ManaMax;

            val += targ.SkillsTotal / 10;

            BaseCreature bc = targ as BaseCreature;

            if (IsMageryCreature(bc))
                val += 100;

            if (IsFireBreathingCreature(bc))
                val += 100;

            if (IsPoisonImmune(bc))
                val += 100;

            if (targ is VampireBat || targ is VampireBatFamiliar)
                val += 100;

            val += GetPoisonLevel(bc) * 20;

            if (val > 700)
                val = 700 + (int)((val - 700) * (3.0 / 11));

            val /= 10;

            if (bc != null && bc.IsParagon)
                val += 40.0;

            if (Core.SE && val > MaxBardingDifficulty)
                val = MaxBardingDifficulty;

            return val;
        }

        public double GetDifficultyFor(Mobile targ)
        {
            double val = GetBaseDifficulty(targ);

            if (m_Quality == ItemQuality.Exceptional)
                val -= 5.0; // 10%

            if (m_Slayer != SlayerName.None)
            {
                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer);

                if (entry != null)
                {
                    if (entry.Slays(targ))
                        val -= 10.0; // 20%
                    else if (entry.Group.OppositionSuperSlays(targ))
                        val += 10.0; // -20%
                }
            }

            if (m_Slayer2 != SlayerName.None)
            {
                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer2);

                if (entry != null)
                {
                    if (entry.Slays(targ))
                        val -= 10.0; // 20%
                    else if (entry.Group.OppositionSuperSlays(targ))
                        val += 10.0; // -20%
                }
            }

            if (m_Slayer == SlayerName.None && m_Slayer2 == SlayerName.None)
            {
                SlayerEntry entry = SlayerGroup.GetEntryByName(SlayerSocket.GetSlayer(this));

                if (entry != null)
                {
                    if (entry.Slays(targ))
                        val -= 10.0; // 20%
                    else if (entry.Group.OppositionSuperSlays(targ))
                        val += 10.0; // -20%
                }
            }

            return val;
        }

        public static void SetInstrument(Mobile from, BaseInstrument item)
        {
            m_Instruments[from] = item;
        }

        public BaseInstrument()
        {
            RandomInstrument();

            UsesRemaining = Utility.RandomMinMax(InitMinUses, InitMaxUses);
        }

        public BaseInstrument(int itemID, int wellSound, int badlySound)
            : base(itemID)
        {
            m_WellSound = wellSound;
            m_BadlySound = badlySound;

            UsesRemaining = Utility.RandomMinMax(InitMinUses, InitMaxUses);
        }

        public override void AddCraftedProperties(ObjectPropertyList list)
        {
            if (m_Crafter != null)
                list.Add(1050043, m_Crafter.TitleName); // crafted by ~1_NAME~

            if (m_Quality == ItemQuality.Exceptional)
                list.Add(1060636); // exceptional
        }

        public override void AddUsesRemainingProperties(ObjectPropertyList list)
        {
            list.Add(1060584, UsesRemaining.ToString()); // uses remaining: ~1_val~
        }

        public override void GetProperties(ObjectPropertyList list)
        {
            int oldUses = m_UsesRemaining;
            CheckReplenishUses(false);

            base.GetProperties(list);

            if (m_ReplenishesCharges)
                list.Add(1070928); // Replenish Charges

            if (m_Slayer != SlayerName.None)
            {
                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer);
                if (entry != null)
                    list.Add(entry.Title);
            }

            if (m_Slayer2 != SlayerName.None)
            {
                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer2);
                if (entry != null)
                    list.Add(entry.Title);
            }

            if (!CraftResources.IsStandard(m_Resource))
            {
                int num = CraftResources.GetLocalizationNumber(m_Resource);

                if (num > 0)
                    list.Add(num);
                else
                    list.Add(CraftResources.GetName(m_Resource));
            }

            if (m_UsesRemaining != oldUses)
                Timer.DelayCall(TimeSpan.Zero, new TimerCallback(InvalidateProperties));
        }

        public override void OnSingleClick(Mobile from)
        {
            ArrayList attrs = new ArrayList();

            if (DisplayLootType)
            {
                if (LootType == LootType.Blessed)
                    attrs.Add(new EquipInfoAttribute(1038021)); // blessed
                else if (LootType == LootType.Cursed)
                    attrs.Add(new EquipInfoAttribute(1049643)); // cursed
            }

            if (m_Quality == ItemQuality.Exceptional)
                attrs.Add(new EquipInfoAttribute(1018305 - (int)m_Quality));

            if (m_ReplenishesCharges)
                attrs.Add(new EquipInfoAttribute(1070928)); // Replenish Charges

            // TODO: Must this support item identification?
            if (m_Slayer != SlayerName.None)
            {
                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer);
                if (entry != null)
                    attrs.Add(new EquipInfoAttribute(entry.Title));
            }

            if (m_Slayer2 != SlayerName.None)
            {
                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer2);
                if (entry != null)
                    attrs.Add(new EquipInfoAttribute(entry.Title));
            }

            int number;

            if (Name == null)
            {
                number = LabelNumber;
            }
            else
            {
                LabelTo(from, Name);
                number = 1041000;
            }

            if (attrs.Count == 0 && Crafter == null && Name != null)
                return;

            EquipmentInfo eqInfo = new EquipmentInfo(number, m_Crafter, false, (EquipInfoAttribute[])attrs.ToArray(typeof(EquipInfoAttribute)));

            from.Send(new DisplayEquipmentInfo(this, eqInfo));
        }

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

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

            writer.Write((int)4); // version

            writer.Write((int)m_Resource);

            writer.Write(m_ReplenishesCharges);
            if (m_ReplenishesCharges)
                writer.Write(m_LastReplenished);

            writer.Write(m_Crafter);

            writer.WriteEncodedInt((int)m_Quality);
            writer.WriteEncodedInt((int)m_Slayer);
            writer.WriteEncodedInt((int)m_Slayer2);

            writer.WriteEncodedInt((int)UsesRemaining);

            writer.WriteEncodedInt((int)m_WellSound);
            writer.WriteEncodedInt((int)m_BadlySound);
        }

        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);

            int version = reader.ReadInt();

            switch ( version )
            {
                case 4:
                    {
                        m_Resource = (CraftResource)reader.ReadInt();
                        goto case 3;
                    }
                case 3:
                    {
                        m_ReplenishesCharges = reader.ReadBool();

                        if (m_ReplenishesCharges)
                            m_LastReplenished = reader.ReadDateTime();

                        goto case 2;
                    }
                case 2:
                    {
                        m_Crafter = reader.ReadMobile();

                        m_Quality = (ItemQuality)reader.ReadEncodedInt();
                        m_Slayer = (SlayerName)reader.ReadEncodedInt();
                        m_Slayer2 = (SlayerName)reader.ReadEncodedInt();

                        UsesRemaining = reader.ReadEncodedInt();

                        m_WellSound = reader.ReadEncodedInt();
                        m_BadlySound = reader.ReadEncodedInt();
					
                        break;
                    }
                case 1:
                    {
                        m_Crafter = reader.ReadMobile();

                        m_Quality = (ItemQuality)reader.ReadEncodedInt();
                        m_Slayer = (SlayerName)reader.ReadEncodedInt();

                        UsesRemaining = reader.ReadEncodedInt();

                        m_WellSound = reader.ReadEncodedInt();
                        m_BadlySound = reader.ReadEncodedInt();

                        break;
                    }
                case 0:
                    {
                        m_WellSound = reader.ReadInt();
                        m_BadlySound = reader.ReadInt();
                        UsesRemaining = Utility.RandomMinMax(InitMinUses, InitMaxUses);

                        break;
                    }
            }

            CheckReplenishUses();
        }

        public override void OnDoubleClick(Mobile from)
        {
            if (!from.InRange(GetWorldLocation(), 1))
            {
                from.SendLocalizedMessage(500446); // That is too far away.
            }
            else if (from.BeginAction(typeof(BaseInstrument)))
            {
                SetInstrument(from, this);

                Timer.DelayCall(TimeSpan.FromMilliseconds(1000), () =>
                {
                    from.EndAction(typeof(BaseInstrument));
                });

                if (CheckMusicianship(from))
                    PlayInstrumentWell(from);
                else
                    PlayInstrumentBadly(from);
            }
            else
            {
                from.SendLocalizedMessage(500119); // You must wait to perform another action
            }
        }

        public static bool CheckMusicianship(Mobile m)
        {
            m.CheckSkill(SkillName.Musicianship, 0.0, 120.0);

            return ((m.Skills[SkillName.Musicianship].Value / 100) > Utility.RandomDouble());
        }

        public void PlayInstrumentWell(Mobile from)
        {
            from.PlaySound(m_WellSound);
        }

        public void PlayInstrumentBadly(Mobile from)
        {
            from.PlaySound(m_BadlySound);
        }

        #region ICraftable Members

        public virtual int OnCraft(int quality, bool makersMark, Mobile from, CraftSystem craftSystem, Type typeRes, ITool tool, CraftItem craftItem, int resHue)
        {
            Quality = (ItemQuality)quality;

            if (makersMark)
                Crafter = from;

            if (!craftItem.ForceNonExceptional)
            {
                if (typeRes == null)
                    typeRes = craftItem.Resources.GetAt(0).ItemType;

                Resource = CraftResources.GetFromType(typeRes);
            }

            return quality;
        }
        #endregion
    }
}