using System.ComponentModel;
using Common.Utils;

namespace Common.Test;

/// <summary>
/// EnumHelper 枚举工具测试
/// 展示枚举解析、描述获取、标志位操作等功能
/// </summary>
[TestClass]
public class EnumHelperTests
{
    #region 测试枚举定义

    /// <summary>
    /// 订单状态枚举
    /// </summary>
    public enum OrderStatus
    {
        [System.ComponentModel.Description("待支付")]
        Pending = 0,

        [System.ComponentModel.Description("已支付")]
        Paid = 1,

        [System.ComponentModel.Description("已发货")]
        Shipped = 2,

        [System.ComponentModel.Description("已完成")]
        Completed = 3,

        [System.ComponentModel.Description("已取消")]
        Cancelled = 4
    }

    /// <summary>
    /// 用户权限枚举（标志位）
    /// </summary>
    [Flags]
    public enum UserPermissions
    {
        [System.ComponentModel.Description("无权限")]
        None = 0,

        [System.ComponentModel.Description("读取权限")]
        Read = 1,

        [System.ComponentModel.Description("写入权限")]
        Write = 2,

        [System.ComponentModel.Description("删除权限")]
        Delete = 4,

        [System.ComponentModel.Description("管理权限")]
        Admin = 8,

        [System.ComponentModel.Description("全部权限")]
        All = Read | Write | Delete | Admin
    }

    /// <summary>
    /// 日志级别（无描述）
    /// </summary>
    public enum LogLevel
    {
        Debug = 1,
        Info = 2,
        Warning = 3,
        Error = 4,
        Fatal = 5
    }

    #endregion

    #region 枚举解析测试

    [TestMethod]
    public void Parse_ValidString_ReturnsEnum()
    {
        // Act
        var result1 = EnumHelper.Parse<OrderStatus>("Paid");
        var result2 = EnumHelper.Parse<OrderStatus>("paid"); // 忽略大小写

        // Assert
        Assert.IsNotNull(result1);
        Assert.AreEqual(OrderStatus.Paid, result1.Value);
        Assert.IsNotNull(result2);
        Assert.AreEqual(OrderStatus.Paid, result2.Value);
    }

    [TestMethod]
    public void Parse_InvalidString_ReturnsNull()
    {
        // Act
        var result = EnumHelper.Parse<OrderStatus>("InvalidValue");

        // Assert
        Assert.IsNull(result);
    }

    [TestMethod]
    public void ParseOrDefault_InvalidString_ReturnsDefaultValue()
    {
        // Act
        var result = EnumHelper.ParseOrDefault("InvalidValue", OrderStatus.Pending);

        // Assert
        Assert.AreEqual(OrderStatus.Pending, result);
    }

    [TestMethod]
    public void ParseFromInt_ValidValue_ReturnsEnum()
    {
        // Act
        var result = EnumHelper.ParseFromInt<OrderStatus>(2);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(OrderStatus.Shipped, result.Value);
    }

    [TestMethod]
    public void ParseFromInt_InvalidValue_ReturnsNull()
    {
        // Act
        var result = EnumHelper.ParseFromInt<OrderStatus>(999);

        // Assert
        Assert.IsNull(result);
    }

    [TestMethod]
    public void ParseFromDescription_ValidDescription_ReturnsEnum()
    {
        // Act
        var result = EnumHelper.ParseFromDescription<OrderStatus>("已支付");

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(OrderStatus.Paid, result.Value);
    }

    [TestMethod]
    public void ParseFromDescription_InvalidDescription_ReturnsNull()
    {
        // Act
        var result = EnumHelper.ParseFromDescription<OrderStatus>("不存在的状态");

        // Assert
        Assert.IsNull(result);
    }

    #endregion

    #region 枚举描述测试

    [TestMethod]
    public void GetDescription_WithDescriptionAttribute_ReturnsDescription()
    {
        // Arrange
        var status = OrderStatus.Paid;

        // Act
        var description = status.GetDescription();

        // Assert
        Assert.AreEqual("已支付", description);
    }

    [TestMethod]
    public void GetDescription_WithoutDescriptionAttribute_ReturnsEnumName()
    {
        // Arrange
        var level = LogLevel.Error;

        // Act
        var description = level.GetDescription();

        // Assert
        Assert.AreEqual("Error", description);
    }

    [TestMethod]
    public void GetAllDescriptions_ReturnsAllDescriptions()
    {
        // Act
        var descriptions = EnumHelper.GetAllDescriptions<OrderStatus>();

        // Assert
        Assert.AreEqual(5, descriptions.Count);
        Assert.AreEqual("待支付", descriptions[OrderStatus.Pending]);
        Assert.AreEqual("已支付", descriptions[OrderStatus.Paid]);
        Assert.AreEqual("已完成", descriptions[OrderStatus.Completed]);
    }

