PKHeX/PKHeX.Core/Legality/Verifiers/MarkVerifier.cs

using System.Linq;
using static PKHeX.Core.LegalityCheckStrings;

namespace PKHeX.Core
{
    /// <summary>
    /// Verifies the <see cref="RibbonIndex"/> values for markings.
    /// </summary>
    public sealed class MarkVerifier : Verifier
    {
        protected override CheckIdentifier Identifier => CheckIdentifier.RibbonMark;

        public override void Verify(LegalityAnalysis data)
        {
            var pkm = data.pkm;
            if (pkm is not IRibbonIndex m)
                return;

            if (data.Info.Generation != 8 || (pkm.Species == (int)Species.Shedinja && data.EncounterOriginal.Species is not (int)Species.Shedinja)) // Shedinja doesn't copy Ribbons or Marks
                VerifyNoMarksPresent(data, m);
            else
                VerifyMarksPresent(data, m);

            VerifyAffixedRibbonMark(data, m);
        }

        private void VerifyNoMarksPresent(LegalityAnalysis data, IRibbonIndex m)
        {
            for (var x = RibbonIndex.MarkLunchtime; x <= RibbonIndex.MarkSlump; x++)
            {
                if (m.GetRibbon((int)x))
                    data.AddLine(GetInvalid(string.Format(LRibbonMarkingFInvalid_0, x)));
            }
        }

        private void VerifyMarksPresent(LegalityAnalysis data, IRibbonIndex m)
        {
            bool hasOne = false;
            for (var mark = RibbonIndex.MarkLunchtime; mark <= RibbonIndex.MarkSlump; mark++)
            {
                bool has = m.GetRibbon((int)mark);
                if (!has)
                    continue;

                if (hasOne)
                {
                    data.AddLine(GetInvalid(string.Format(LRibbonMarkingFInvalid_0, GetRibbonNameSafe(mark))));
                    return;
                }

                bool result = IsMarkValid(mark, data.pkm, data.EncounterMatch);
                if (!result)
                {
                    data.AddLine(GetInvalid(string.Format(LRibbonMarkingFInvalid_0, GetRibbonNameSafe(mark))));
                    return;
                }

                hasOne = true;
            }
        }

        private static string GetRibbonNameSafe(RibbonIndex index)
        {
            if (index >= RibbonIndex.MAX_COUNT)
                return index.ToString();
            var expect = $"Ribbon{index}";
            return RibbonStrings.GetName(expect);
        }

        public static bool IsMarkValid(RibbonIndex mark, PKM pk, IEncounterTemplate enc)
        {
            return IsMarkAllowedAny(enc) && IsMarkAllowedSpecific(mark, pk, enc);
        }

        public static bool IsMarkAllowedSpecific(RibbonIndex mark, PKM pk, IEncounterTemplate x) => mark switch
        {
            RibbonIndex.MarkCurry when !IsMarkAllowedCurry(pk, x) => false,
            RibbonIndex.MarkFishing when !IsMarkAllowedFishing(x) => false,
            RibbonIndex.MarkMisty when pk.Met_Level < EncounterArea8.BoostLevel && EncounterArea8.IsBoostedArea60Fog(pk.Met_Location) => false,
            RibbonIndex.MarkDestiny => false,
            >= RibbonIndex.MarkCloudy and <= RibbonIndex.MarkMisty => IsWeatherPermitted(mark, x),
            _ => true,
        };

        private static bool IsWeatherPermitted(RibbonIndex mark, IEncounterTemplate enc)
        {
            var permit = mark.GetWeather8();

            // Encounter slots check location weather, while static encounters check weather per encounter.
            return enc switch
            {
                EncounterSlot8 w => IsSlotWeatherPermitted(permit, w),
                EncounterStatic8 s => s.Weather.HasFlag(permit),
                _ => false,
            };
        }

        private static bool IsSlotWeatherPermitted(AreaWeather8 permit, EncounterSlot8 s)
        {
            var location = s.Location;
            // If it's not in the main table, it can only have Normal weather.
            if (!EncounterArea8.WeatherbyArea.TryGetValue(location, out var weather))
                weather = AreaWeather8.Normal;
            if (weather.HasFlag(permit))
                return true;

            // Valid tree/fishing weathers should have returned with main area weather.
            if ((s.Weather & (AreaWeather8.Shaking_Trees | AreaWeather8.Fishing)) != 0)
                return false;

            // Check bleed conditions otherwise.
            return EncounterArea8.IsWeatherBleedPossible(s.SlotType, permit, location);
        }

