using System;
using System.Collections.Generic;
using ModernUO.Serialization;
using Server.Engines.ConPVP;
using Server.Factions;
using Server.Gumps;
using Server.Misc;
using Server.Mobiles;
using Server.Targeting;
using Server.Engines.BuffIcons;

namespace Server.Items;

[SerializationGenerator(0, false)]
public partial class Bandage : Item, IDyable
{
    public static int Range = Core.AOS ? 2 : 1;

    [Constructible]
    public Bandage(int amount = 1) : base(0xE21)
    {
        Stackable = true;
        Amount = amount;
    }

    public override double DefaultWeight => 0.1;

    public virtual bool Dye(Mobile from, DyeTub sender)
    {
        if (Deleted) return false;
        Hue = sender.DyedHue;
        return true;
    }

    public override void OnDoubleClick(Mobile from)
    {
        if (from.InRange(GetWorldLocation(), Range))
        {
            from.RevealingAction();
            from.SendLocalizedMessage(500948); // Who will you use the bandages on?
            from.Target = new InternalTarget(this);
        }
        else
        {
            from.SendLocalizedMessage(500295); // You are too far away to do that.
        }
    }

    public static void BandageTargetRequest(Mobile from, Item item, Mobile target)
    {
        if (item is not Bandage b || b.Deleted) return;

        if (!from.InRange(b.GetWorldLocation(), Range))
        {
            from.SendLocalizedMessage(500295); // You are too far away to do that.
            return;
        }

        if (from.Target != null)
        {
            Target.Cancel(from);
            from.Target = null;
        }

        from.RevealingAction();
        from.SendLocalizedMessage(500948); // Who will you use the bandages on?

        new InternalTarget(b).Invoke(from, target);
    }

    private class InternalTarget : Target
    {
        private readonly Bandage _bandage;

        public InternalTarget(Bandage bandage) : base(Bandage.Range, false, TargetFlags.Beneficial) =>
            _bandage = bandage;

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (_bandage.Deleted) return;

            if (targeted is Mobile mobile)
            {
                if (from.InRange(_bandage.GetWorldLocation(), Bandage.Range))
                {
                    if (!(BandageContext.BeginHeal(from, mobile) == null || DuelContext.IsFreeConsume(from)))
                    {
                        _bandage.Consume();
                    }
                }
                else
                {
                    from.SendLocalizedMessage(500295); // You are too far away to do that.
                }
                return;
            }

            if (targeted is PlagueBeastInnard innard)
            {
                if (innard.OnBandage(from)) _bandage.Consume();
                return;
            }

            from.SendLocalizedMessage(500970); // Bandages can not be used on that.
        }

        protected override void OnNonlocalTarget(Mobile from, object targeted)
        {
            if (targeted is PlagueBeastInnard innard)
            {
                if (innard.OnBandage(from)) _bandage.Consume();
            }
            else
            {
                base.OnNonlocalTarget(from, targeted);
            }
        }
    }
}

public class BandageContext : Timer
{
    private static readonly Dictionary<Mobile, BandageContext> _table = new();

    // --- MEMENTO DEFERRED HEALING VARIABLES ---
    private int _currentTicks;
    private readonly int _maxTicks;
    private readonly int _tickHealAmount;
    private int _finalHealAmount;

    public BandageContext(Mobile healer, Mobile patient, TimeSpan delay)
        // Run the timer every 250 milliseconds instead of waiting the full duration
        : base(TimeSpan.FromMilliseconds(250), TimeSpan.FromMilliseconds(250))
    {
        Healer = healer;
        Patient = patient;

        // Calculate how many 250ms ticks fit into the total delay
        _maxTicks = (int)(delay.TotalMilliseconds / 250);

        // Pre-calculate standard heal amounts for partial ticking
        var primarySkill = GetPrimarySkill(patient);
        var secondarySkill = GetSecondarySkill(patient);
        var healingVal = healer.Skills[primarySkill].Value;
        var anatomyVal = healer.Skills[secondarySkill].Value;

        double min, max;
        if (Core.AOS)
        {
            min = anatomyVal / 8.0 + healingVal / 5.0 + 4.0;
            max = anatomyVal / 6.0 + healingVal / 2.5 + 4.0;
        }
        else
        {
            min = anatomyVal / 5.0 + healingVal / 5.0 + 3.0;
            max = anatomyVal / 5.0 + healingVal / 2.0 + 10.0;
        }

        var toHeal = min + Utility.RandomDouble() * (max - min);

        if (patient.Body.IsMonster || patient.Body.IsAnimal)
        {
            toHeal += patient.HitsMax / 100.0;
        }

        _finalHealAmount = (int)toHeal;

        int partialHealCount = _maxTicks / 4; // 4 ticks = 1 second

        if (partialHealCount > 0)
        {
            // Baseline as 33% of the total healing distributed across partial ticks, capped at 10% per tick
            _tickHealAmount = Math.Min(
                (int)(0.33 * _finalHealAmount) / partialHealCount,
                (int)(0.1 * _finalHealAmount)
            );

            // Deduct what will be healed over time from the final burst
            _finalHealAmount -= _tickHealAmount * partialHealCount;
        }
    }