    #endregion

    #region 枚举列表测试

    [TestMethod]
    public void GetValues_ReturnsAllValues()
    {
        // Act
        var values = EnumHelper.GetValues<OrderStatus>();

        // Assert
        Assert.AreEqual(5, values.Length);
        CollectionAssert.Contains(values, OrderStatus.Pending);
        CollectionAssert.Contains(values, OrderStatus.Paid);
        CollectionAssert.Contains(values, OrderStatus.Shipped);
    }

    [TestMethod]
    public void GetNames_ReturnsAllNames()
    {
        // Act
        var names = EnumHelper.GetNames<OrderStatus>();

        // Assert
        Assert.AreEqual(5, names.Length);
        CollectionAssert.Contains(names, "Pending");
        CollectionAssert.Contains(names, "Paid");
        CollectionAssert.Contains(names, "Shipped");
    }

    [TestMethod]
    public void GetOptions_ReturnsListForDropdown()
    {
        // Act
        var options = EnumHelper.GetOptions<OrderStatus>();

        // Assert
        Assert.AreEqual(5, options.Count);

        var paidOption = options.First(o => o.Value == 1);
        Assert.AreEqual("Paid", paidOption.Name);
        Assert.AreEqual("已支付", paidOption.Description);
        Assert.AreEqual("已支付", paidOption.DisplayText);
    }

    [TestMethod]
    public void GetDictionary_ReturnsValueNamePairs()
    {
        // Act
        var dict = EnumHelper.GetDictionary<OrderStatus>();

        // Assert
        Assert.AreEqual(5, dict.Count);
        Assert.AreEqual("Paid", dict[1]);
        Assert.AreEqual("Shipped", dict[2]);
    }

    [TestMethod]
    public void GetDictionaryWithDescription_ReturnsValueDescriptionPairs()
    {
        // Act
        var dict = EnumHelper.GetDictionaryWithDescription<OrderStatus>();

        // Assert
        Assert.AreEqual(5, dict.Count);
        Assert.AreEqual("已支付", dict[1]);
        Assert.AreEqual("已发货", dict[2]);
    }

    #endregion

    #region 枚举验证测试

    [TestMethod]
    public void IsDefined_ValidValue_ReturnsTrue()
    {
        // Act & Assert
        Assert.IsTrue(EnumHelper.IsDefined<OrderStatus>(1));
        Assert.IsTrue(EnumHelper.IsDefined<OrderStatus>("Paid"));
        Assert.IsTrue(EnumHelper.IsDefined(OrderStatus.Paid));
    }

    [TestMethod]
    public void IsDefined_InvalidValue_ReturnsFalse()
    {
        // Act & Assert
        Assert.IsFalse(EnumHelper.IsDefined<OrderStatus>(999));
        Assert.IsFalse(EnumHelper.IsDefined<OrderStatus>("InvalidStatus"));
    }

    #endregion

    #region 标志位枚举操作测试

    [TestMethod]
    public void HasFlag_ChecksFlagCorrectly()
    {
        // Arrange
        var permissions = UserPermissions.Read | UserPermissions.Write;

        // Act & Assert
        Assert.IsTrue(permissions.HasFlag(UserPermissions.Read));
        Assert.IsTrue(permissions.HasFlag(UserPermissions.Write));
        Assert.IsFalse(permissions.HasFlag(UserPermissions.Delete));
    }

    [TestMethod]
    public void AddFlag_AddsNewFlag()
    {
        // Arrange
        var permissions = UserPermissions.Read;

        // Act
        var newPermissions = permissions.AddFlag(UserPermissions.Write);

        // Assert
        Assert.IsTrue(newPermissions.HasFlag(UserPermissions.Read));
        Assert.IsTrue(newPermissions.HasFlag(UserPermissions.Write));
    }

    [TestMethod]
    public void RemoveFlag_RemovesExistingFlag()
    {
        // Arrange
        var permissions = UserPermissions.Read | UserPermissions.Write | UserPermissions.Delete;

        // Act
        var newPermissions = permissions.RemoveFlag(UserPermissions.Write);

        // Assert
        Assert.IsTrue(newPermissions.HasFlag(UserPermissions.Read));
        Assert.IsFalse(newPermissions.HasFlag(UserPermissions.Write));
        Assert.IsTrue(newPermissions.HasFlag(UserPermissions.Delete));
    }