        public static bool IsMarkAllowedAny(IEncounterTemplate enc) => enc.Generation == 8 && enc switch
        {
            // Gen 8
            EncounterSlot8 or EncounterStatic8 {Gift: false, ScriptedNoMarks: false} => true,
            _ => false,
        };

        public static bool IsMarkAllowedCurry(PKM pkm, IEncounterTemplate enc)
        {
            // Curry are only encounter slots, from the hidden table (not symbol). Slots taken from area's current weather(?).
            if (enc is not EncounterSlot8 {CanEncounterViaCurry: true})
                return false;

            var ball = pkm.Ball;
            return (uint)(ball - 2) <= 2;
        }

        public static bool IsMarkAllowedFishing(IEncounterTemplate enc)
        {
            return enc is EncounterSlot8 {CanEncounterViaFishing: true};
        }

        private void VerifyAffixedRibbonMark(LegalityAnalysis data, IRibbonIndex m)
        {
            if (m is not IRibbonSetAffixed a)
                return;

            var affix = a.AffixedRibbon;
            if (affix == -1) // None
                return;

            if ((byte)affix > (int)RibbonIndex.MarkSlump) // SW/SH cannot affix anything higher.
            {
                data.AddLine(GetInvalid(string.Format(LRibbonMarkingAffixedF_0, GetRibbonNameSafe((RibbonIndex)affix))));
                return;
            }

            if (m is not PKM pk)
                return;

            if (pk.Species == (int)Species.Shedinja && data.EncounterOriginal.Species is not (int)Species.Shedinja)
            {
                VerifyShedinjaAffixed(data, affix, pk, m);
                return;
            }
            EnsureHasRibbon(data, m, affix);
        }

        private void VerifyShedinjaAffixed(LegalityAnalysis data, sbyte affix, PKM pk, IRibbonIndex r)
        {
            // Does not copy ribbons or marks, but retains the Affixed Ribbon value.
            // Try re-verifying to see if it could have had the Ribbon/Mark.

            var enc = data.EncounterOriginal;
            if ((byte) affix >= (int) RibbonIndex.MarkLunchtime)
            {
                if (!IsMarkValid((RibbonIndex)affix, pk, enc))
                    data.AddLine(GetInvalid(string.Format(LRibbonMarkingAffixedF_0, GetRibbonNameSafe((RibbonIndex)affix))));
                return;
            }

            if (enc.Generation <= 4 && (pk.Ball != (int)Ball.Poke || IsMoveSetEvolvedShedinja(pk)))
            {
                // Evolved in a prior generation.
                EnsureHasRibbon(data, r, affix);
                return;
            }

            var clone = pk.Clone();
            clone.Species = (int) Species.Nincada;
            ((IRibbonIndex) clone).SetRibbon(affix);
            var parse = RibbonVerifier.GetRibbonResults(clone, data.Info.EvoChainsAllGens, enc);
            var name = GetRibbonNameSafe((RibbonIndex)affix);
            bool invalid = parse.FirstOrDefault(z => z.Name == name)?.Invalid == true;
            var severity = invalid ? Severity.Invalid : Severity.Fishy;
            data.AddLine(Get(string.Format(LRibbonMarkingAffixedF_0, name), severity));
        }

        private static bool IsMoveSetEvolvedShedinja(PKM pk)
        {
            // Check for gen3/4 exclusive moves that are Ninjask glitch only.
            if (pk.HasMove((int) Move.Screech))
                return true;
            if (pk.HasMove((int) Move.SwordsDance))
                return true;
            if (pk.HasMove((int) Move.Slash))
                return true;
            if (pk.HasMove((int) Move.BatonPass))
                return true;
            return pk.HasMove((int)Move.Agility) && pk is PK8 pk8 && !pk8.GetMoveRecordFlag(12); // TR12 (Agility)
        }

        private void EnsureHasRibbon(LegalityAnalysis data, IRibbonIndex m, sbyte affix)
        {
            var hasRibbon = m.GetRibbonIndex((RibbonIndex) affix);
            if (!hasRibbon)
                data.AddLine(GetInvalid(string.Format(LRibbonMarkingAffixedF_0, GetRibbonNameSafe((RibbonIndex) affix))));
        }
    }
}