    public Mobile Healer { get; }
    public Mobile Patient { get; }
    public int Slips { get; set; }

    public void Slip()
    {
        Healer.SendLocalizedMessage(500961); // Your fingers slip!
        ++Slips;

        // --- SKILL GAIN: On Interruption ---
        Healer.CheckSkill(GetSecondarySkill(Patient), 0.0, 120.0);
        Healer.CheckSkill(GetPrimarySkill(Patient), 0.0, 120.0);
    }

    public void StopHeal()
    {
        if (Healer is PlayerMobile pm)
        {
            pm.RemoveBuff(BuffIcon.Healing);
        }
        _table.Remove(Healer);
        Stop();
    }

    public static BandageContext GetContext(Mobile healer)
    {
        _table.TryGetValue(healer, out var bc);
        return bc;
    }

    public static SkillName GetPrimarySkill(Mobile m)
    {
        if (!m.Player && (m.Body.IsMonster || m.Body.IsAnimal)) return SkillName.Veterinary;
        return SkillName.Healing;
    }

    public static SkillName GetSecondarySkill(Mobile m)
    {
        if (!m.Player && (m.Body.IsMonster || m.Body.IsAnimal)) return SkillName.AnimalLore;
        return SkillName.Anatomy;
    }

    // --- NEW: TICKING LOGIC (MEMENTO STYLE) ---
    protected override void OnTick()
    {
        _currentTicks++;

        bool isComplete = _currentTicks >= _maxTicks;
        bool canCheck = _currentTicks % 4 == 0; // Check every 1 second (4 ticks of 250ms)

        if (isComplete)
        {
            // Time is up! Run the standard ModernUO final heal/resurrect/cure logic
            DoFinalHeal();
            return;
        }

        if (canCheck)
        {
            int totalSeconds = _currentTicks / 4;

            // --- SKILL GAIN: Every 3 Seconds ---
            if (totalSeconds % 3 == 0)
            {
                Healer.CheckSkill(GetSecondarySkill(Patient), 0.0, 120.0);
                Healer.CheckSkill(GetPrimarySkill(Patient), 0.0, 120.0);
            }

            // --- PARTIAL HEALS (HoT) ---
            // Only tick HP if they are alive, unpoisoned, not bleeding, and not mortaled
            if (Patient.Alive && !Patient.Poisoned && !BleedAttack.IsBleeding(Patient) && !MortalStrike.IsWounded(Patient))
            {
                if (_tickHealAmount > 0)
                {
                    var primarySkill = GetPrimarySkill(Patient);
                    var healing = Healer.Skills[primarySkill].Value;
                    var chance = (healing + 10.0) / 100.0 - Slips * 0.02;

                    // Still requires a successful chance roll to land the partial tick
                    if (chance > Utility.RandomDouble())
                    {
                        Patient.Heal(_tickHealAmount, Healer, false);
                    }
                }
            }
        }
    }