    [TestMethod]
    public void ToggleFlag_TogglesFlag()
    {
        // Arrange
        var permissions = UserPermissions.Read;

        // Act: 切换 Write（添加）
        var withWrite = permissions.ToggleFlag(UserPermissions.Write);
        Assert.IsTrue(withWrite.HasFlag(UserPermissions.Write));

        // Act: 再次切换 Write（移除）
        var withoutWrite = withWrite.ToggleFlag(UserPermissions.Write);
        Assert.IsFalse(withoutWrite.HasFlag(UserPermissions.Write));
    }

    [TestMethod]
    public void GetFlags_ReturnsAllSetFlags()
    {
        // Arrange
        var permissions = UserPermissions.Read | UserPermissions.Write | UserPermissions.Admin;

        // Act
        var flags = permissions.GetFlags().ToList();

        // Assert: None 不应该包含在内（因为值是 0）
        Assert.IsTrue(flags.Contains(UserPermissions.Read));
        Assert.IsTrue(flags.Contains(UserPermissions.Write));
        Assert.IsTrue(flags.Contains(UserPermissions.Admin));
        Assert.IsFalse(flags.Contains(UserPermissions.Delete));
    }

    [TestMethod]
    public void CombineFlags_CombinesMultipleFlags()
    {
        // Act
        var combined = EnumHelper.CombineFlags(
            UserPermissions.Read,
            UserPermissions.Write,
            UserPermissions.Delete
        );

        // Assert
        Assert.IsTrue(combined.HasFlag(UserPermissions.Read));
        Assert.IsTrue(combined.HasFlag(UserPermissions.Write));
        Assert.IsTrue(combined.HasFlag(UserPermissions.Delete));
        Assert.IsFalse(combined.HasFlag(UserPermissions.Admin));
    }

    #endregion

    #region 枚举转换测试

    [TestMethod]
    public void ToInt_ConvertsToInteger()
    {
        // Arrange
        var status = OrderStatus.Paid;

        // Act
        var intValue = status.ToInt();

        // Assert
        Assert.AreEqual(1, intValue);
    }

    [TestMethod]
    public void ToLong_ConvertsToLong()
    {
        // Arrange
        var status = OrderStatus.Shipped;

        // Act
        var longValue = status.ToLong();

        // Assert
        Assert.AreEqual(2L, longValue);
    }

    [TestMethod]
    public void ToEnum_ConvertsIntToEnum()
    {
        // Arrange
        var value = 3;

        // Act
        var status = value.ToEnum<OrderStatus>();

        // Assert
        Assert.AreEqual(OrderStatus.Completed, status);
    }

    #endregion

    #region 枚举信息测试

    [TestMethod]
    public void GetCount_ReturnsEnumCount()
    {
        // Act
        var count = EnumHelper.GetCount<OrderStatus>();

        // Assert
        Assert.AreEqual(5, count);
    }

    [TestMethod]
    public void GetMinValue_ReturnsSmallestValue()
    {
        // Act
        var min = EnumHelper.GetMinValue<OrderStatus>();

        // Assert
        Assert.AreEqual(OrderStatus.Pending, min);
    }

    [TestMethod]
    public void GetMaxValue_ReturnsLargestValue()
    {
        // Act
        var max = EnumHelper.GetMaxValue<OrderStatus>();

        // Assert
        Assert.AreEqual(OrderStatus.Cancelled, max);
    }

    [TestMethod]
    public void IsFlagsEnum_DetectsFlagsAttribute()
    {
        // Act
        var isFlagsEnum = EnumHelper.IsFlagsEnum<UserPermissions>();
        var isNotFlagsEnum = EnumHelper.IsFlagsEnum<OrderStatus>();

        // Assert
        Assert.IsTrue(isFlagsEnum);
        Assert.IsFalse(isNotFlagsEnum);
    }

    #endregion

    #region 枚举比较测试

    [TestMethod]
    public void Equals_ComparesEnumValues()
    {
        // Act & Assert
        Assert.IsTrue(EnumHelper.Equals(OrderStatus.Paid, OrderStatus.Paid));
        Assert.IsFalse(EnumHelper.Equals(OrderStatus.Paid, OrderStatus.Pending));
    }

    [TestMethod]
    public void In_ChecksIfValueInList()
    {
        // Arrange
        var status = OrderStatus.Paid;

        // Act & Assert
        Assert.IsTrue(status.In(OrderStatus.Pending, OrderStatus.Paid, OrderStatus.Shipped));
        Assert.IsFalse(status.In(OrderStatus.Completed, OrderStatus.Cancelled));
    }

