ft/Client/Assets/Scripts/UI/OfferTreasureAscent/Tests/OfferTreasureAscentManagerTests.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;
using GameCore;

namespace OfferTreasureAscent.Tests
{
    public class OfferTreasureAscentManagerTests
    {
        public void StartTest()
        {
            Claim_SetsBitCorrectly();
            IsClaimed_ReturnsCorrectValue();
            MultipleClaims_AreHandledCorrectly();
            Claim_MultipleTimesSameIndex_DoesNotCauseIssues();

            IsDone_WithAllRewardsClaimed_ReturnsTrue();
            IsDone_WithBitwiseLogic_WorksCorrectly();
            IsDone_WithNoRewardsClaimed_ReturnsFalse();
            IsDone_WithSingleRewardClaimed_ReturnsTrue();
            IsDone_WithSomeRewardsClaimed_ReturnsFalse();

            GetItemFromIndex_WithValidIndex_ReturnsItemData();
            GetItemFromIndex_WithNegativeIndex_ClampsToZero();
            GetItemFromIndex_WithLargeIndex_ClampsToMax();
            // GetItemFromIndex_WithValidRange_ReturnsDifferentItems();

            PickRandomRewardIdx_WithValidRound_ReturnsValidIndex();
            PickRandomRewardIdx_WithHigherRound_ReturnsValidIndex();
            PickRandomRewardIdx_WithClaimedRewards_ExcludesClaimed();
            PickRandomRewardIdx_WithNoAvailableRewards_ReturnsNegativeOne();
            PickRandomRewardIdx_WithLimitedByRound_RespectsLimit();
        }

        public void Claim_SetsBitCorrectly()
        {
            var manager = new Manager();
            
            // Initially nothing should be claimed
            Assert.IsFalse(manager.IsClaimed(0));
            Assert.IsFalse(manager.IsClaimed(1));
            Assert.IsFalse(manager.IsClaimed(2));
            
            // Claim index 0
            manager.Claim(0);
            Assert.IsTrue(manager.IsClaimed(0));
            Assert.IsFalse(manager.IsClaimed(1));
            Assert.IsFalse(manager.IsClaimed(2));
            
            // Claim index 2
            manager.Claim(2);
            Assert.IsTrue(manager.IsClaimed(0));
            Assert.IsFalse(manager.IsClaimed(1));
            Assert.IsTrue(manager.IsClaimed(2));
        }

        public void IsClaimed_ReturnsCorrectValue()
        {
            var manager = new Manager();
            
            // Nothing claimed initially
            for (int i = 0; i < 10; i++)
            {
                Assert.IsFalse(manager.IsClaimed(i));
            }
            
            // Claim some indices and verify
            manager.Claim(3);
            manager.Claim(7);
            manager.Claim(9);
            
            Assert.IsFalse(manager.IsClaimed(0));
            Assert.IsFalse(manager.IsClaimed(1));
            Assert.IsFalse(manager.IsClaimed(2));
            Assert.IsTrue(manager.IsClaimed(3));
            Assert.IsFalse(manager.IsClaimed(4));
            Assert.IsFalse(manager.IsClaimed(5));
            Assert.IsFalse(manager.IsClaimed(6));
            Assert.IsTrue(manager.IsClaimed(7));
            Assert.IsFalse(manager.IsClaimed(8));
            Assert.IsTrue(manager.IsClaimed(9));
        }

        public void MultipleClaims_AreHandledCorrectly()
        {
            var manager = new Manager();
            
            // Claim multiple indices
            for (int i = 0; i < 8; i++)
            {
                if (i % 2 == 0) // Claim even indices
                {
                    manager.Claim(i);
                }
            }
            
            // Verify even indices are claimed, odd are not
            for (int i = 0; i < 8; i++)
            {
                bool expected = (i % 2 == 0);
                Assert.AreEqual(expected, manager.IsClaimed(i));
            }
        }

        public void Claim_MultipleTimesSameIndex_DoesNotCauseIssues()
        {
            var manager = new Manager();
            
            // Claim the same index multiple times
            manager.Claim(5);
            Assert.IsTrue(manager.IsClaimed(5));
            
            manager.Claim(5); // Claim again
            Assert.IsTrue(manager.IsClaimed(5));
            
            manager.Claim(5); // And again
            Assert.IsTrue(manager.IsClaimed(5));
        }

        public void IsDone_WithAllRewardsClaimed_ReturnsTrue()
        {
            // Arrange
            var manager = new Manager();
            var rewards = manager.GetRewards();
            int rewardCount = rewards.Count;

            // Claim all rewards
            for (int i = 0; i < rewardCount; i++)
            {
                manager.Claim(i);
            }

            // Act
            bool result = manager.IsNormalRewardsDepleted;

            // Assert
            Assert.IsTrue(result, "IsDone should return true when all rewards are claimed");
        }

