using DramaLing.Api.Utils;
using Xunit;

namespace DramaLing.Api.Tests.Utils
{
    public class CEFRHelperTests
    {
        [Theory]
        [InlineData("A1", 1)]
        [InlineData("A2", 2)]
        [InlineData("B1", 3)]
        [InlineData("B2", 4)]
        [InlineData("C1", 5)]
        [InlineData("C2", 6)]
        [InlineData("a1", 1)] // 測試小寫
        [InlineData(" A1 ", 1)] // 測試空格
        [InlineData(null, 0)]
        [InlineData("", 0)]
        [InlineData("INVALID", 0)]
        public void ToNumeric_ShouldReturnCorrectValue(string input, int expected)
        {
            // Act
            var result = CEFRHelper.ToNumeric(input);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData(1, "A1")]
        [InlineData(2, "A2")]
        [InlineData(3, "B1")]
        [InlineData(4, "B2")]
        [InlineData(5, "C1")]
        [InlineData(6, "C2")]
        [InlineData(0, "Unknown")]
        [InlineData(-1, "Unknown")]
        [InlineData(7, "Unknown")]
        public void ToString_ShouldReturnCorrectValue(int input, string expected)
        {
            // Act
            var result = CEFRHelper.ToString(input);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData(3, 2, true)]  // B1 > A2
        [InlineData(2, 3, false)] // A2 < B1
        [InlineData(3, 3, false)] // B1 == B1
        [InlineData(0, 1, false)] // 未知 < A1
        [InlineData(6, 5, true)]  // C2 > C1
        public void IsHigherThan_Numeric_ShouldReturnCorrectValue(int level1, int level2, bool expected)
        {
            // Act
            var result = CEFRHelper.IsHigherThan(level1, level2);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData("B1", "A2", true)]  // B1 > A2
        [InlineData("A2", "B1", false)] // A2 < B1
        [InlineData("B1", "B1", false)] // B1 == B1
        [InlineData("C2", "C1", true)]  // C2 > C1
        [InlineData(null, "A1", false)] // null < A1
        [InlineData("A1", "", false)]   // A1 > ""
        public void IsHigherThan_String_ShouldReturnCorrectValue(string level1, string level2, bool expected)
        {
            // Act
            var result = CEFRHelper.IsHigherThan(level1, level2);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData(2, 3, true)]  // A2 < B1
        [InlineData(3, 2, false)] // B1 > A2
        [InlineData(3, 3, false)] // B1 == B1
        [InlineData(1, 0, false)] // A1 > 未知
        public void IsLowerThan_Numeric_ShouldReturnCorrectValue(int level1, int level2, bool expected)
        {
            // Act
            var result = CEFRHelper.IsLowerThan(level1, level2);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData("A2", "B1", true)]  // A2 < B1
        [InlineData("B1", "A2", false)] // B1 > A2
        [InlineData("B1", "B1", false)] // B1 == B1
        public void IsLowerThan_String_ShouldReturnCorrectValue(string level1, string level2, bool expected)
        {
            // Act
            var result = CEFRHelper.IsLowerThan(level1, level2);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData(3, 3, true)]  // B1 == B1
        [InlineData(3, 2, false)] // B1 != A2
        [InlineData(0, 0, true)]  // 未知 == 未知
        public void IsSameLevel_Numeric_ShouldReturnCorrectValue(int level1, int level2, bool expected)
        {
            // Act
            var result = CEFRHelper.IsSameLevel(level1, level2);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData("B1", "B1", true)]  // B1 == B1
        [InlineData("B1", "A2", false)] // B1 != A2
        [InlineData("b1", "B1", true)]  // 忽略大小寫
        [InlineData(null, "", true)]    // null == "" (都是未知)
        public void IsSameLevel_String_ShouldReturnCorrectValue(string level1, string level2, bool expected)
        {
            // Act
            var result = CEFRHelper.IsSameLevel(level1, level2);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData(0, true)]
        [InlineData(1, true)]
        [InlineData(6, true)]
        [InlineData(-1, false)]
        [InlineData(7, false)]
        public void IsValidNumericLevel_ShouldReturnCorrectValue(int level, bool expected)
        {
            // Act
            var result = CEFRHelper.IsValidNumericLevel(level);

            // Assert
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData("A1", true)]
        [InlineData("C2", true)]
        [InlineData("a1", true)] // 忽略大小寫
        [InlineData(" B1 ", true)] // 忽略空格
        [InlineData("X1", false)]
        [InlineData("", false)]
        [InlineData(null, false)]
        public void IsValidStringLevel_ShouldReturnCorrectValue(string level, bool expected)
        {
            // Act
            var result = CEFRHelper.IsValidStringLevel(level);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void GetAllNumericLevels_ShouldReturnCorrectArray()
        {
            // Act
            var result = CEFRHelper.GetAllNumericLevels();

            // Assert
            Assert.Equal(new int[] { 0, 1, 2, 3, 4, 5, 6 }, result);
        }

        [Fact]
        public void GetAllStringLevels_ShouldReturnCorrectArray()
        {
            // Act
            var result = CEFRHelper.GetAllStringLevels();

            // Assert
            Assert.Equal(new string[] { "A1", "A2", "B1", "B2", "C1", "C2" }, result);
        }

        [Fact]
        public void RoundTrip_StringToNumericToString_ShouldReturnOriginal()
        {
            // Arrange
            var originalLevels = new[] { "A1", "A2", "B1", "B2", "C1", "C2" };

            foreach (var original in originalLevels)
            {
                // Act
                var numeric = CEFRHelper.ToNumeric(original);
                var result = CEFRHelper.ToString(numeric);

                // Assert
                Assert.Equal(original, result);
            }
        }

        [Fact]
        public void RoundTrip_NumericToStringToNumeric_ShouldReturnOriginal()
        {
            // Arrange
            var originalLevels = new[] { 1, 2, 3, 4, 5, 6 };

            foreach (var original in originalLevels)
            {
                // Act
                var stringLevel = CEFRHelper.ToString(original);
                var result = CEFRHelper.ToNumeric(stringLevel);

                // Assert
                Assert.Equal(original, result);
            }
        }
    }
}