    // --- THE ORIGINAL MODERNUO ONTICK LOGIC ---
    private void DoFinalHeal()
    {
        StopHeal();

        int healerNumber;
        int patientNumber;
        var playSound = true;
        bool checkSkills;

        var primarySkill = GetPrimarySkill(Patient);
        var secondarySkill = GetSecondarySkill(Patient);

        var petPatient = Patient as BaseCreature;

        if (!Healer.Alive)
        {
            Healer.SendLocalizedMessage(500962); // You were unable to finish your work before you died.
            return;
        }

        if (!Healer.InRange(Patient, Bandage.Range))
        {
            Healer.SendLocalizedMessage(500963); // You did not stay close enough to heal your target.
            return;
        }

        if (!Patient.Alive || petPatient?.IsDeadPet == true)
        {
            if (Patient.Map?.CanFit(Patient.Location, 16, false, false) != true)
            {
                Healer.SendLocalizedMessage(501042);
                Patient.SendLocalizedMessage(502391);
                return;
            }

            if (Patient.Region?.IsPartOf("Khaldun") == true)
            {
                Healer.SendLocalizedMessage(1010395);
                return;
            }

            var healing = Healer.Skills[primarySkill].Value;
            var anatomy = Healer.Skills[secondarySkill].Value;
            var chance = (healing - 68.0) / 50.0 - Slips * 0.02;
            checkSkills = healing >= 80.0 && anatomy >= 80.0;

            if (!(checkSkills && chance > Utility.RandomDouble())
                && (!Core.SE || petPatient is not FactionWarHorse || petPatient.ControlMaster != Healer))
            {
                if (petPatient?.IsDeadPet == true)
                    Healer.SendLocalizedMessage(503256);
                else
                    Healer.SendLocalizedMessage(500966);

                return;
            }

            healerNumber = 500965; // You are able to resurrect your patient.
            patientNumber = -1;

            Patient.PlaySound(0x214);
            Patient.FixedEffect(0x376A, 10, 16);

            if (petPatient?.IsDeadPet == true)
            {
                var master = petPatient.ControlMaster;

                if (master != null && Healer == master)
                {
                    petPatient.ResurrectPet();
                    for (var i = 0; i < petPatient.Skills.Length; ++i)
                    {
                        petPatient.Skills[i].Base -= 0.1;
                    }
                }
                else if (master?.InRange(petPatient, 3) == true)
                {
                    healerNumber = 503255;
                    master.SendGump(new PetResurrectGump(Healer, petPatient));
                }
                else
                {
                    var found = false;
                    var friends = petPatient.Friends;

                    for (var i = 0; i < friends?.Count; ++i)
                    {
                        var friend = friends[i];
                        if (friend.InRange(petPatient, 3))
                        {
                            healerNumber = 503255;
                            friend.SendGump(new PetResurrectGump(Healer, petPatient));
                            found = true;
                            break;
                        }
                    }

                    if (!found) healerNumber = 1049670;
                }
            }
            else
            {
                Patient.SendGump(new ResurrectGump(Healer));
            }
        }
        else if (Patient.Poisoned)
        {
            Healer.SendLocalizedMessage(500969); // You finish applying the bandages.

            var healing = Healer.Skills[primarySkill].Value;
            var anatomy = Healer.Skills[secondarySkill].Value;
            var chance = (healing - 30.0) / 50.0 - Patient.Poison.Level * 0.1 - Slips * 0.02;
            checkSkills = healing >= 60.0 && anatomy >= 60.0;

            if (!(checkSkills && chance > Utility.RandomDouble()))
            {
                Healer.SendLocalizedMessage(1010060); // You have failed to cure your target!
                return;
            }

            if (Patient.CurePoison(Healer))
            {
                healerNumber = Healer == Patient ? -1 : 1010058;
                patientNumber = 1010059;
            }
            else
            {
                healerNumber = -1;
                patientNumber = -1;
            }
        }
        else
        {
            if (BleedAttack.IsBleeding(Patient))
            {
                Healer.SendLocalizedMessage(1060088);
                Patient.SendLocalizedMessage(1060167);
                BleedAttack.EndBleed(Patient, false);
                return;
            }

            if (MortalStrike.IsWounded(Patient))
            {
                if (Healer == Patient)
                    Healer.SendLocalizedMessage(1005000);
                else
                    Healer.SendLocalizedMessage(1010398);

                return;
            }

            if (Patient.Hits == Patient.HitsMax)
            {
                Healer.SendLocalizedMessage(500967); // You heal what little damage your patient had.
                return;
            }

            checkSkills = true;
            patientNumber = -1;

            var healing = Healer.Skills[primarySkill].Value;
            var anatomy = Healer.Skills[secondarySkill].Value;
            var chance = (healing + 10.0) / 100.0 - Slips * 0.02;

            if (chance > Utility.RandomDouble())
            {
                healerNumber = 500969; // You finish applying the bandages.

                // --- INTEGRATED MEMENTO FINAL HEAL AMOUNT ---
                double finalHeal = _finalHealAmount;

                if (Core.AOS)
                {
                    finalHeal -= finalHeal * Slips * 0.35; // Apply slip reduction to the remaining burst
                }
                else
                {
                    finalHeal -= Slips * 4;
                }

                if (finalHeal < 1)
                {
                    finalHeal = 1;
                    healerNumber = 500968; // You apply the bandages, but they barely help.
                }

                Patient.Heal((int)finalHeal, Healer, false);
            }
            else
            {
                healerNumber = 500968; // You apply the bandages, but they barely help.
                playSound = false;
            }
        }

        if (healerNumber != -1) Healer.SendLocalizedMessage(healerNumber);
        if (patientNumber != -1) Patient.SendLocalizedMessage(patientNumber);
        if (playSound) Patient.PlaySound(0x57);

        // --- SKILL GAIN: Final Completion ---
        if (checkSkills)
        {
            Healer.CheckSkill(secondarySkill, 0.0, 120.0);
            Healer.CheckSkill(primarySkill, 0.0, 120.0);
        }

        if (Healer != Patient && Patient.Karma > 0)
        {
            Titles.AwardKarma(Healer, Patient.Karma / 5, true);
        }
    }

