using BrilliantSightClient.Model.Attributes;
using BrilliantSightClient.Model.Extension;
using BrilliantSightClient.Model.GradeResult.Entity.Enums;

namespace BrilliantSightClient.Model.GradeResult.Helper;
/// <summary>
/// 数据格式化工具类
/// </summary>
public static class DoubleDataFormatHelper
{
    /// <summary>
    /// 格式为小数点后一位
    /// </summary>
    public const string DigitsFormat = "f1";
    
    /// <summary>
    /// 直径的小数格式化
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [Log]
    public static string FormatDouble_D(double value)
    {
        // 2025/03/28 维护阶段发现直径切舍为四舍五入,现在改成直接切割
        //return value.ToString("f2");
        return (Math.Floor(value*100)/100).ToString("f2");
    }
    /// <summary>
    /// 百分比用的小数格式化
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [Log]
    public static  string FormatDouble_P(double value)
    {
        return (Math.Floor(value*1000)/10).ToString(DigitsFormat);
    }
    
    
    [Log]
    public static  string FormatDouble_P2(double value)
    {
        return (Math.Floor(value * 10000) / 100).ToString("f2");
    }
    
    /// <summary>
    /// 百分比用的小数格式化
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [Log]
    public static  string FormatDouble_Avg(double value, Accuracy accuracy)
    {
        string result = "";
        if (Model.Helper.Common.RunMode == 0)
        {
            switch (accuracy)
            {
                case Accuracy.ForceTwoDecimals:
                    result = (Math.Floor(value * 100) / 100).ToString("f2");
                    break;
                case Accuracy.ForceOneDecimal:
                    result = (Math.Floor(value * 10) / 10).ToString("f1");
                    break;
                case Accuracy.HalfStepRounding:
                    result = (RoundFiveDownSixUp(value * 2) / 2).ToString("f1");
                    break;
                case Accuracy.MultipleOfFive:
                    result = (RoundFiveDownSixUp(value / 5) * 5).ToString();
                    break;
                case Accuracy.DecimalTwoStepRounding:
                    result = RoundToPointTwo(value).ToString("f1"); // 保留1位小数
                    break;
                case Accuracy.IntegerFloor:
                    result = Math.Floor(value).ToString("F1"); // 直接取整
                    break;
            }
        }
        else
        {
            //工厂模式不量化
            switch (accuracy)
            {
                case Accuracy.ForceTwoDecimals:
                    result = (Math.Floor(value * 100) / 100).ToString("f2");
                    break;
                case Accuracy.HalfStepRounding:
                case Accuracy.ForceOneDecimal:
                case Accuracy.DecimalTwoStepRounding:
                case Accuracy.IntegerFloor:
                case Accuracy.MultipleOfFive:
                    result = (Math.Floor(value * 10) / 10).ToString("f1");
                    break;
            }
        }
        return result;
    }
    
    /// <summary>
    /// 百分比用的小数格式化
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [Log]
    public static  string FormatDouble(object? value, Accuracy accuracy)
    {
        string result = "";

        double dvalue = Double.NaN;
        if (!Double.TryParse(value.ToSafeString(), out dvalue))
        {
            return string.Empty;
        }

        if (Model.Helper.Common.RunMode == 0)
        {
            switch (accuracy)
            {
                case Accuracy.ForceTwoDecimals:
                    result = (Math.Floor(dvalue * 100) / 100).ToString("f2");
                    break;
                case Accuracy.ForceOneDecimal:
                    result = (Math.Floor(dvalue * 10) / 10).ToString("f1");
                    break;
                case Accuracy.HalfStepRounding:
                    result = (RoundFiveDownSixUp(dvalue * 2) / 2).ToString("f1");
                    break;
                case Accuracy.MultipleOfFive:
                    result = (RoundFiveDownSixUp(dvalue / 5) * 5).ToString();
                    break;
                case Accuracy.DecimalTwoStepRounding:
                    result = RoundToPointTwo(dvalue).ToString("f1"); // 保留1位小数
                    break;
                case Accuracy.IntegerFloor:
                    result = Math.Floor(dvalue).ToString("F1"); // 直接取整
                    break;
            }
        }
        else
        {
            //工厂模式不量化
            switch (accuracy)
            {
                case Accuracy.ForceTwoDecimals:
                    result = (Math.Floor(dvalue * 100) / 100).ToString("f2");
                    break;
                case Accuracy.HalfStepRounding:
                case Accuracy.ForceOneDecimal:
                case Accuracy.DecimalTwoStepRounding:
                case Accuracy.IntegerFloor:
                case Accuracy.MultipleOfFive:
                    result = (Math.Floor(dvalue * 10) / 10).ToString("f1");
                    break;
            }
        }
        return result;
    }
    
    [Log]
    public static double RoundFiveDownSixUp(double value)
    {
        // 提取整数部分
        double integerPart = Math.Truncate(value);
        // 提取小数部分
        double fractionalPart = value - integerPart;

        // 判断小数部分是否大于 0.5
        return fractionalPart > 0.5 ? integerPart + 1 : integerPart;
    }
    public static double RoundToPointTwo(double value)
    {
        // 转换到10倍精度空间处理
        double scaled = value * 10;
        double remainder = scaled % 2; // 求模得到余数
    
        // 核心舍入规则：余数>=1.5时进位
        return remainder >= 1.5 ?  (scaled - remainder + 2) / 10 : (scaled - remainder) / 10; 
    }
    
    /// <summary>
    /// 直接值(角度，直径)用的小数格式化
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [Log]
    public static  string FormatDouble_A(double value)
    {
        return (Math.Floor(value * 10) / 10).ToString(DigitsFormat);
    }
    [Log]
    public static  string FormatDouble_A2(double value)
    {
        return (Math.Floor(value * 100) / 100).ToString("f2");
    }
    public static Accuracy ToAccuracy(this string value)
    {
        if (string.IsNullOrEmpty(value))
            throw new ArgumentNullException(nameof(value), "输入值不能为空");

        if (int.TryParse(value, out int numericValue))
        {
            if (Enum.IsDefined(typeof(Accuracy), numericValue))
                return (Accuracy)numericValue;
        }

        // 尝试按名称转换（处理ForceTwoDecimals等情况）
        if (Enum.TryParse<Accuracy>(value, true, out var result))
            return result;

        throw new ArgumentException($"无法将值 '{value}' 转换为有效的Accuracy枚举", nameof(value));
    }
    
}