        public void IsDone_WithNoRewardsClaimed_ReturnsFalse()
        {
            // Arrange - No claims made
            var manager = new Manager();
            var rewards = manager.GetRewards();
            int rewardCount = rewards.Count;

            // Verify no rewards are claimed initially
            for (int i = 0; i < rewardCount; i++)
            {
                Assert.IsFalse(manager.IsClaimed(i), $"Reward at index {i} should not be claimed initially");
            }

            // Act
            bool result = manager.IsNormalRewardsDepleted;

            // Assert
            Assert.IsFalse(result, "IsDone should return false when no rewards are claimed");
        }

        public void IsDone_WithSomeRewardsClaimed_ReturnsFalse()
        {
            // Arrange - Claim only some rewards
            var manager = new Manager();
            var rewards = manager.GetRewards();
            manager.Claim(0); // Claim first reward
            manager.Claim(2); // Claim third reward

            // Act
            bool result = manager.IsNormalRewardsDepleted;

            // Assert
            Assert.IsFalse(result, "IsDone should return false when only some rewards are claimed");
        }

        public void IsDone_WithSingleRewardClaimed_ReturnsTrue()
        {
            // Arrange - Create a scenario with only 1 reward and claim it
            // Since the original manager has 11 rewards by default, we can test
            // by claiming all except one, then checking that it's not done,
            // and then claiming the last one to verify it becomes done.

            var manager = new Manager();
            var rewards = manager.GetRewards(); // Gets 11 rewards by default
            int rewardCount = rewards.Count;

            // Claim all rewards except the last one
            for (int i = 0; i < rewardCount - 1; i++)
            {
                manager.Claim(i);
            }

            // Verify it's not done yet
            Assert.IsFalse(manager.IsNormalRewardsDepleted, "Should not be done with one reward left to claim");

            // Now claim the last reward
            manager.Claim(rewardCount - 1);

            // Act
            bool result = manager.IsNormalRewardsDepleted;

            // Assert
            Assert.IsTrue(result, "IsDone should return true when all rewards are claimed");
        }

        public void IsDone_WithBitwiseLogic_WorksCorrectly()
        {
            // This test verifies the bitwise logic of the IsDone method

            // Arrange - Test the specific bitwise operations
            // The method calculates: expectedMask = (1 << rewardCount) - 1
            // And checks: (_status & expectedMask) == expectedMask

            // For the default manager, there are 11 rewards
            var manager = new Manager();
            var rewards = manager.GetRewards();
            int rewardCount = rewards.Count; // Should be 11
            int expectedMask = (1 << rewardCount) - 1; // (1 << 11) - 1 = 2048 - 1 = 2047

            // Initially, _status should be 0, so (_status & expectedMask) = (0 & 2047) = 0
            // Since 0 != 2047, IsDone() should return false
            Assert.IsFalse(manager.IsNormalRewardsDepleted, "IsDone should return false initially");

            // Manually claim all rewards
            for (int i = 0; i < rewardCount; i++)
            {
                manager.Claim(i);
            }

            // Now _status should equal expectedMask, so IsDone() should return true
            Assert.IsTrue(manager.IsNormalRewardsDepleted, "IsDone should return true when all rewards are claimed");
        }

        public void IsDone_WithZeroRewards_ReturnsTrue()
        {
            // Use reflection to test the edge case where reward count is 0
            // This simulates the condition: if (rewardCount <= 0) return true;

            // Create a temporary manager and override its GetRewards method behavior
            var manager = new Manager();

            // Act
            bool result = manager.IsNormalRewardsDepleted;

            // Assert
            Assert.IsTrue(result, "IsDone should return true when there are zero rewards");
        }

        // public void IsDone_WithMoreThan31Rewards_ReturnsTrue()
        // {
        //     // Use reflection or a testable subclass to test the edge case where reward count > 31
        //     // This simulates the condition: if (rewardCount > 31) { log error; return true; }

        //     // Create a list with more than 31 items to simulate this case
        //     var manyRewards = new List<ItemData>();
        //     for (int i = 0; i < 35; i++)
        //     {
        //         manyRewards.Add(new ItemData(1001, i));
        //     }

        //     var testManager = new TestableManager(() => manyRewards);

        //     // Act
        //     bool result = testManager.IsDone();

        //     // Assert
        //     Assert.IsTrue(result, "IsDone should return true when there are more than 31 rewards");
        // }

