VanguardReMaster/client/Assets/Vanguard/Tests/Editor/CardOverlayTests.cs

using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using Vanguard.Board3D;
using Vanguard.Shared.Protocol;
using Vanguard.UI;
using Vanguard.UI.Overlays;

namespace Vanguard.Tests
{
    public sealed class CardOverlayTests
    {
        [Test]
        public void Zone_Content_Shows_Last_Added_First_And_Hides_Opponent_Hand()
        {
            var first = Card("BT01/001EN", 1);
            var last = Card("BT01/002EN", 2);
            var player = new PlayerView
            {
                Index = 0,
                Hand = new List<CardView> { first, last },
                HandCount = 2,
                Drop = new List<CardView> { first, last },
                FaceUpDamage = new List<CardView> { first },
                FaceDownDamage = 2,
                Soul = new List<CardView> { first, last },
            };

            var drop = CardZoneContent.Build(player, viewer: 0, BoardZone.Drop);
            Assert.AreSame(last, drop.Entries[0].Card);

            var ownHand = CardZoneContent.Build(player, viewer: 0, BoardZone.Hand);
            Assert.AreSame(last, ownHand.Entries[0].Card);

            var opponentHand = CardZoneContent.Build(player, viewer: 1, BoardZone.Hand);
            Assert.AreEqual(2, opponentHand.Entries.Count);
            Assert.IsTrue(opponentHand.Entries.All(entry => entry.Hidden));

            var damage = CardZoneContent.Build(player, viewer: 0, BoardZone.Damage);
            Assert.AreEqual(3, damage.Entries.Count);
            Assert.IsTrue(damage.Entries.Skip(1).All(entry => entry.Hidden));
        }

        [Test]
        public void CardList_Opens_Detail_And_Returns_To_List()
        {
            var canvas = UiKit.CreateCanvas("Overlay Test Canvas");
            var overlays = new OverlayNavigationService(canvas.transform, _ => null);
            try
            {
                var request = new CardListRequest("Тест", 0, BoardZone.Drop);
                request.Entries.Add(new CardListEntry(Card("BT01/001EN", 1)));
                request.Entries.Add(new CardListEntry(null, true, "Закрытая карта"));

                overlays.OpenList(request);
                Assert.IsTrue(overlays.IsOpen);
                Assert.IsTrue(Exists("CardListView"));

                var tile = Resources.FindObjectsOfTypeAll<Button>()
                    .FirstOrDefault(button => button.name.StartsWith("Card_"));
                Assert.IsNotNull(tile);
                tile.onClick.Invoke();

                Assert.IsTrue(Exists("CardDetailOverlay"));

                var back = Resources.FindObjectsOfTypeAll<Button>()
                    .FirstOrDefault(button => button.name == "Back"
                        && button.gameObject.scene.IsValid());
                Assert.IsNotNull(back);
                back.onClick.Invoke();
                Assert.IsTrue(Exists("CardListView"));
                Assert.IsFalse(Exists("CardDetailOverlay"));
            }
            finally
            {
                overlays.Dispose();
                Object.DestroyImmediate(canvas.gameObject);
                var eventSystem = Object.FindAnyObjectByType<EventSystem>();
                if (eventSystem != null)
                    Object.DestroyImmediate(eventSystem.gameObject);
            }
        }

        [Test]
        public void Overlay_Prefabs_Are_Available()
        {
            foreach (var name in new[]
                     {
                         "CardListView",
                         "CardDetailOverlay",
                         "CardActionMenu",
                         "ZoneBlockStrip",
                     })
            {
                Assert.IsNotNull(
                    Resources.Load<GameObject>("Overlays/" + name),
                    name);
            }
        }

        [Test]
        public void Animation_Config_Asset_Is_Loaded_From_Resources()
        {
            var asset = Resources.Load<Vanguard.Battle.AnimationConfig>("AnimationConfig");
            Assert.IsNotNull(asset);
            Assert.Greater(asset.cardMoveDuration, 0f);
            Assert.Greater(asset.arrowShowDuration, 0f);
        }

        [Test]
        public void Input_Lock_Returns_After_Last_Reason()
        {
            var lockService = new Vanguard.Battle.InputLockService();
            var changes = new List<bool>();
            lockService.Changed += changes.Add;

            lockService.Acquire("board");
            lockService.Acquire("feedback");
            Assert.IsTrue(lockService.IsLocked);

            lockService.Release("board");
            Assert.IsTrue(lockService.IsLocked);

            lockService.Release("feedback");
            Assert.IsFalse(lockService.IsLocked);
            CollectionAssert.AreEqual(new[] { true, false }, changes);

            lockService.Acquire("overlay");
            lockService.Acquire("overlay");
            lockService.Release("overlay");
            Assert.IsTrue(lockService.IsLocked);
            lockService.Release("overlay");
            Assert.IsFalse(lockService.IsLocked);
        }

        [Test]
        public void Card_Action_Menu_Invokes_Action_And_Closes()
        {
            var canvas = UiKit.CreateCanvas("Menu Test Canvas");
            var menu = new CardActionMenuView();
            menu.Build(canvas.transform);
            var invoked = false;
            var closed = false;
            try
            {
                menu.Show(
                    new Vector2(200f, 200f),
                    "Карта",
                    new List<CardActionMenuItem>
                    {
                        new CardActionMenuItem("Тест", () => invoked = true),
                    },
                    () => closed = true);

                Assert.IsTrue(menu.IsVisible);
                var button = Resources.FindObjectsOfTypeAll<Button>()
                    .FirstOrDefault(item => item.name == "Action_Тест");
                Assert.IsNotNull(button);
                button.onClick.Invoke();
                Assert.IsTrue(invoked);
                Assert.IsTrue(closed);
                Assert.IsFalse(menu.IsVisible);
            }
            finally
            {
                if (canvas != null)
                    Object.DestroyImmediate(canvas.gameObject);
                var eventSystem = Object.FindAnyObjectByType<EventSystem>();
                if (eventSystem != null)
                    Object.DestroyImmediate(eventSystem.gameObject);
            }
        }

        private static CardView Card(string id, int instanceId) => new CardView
        {
            PrintingId = id,
            InstanceId = instanceId,
            FaceUp = true,
            Power = 8000,
            BasePower = 8000,
            Critical = 1,
            BaseCritical = 1,
        };

        private static bool Exists(string name) =>
            Resources.FindObjectsOfTypeAll<GameObject>()
                .Any(go => go.name == name && go.activeInHierarchy);
    }
}