    public static BandageContext BeginHeal(Mobile healer, Mobile patient)
    {
        var creature = patient as BaseCreature;

        if (patient is Golem)
            healer.SendLocalizedMessage(500970);
        else if (creature?.IsAnimatedDead == true)
            healer.SendLocalizedMessage(500951);
        else if (!patient.Poisoned && patient.Hits == patient.HitsMax && !BleedAttack.IsBleeding(patient) && creature?.IsDeadPet != true)
            healer.SendLocalizedMessage(500955);
        else if (!patient.Alive && patient.Map?.CanFit(patient.Location, 16, false, false) != true)
            healer.SendLocalizedMessage(501042);
        else if ((healer as PlayerMobile)?.Young == true && (patient as PlayerMobile)?.Young == false)
            healer.SendLocalizedMessage(500952);
        else if (healer.CanBeBeneficial(patient, true, true))
        {
            healer.DoBeneficial(patient);

            var onSelf = healer == patient;
            var dex = healer.Dex;

            double seconds;
            var resDelay = patient.Alive ? 0.0 : 5.0;

            if (onSelf)
            {
                if (Core.AOS)
                    seconds = 5.0 + 0.5 * ((double)(120 - dex) / 10);
                else
                    seconds = 9.4 + 0.6 * ((double)(120 - dex) / 10);
            }
            else if (Core.AOS && GetPrimarySkill(patient) == SkillName.Veterinary)
            {
                seconds = 2.0;
            }
            else if (Core.AOS)
            {
                if (dex < 204)
                    seconds = 3.2 - Math.Sin((double)dex / 130) * 2.5 + resDelay;
                else
                    seconds = 0.7 + resDelay;
            }
            else if (dex >= 100)
                seconds = 3.0 + resDelay;
            else if (dex >= 40)
                seconds = 4.0 + resDelay;
            else
                seconds = 5.0 + resDelay;

            var context = GetContext(healer);
            context?.StopHeal();

            seconds *= 1000;

            context = new BandageContext(healer, patient, TimeSpan.FromMilliseconds(seconds));
            _table[healer] = context;
            context.Start();

            if (!onSelf) patient.SendLocalizedMessage(1008078, false, healer.Name);

            if (healer is PlayerMobile pm)
            {
                pm.AddBuff(new BuffInfo(BuffIcon.Healing, 1042971, TimeSpan.FromMilliseconds(seconds), "Healing"));
            }

            healer.SendLocalizedMessage(500956); // You begin applying the bandages.

            // --- SKILL GAIN: On Bandage Start ---
            healer.CheckSkill(GetSecondarySkill(patient), 0.0, 120.0);
            healer.CheckSkill(GetPrimarySkill(patient), 0.0, 120.0);

            return context;
        }

        return null;
    }
}