        public void GetItemFromIndex_WithValidIndex_ReturnsItemData()
        {
            // Arrange
            var manager = new Manager();

            // Act
            var result = manager.GetItemFromIndex(0);

            // Assert
            Assert.IsNotNull(result, "GetItemFromIndex should return a valid ItemData object for a valid index");
        }

        public void GetItemFromIndex_WithNegativeIndex_ClampsToZero()
        {
            // Arrange
            var manager = new Manager();

            // Act
            var result = manager.GetItemFromIndex(-5);

            // Assert
            // Since the method clamps to [0, maxIndex], negative values should be treated as 0
            // We can't easily verify the exact behavior without knowing the table structure,
            // but we can verify it doesn't throw an exception
            Assert.IsNotNull(result, "GetItemFromIndex should handle negative indices gracefully by clamping");
        }

        public void GetItemFromIndex_WithLargeIndex_ClampsToMax()
        {
            // Arrange
            var manager = new Manager();

            // Act
            var result = manager.GetItemFromIndex(100); // Assuming this is larger than the table size

            // Assert
            // The method clamps to the maximum valid index, so it should return a valid ItemData
            Assert.IsNotNull(result, "GetItemFromIndex should handle large indices by clamping to max valid index");
        }

        // public void GetItemFromIndex_WithValidRange_ReturnsDifferentItems()
        // {
        //     // Arrange
        //     var manager = new Manager();
        //     var rewards = manager.GetRewards();
        //     int rewardCount = rewards.Count;

        //     // Act & Assert
        //     // Test a few indices within range to ensure they return valid objects
        //     for (int i = 0; i < Mathf.Min(5, rewardCount); i++)
        //     {
        //         var result = manager.GetItemFromIndex(i);
        //         Assert.IsNotNull(result, $"GetItemFromIndex should return valid ItemData for index {i}");
        //     }
        // }

        public void PickRandomRewardIdx_WithValidRound_ReturnsValidIndex()
        {
            // Arrange
            var manager = new Manager();

            // Act
            var result = manager.PickRandomAvailableRewardIdx(0); // Round 0

            // Assert
            // The result could be a valid index or -1 if no rewards are available
            // Since we don't know the table structure, we can only assert it returns an integer
            Assert.IsTrue(result >= -1, "PickRandomRewardIdx should return an index >= -1");
        }

        public void PickRandomRewardIdx_WithHigherRound_ReturnsValidIndex()
        {
            // Arrange
            var manager = new Manager();

            // Act
            var result = manager.PickRandomAvailableRewardIdx(10); // Higher round

            // Assert
            Assert.IsTrue(result >= -1, "PickRandomRewardIdx should return an index >= -1 for higher rounds");
        }

        public void PickRandomRewardIdx_WithClaimedRewards_ExcludesClaimed()
        {
            // Arrange
            var manager = new Manager();

            // Claim some rewards first
            manager.Claim(0);
            manager.Claim(1);

            // Act
            var result = manager.PickRandomAvailableRewardIdx(10); // High round to make most rewards available

            // Assert
            // The result should be a valid index that's not 0 or 1 (since those are claimed)
            // We can't verify the exact behavior without knowing table structure,
            // but we can check it doesn't throw
            Assert.IsTrue(result >= -1, "PickRandomRewardIdx should handle claimed rewards appropriately");
        }

        public void PickRandomRewardIdx_WithNoAvailableRewards_ReturnsNegativeOne()
        {
            // Arrange
            var manager = new Manager();
            var rewards = manager.GetRewards();
            int rewardCount = rewards.Count;

            // Claim all rewards
            for (int i = 0; i < rewardCount; i++)
            {
                manager.Claim(i);
            }

            // Act
            var result = manager.PickRandomAvailableRewardIdx(0);

            // Assert
            // After claiming all rewards, there should be no available rewards
            // So the method should return -1
            Assert.AreEqual(-1, result, "PickRandomRewardIdx should return -1 when no rewards are available");
        }

        public void PickRandomRewardIdx_WithLimitedByRound_RespectsLimit()
        {
            // Arrange
            var manager = new Manager();

            // Act & Assert
            // Test with different rounds to ensure the method respects the LimitConfig
            // We can't verify the exact filtering without knowing table structure,
            // but we can ensure it doesn't crash
            var result1 = manager.PickRandomAvailableRewardIdx(0);
            var result2 = manager.PickRandomAvailableRewardIdx(5);
            var result3 = manager.PickRandomAvailableRewardIdx(10);

            Assert.IsTrue(result1 >= -1, "PickRandomRewardIdx should work with round 0");
            Assert.IsTrue(result2 >= -1, "PickRandomRewardIdx should work with round 5");
            Assert.IsTrue(result3 >= -1, "PickRandomRewardIdx should work with round 10");
        }
    }
}