    [TestMethod]
    public void NotIn_ChecksIfValueNotInList()
    {
        // Arrange
        var status = OrderStatus.Paid;

        // Act & Assert
        Assert.IsFalse(status.NotIn(OrderStatus.Pending, OrderStatus.Paid, OrderStatus.Shipped));
        Assert.IsTrue(status.NotIn(OrderStatus.Completed, OrderStatus.Cancelled));
    }

    #endregion

    #region 随机枚举测试

    [TestMethod]
    public void GetRandom_ReturnsValidEnum()
    {
        // Act
        var random = EnumHelper.GetRandom<OrderStatus>();

        // Assert
        Assert.IsTrue(EnumHelper.IsDefined(random));
    }

    [TestMethod]
    public void GetRandomExcept_ExcludesSpecifiedValues()
    {
        // Act: 多次获取随机值，确保不包含排除的值
        for (var i = 0; i < 10; i++)
        {
            var random = EnumHelper.GetRandomExcept(OrderStatus.Pending, OrderStatus.Cancelled);

            // Assert
            Assert.IsTrue(random.NotIn(OrderStatus.Pending, OrderStatus.Cancelled));
        }
    }

    #endregion

    #region 实际应用场景测试

    [TestMethod]
    public void Scenario_OrderStatusWorkflow()
    {
        // Arrange: 模拟订单状态流转
        var currentStatus = OrderStatus.Pending;

        // Act: 支付订单
        currentStatus = OrderStatus.Paid;
        Assert.AreEqual("已支付", currentStatus.GetDescription());

        // Act: 发货
        currentStatus = OrderStatus.Shipped;
        Assert.AreEqual("已发货", currentStatus.GetDescription());

        // Assert: 检查状态是否在允许的范围内
        var validStatuses = new[] { OrderStatus.Shipped, OrderStatus.Completed };
        Assert.IsTrue(currentStatus.In(validStatuses));
    }

    [TestMethod]
    public void Scenario_PermissionManagement()
    {
        // Arrange: 初始化普通用户权限
        var userPermissions = UserPermissions.Read;

        // Act: 升级为编辑权限
        userPermissions = userPermissions.AddFlag(UserPermissions.Write);
        Assert.IsTrue(userPermissions.HasFlag(UserPermissions.Write));

        // Act: 再添加删除权限
        userPermissions = userPermissions.AddFlag(UserPermissions.Delete);

        // Assert: 验证权限
        var grantedPermissions = userPermissions.GetFlags().ToList();
        Assert.AreEqual(3, grantedPermissions.Count);
        Assert.IsTrue(grantedPermissions.Contains(UserPermissions.Read));
        Assert.IsTrue(grantedPermissions.Contains(UserPermissions.Write));
        Assert.IsTrue(grantedPermissions.Contains(UserPermissions.Delete));

        // Act: 撤销写入权限
        userPermissions = userPermissions.RemoveFlag(UserPermissions.Write);
        Assert.IsFalse(userPermissions.HasFlag(UserPermissions.Write));
    }

    [TestMethod]
    public void Scenario_DropdownBinding()
    {
        // Arrange: 模拟为前端下拉框准备数据
        var statusOptions = EnumHelper.GetOptions<OrderStatus>();

        // Act: 转换为前端所需的格式
        var dropdownData = statusOptions.Select(o => new
        {
            Value = o.Value,
            Text = o.DisplayText
        }).ToList();

        // Assert
        Assert.AreEqual(5, dropdownData.Count);
        Assert.AreEqual("待支付", dropdownData[0].Text);
        Assert.AreEqual(0, dropdownData[0].Value);
    }

    [TestMethod]
    public void Scenario_StatusValidation()
    {
        // Arrange: 从前端接收状态值
        var statusFromFrontend = 2;

        // Act: 验证并转换
        if (EnumHelper.IsDefined<OrderStatus>(statusFromFrontend))
        {
            var status = statusFromFrontend.ToEnum<OrderStatus>();
            var description = status.GetDescription();

            // Assert
            Assert.AreEqual(OrderStatus.Shipped, status);
            Assert.AreEqual("已发货", description);
        }
        else
        {
            Assert.Fail("Invalid status value");
        }
    }

    [TestMethod]
    public void Scenario_ParseUserInput()
    {
        // Arrange: 用户输入的状态名称
        var userInput = "paid"; // 可能是小写

        // Act: 解析
        var status = EnumHelper.Parse<OrderStatus>(userInput);

        // Assert
        Assert.IsNotNull(status);
        Assert.AreEqual(OrderStatus.Paid, status.Value);
        Assert.AreEqual("已支付", status.Value.GetDescription());
    }

    #endregion
}