using NUnit.Framework;
using UnityEngine;
using System.Collections.Generic;

namespace Tests.EditMode
{
    public class PickupItemDataTests
    {
        private PickupItemData item1;
        private PickupItemData item2;
        private PickupItemData item3;

        [SetUp]
        public void SetUp()
        {
            // Create test instances using ScriptableObject.CreateInstance
            item1 = ScriptableObject.CreateInstance<PickupItemData>();
            item1.itemName = "Apple";
            item1.description = "A red fruit";

            item2 = ScriptableObject.CreateInstance<PickupItemData>();
            item2.itemName = "Apple";
            item2.description = "A different description"; // Different description but same name

            item3 = ScriptableObject.CreateInstance<PickupItemData>();
            item3.itemName = "Orange";
            item3.description = "A citrus fruit";
        }

        [TearDown]
        public void TearDown()
        {
            // Clean up created ScriptableObjects
            if (item1 != null) Object.DestroyImmediate(item1);
            if (item2 != null) Object.DestroyImmediate(item2);
            if (item3 != null) Object.DestroyImmediate(item3);
        }

        #region AreEquivalent Tests

        [Test]
        public void AreEquivalent_SameReference_ReturnsTrue()
        {
            // Arrange
            var item = item1;

            // Act
            bool result = PickupItemData.AreEquivalent(item, item);

            // Assert
            Assert.IsTrue(result, "Same reference should be equivalent");
        }

        [Test]
        public void AreEquivalent_SameItemName_ReturnsTrue()
        {
            // Arrange - item1 and item2 have the same itemName but different descriptions

            // Act
            bool result = PickupItemData.AreEquivalent(item1, item2);

            // Assert
            Assert.IsTrue(result, "Items with the same itemName should be equivalent");
        }

        [Test]
        public void AreEquivalent_DifferentItemName_ReturnsFalse()
        {
            // Arrange - item1 and item3 have different itemNames

            // Act
            bool result = PickupItemData.AreEquivalent(item1, item3);

            // Assert
            Assert.IsFalse(result, "Items with different itemName should not be equivalent");
        }

        [Test]
        public void AreEquivalent_FirstItemNull_ReturnsFalse()
        {
            // Arrange

            // Act
            bool result = PickupItemData.AreEquivalent(null, item1);

            // Assert
            Assert.IsFalse(result, "Null item should not be equivalent to a non-null item");
        }

        [Test]
        public void AreEquivalent_SecondItemNull_ReturnsFalse()
        {
            // Arrange

            // Act
            bool result = PickupItemData.AreEquivalent(item1, null);

            // Assert
            Assert.IsFalse(result, "Non-null item should not be equivalent to a null item");
        }

        [Test]
        public void AreEquivalent_BothItemsNull_ReturnsTrue()
        {
            // Arrange

            // Act
            bool result = PickupItemData.AreEquivalent(null, null);

            // Assert
            Assert.IsTrue(result, "Two null items should be equivalent (ReferenceEquals)");
        }

        #endregion

        #region ListContainsEquivalent Tests

        [Test]
        public void ListContainsEquivalent_EmptyList_ReturnsFalse()
        {
            // Arrange
            var list = new List<PickupItemData>();

            // Act
            bool result = PickupItemData.ListContainsEquivalent(list, item1);

            // Assert
            Assert.IsFalse(result, "Empty list should not contain any item");
        }

        [Test]
        public void ListContainsEquivalent_ListContainsSameReference_ReturnsTrue()
        {
            // Arrange
            var list = new List<PickupItemData> { item1 };

            // Act
            bool result = PickupItemData.ListContainsEquivalent(list, item1);

            // Assert
            Assert.IsTrue(result, "List should contain the same reference");
        }

        [Test]
        public void ListContainsEquivalent_ListContainsEquivalentItem_ReturnsTrue()
        {
            // Arrange - item1 and item2 have the same itemName but are different instances
            var list = new List<PickupItemData> { item1 };

            // Act
            bool result = PickupItemData.ListContainsEquivalent(list, item2);

            // Assert
            Assert.IsTrue(result, "List should contain an equivalent item with the same itemName");
        }

        [Test]
        public void ListContainsEquivalent_ListDoesNotContainEquivalentItem_ReturnsFalse()
        {
            // Arrange - item1 and item3 have different itemNames
            var list = new List<PickupItemData> { item1 };

            // Act
            bool result = PickupItemData.ListContainsEquivalent(list, item3);

            // Assert
            Assert.IsFalse(result, "List should not contain an item with a different itemName");
        }

        [Test]
        public void ListContainsEquivalent_SearchForNullInNonEmptyList_ReturnsFalse()
        {
            // Arrange
            var list = new List<PickupItemData> { item1, item2 };

            // Act
            bool result = PickupItemData.ListContainsEquivalent(list, null);

            // Assert
            Assert.IsFalse(result, "List should not contain a null item");
        }

        [Test]
        public void ListContainsEquivalent_SearchInListWithNull_HandlesNullGracefully()
        {
            // Arrange
            var list = new List<PickupItemData> { item1, null, item3 };

            // Act
            bool result = PickupItemData.ListContainsEquivalent(list, item2);

            // Assert
            Assert.IsTrue(result, "List with null element should still find equivalent item");
        }

        #endregion
    }
}