using System;

namespace ProjectI.Enemies
{
    public enum EnemyControlKind { Slow, Root, Stun, Push, Pull }

    public static class EnemyResistanceRules
    {
        public static float ResolveSlow(float requestedSlow, EnemyResistanceValues resistance) =>
            Valid(requestedSlow) && requestedSlow <= 1 ? Scale(requestedSlow, 1 - resistance.SlowReduction) : 0;

        public static double ResolveDuration(EnemyControlKind kind, double requestedDuration, EnemyResistanceValues resistance)
        {
            if (!Valid(requestedDuration)) return 0;
            double fraction = kind == EnemyControlKind.Root ? 1 - resistance.RootReduction
                : kind == EnemyControlKind.Stun ? 1 - resistance.StunReduction : 1;
            return requestedDuration * fraction;
        }

        public static float ResolveDisplacement(float requestedMetres, EnemyControlKind kind, EnemyResistanceValues resistance) =>
            kind == EnemyControlKind.Push || kind == EnemyControlKind.Pull ? Scale(requestedMetres, 1 - resistance.DisplacementReduction) : 0;

        public static float ResolveDamage(float incomingDamage, float guardReduction, EnemyResistanceValues resistance) =>
            Valid(guardReduction) && guardReduction <= 1 ? Scale(incomingDamage, (1d - resistance.DamageReduction) * (1 - guardReduction)) : 0;

        public static float ResolveBaseHealth(float authoredMaximumHealth, EnemyResistanceValues resistance) =>
            Scale(authoredMaximumHealth, resistance.HealthMultiplier);
        public static float ResolveOutgoingDamage(float authoredDamage, EnemyResistanceValues resistance) =>
            Scale(authoredDamage, resistance.OutgoingDamageMultiplier);

        public static bool WithinDisplacementBudget(UnityEngine.Vector3 origin, UnityEngine.Vector3 support, float metres)
        {
            if (!Valid(metres)) return false;
            var delta=support-origin; delta.y=0;
            return Valid(delta.sqrMagnitude) && delta.sqrMagnitude <= (double)metres*metres + .000001;
        }

        private static float Scale(float value, double factor) => Valid(value) && Valid(factor)
            ? (float)Math.Min(float.MaxValue, value * factor) : 0;
        private static bool Valid(double value) => !double.IsNaN(value) && !double.IsInfinity(value) && value >= 0;
    }
}