using System;

namespace Models;

/// <summary>
///     属性值类型（通用数值封装）
///     设计说明：
///     1) 过去固定使用 0-100 的范围，导致“精力/算力”等大数值被强行截断。
///     2) 现在改为“每个实例自带范围”，默认仍然是 0-100，兼顾直觉和可扩展性。
///     3) 这个类仅承担“数值与范围”的职责，不负责业务含义，便于在 MVC 中被复用。
///     注意事项：
///     - 运算符会保留左操作数的范围（或右操作数的范围），避免范围丢失。
///     - 如果需要无上限/无下限，请显式传入更大的 Max/更小的 Min。
///     未来扩展：
///     - 可加入“软上限/软下限”和“可见范围”等 UI 表现字段。
///     - 可增加数值变化事件，以便 View 层更高效地刷新。
/// </summary>
public sealed class PropertyValue {
    public const float DefaultMin = 0f;
    public const float DefaultMax = 100f;

    private float _value;

    /// <summary>
    ///     构造函数
    /// </summary>
    /// <param name="value">初始值</param>
    /// <param name="min">最小值</param>
    /// <param name="max">最大值</param>
    public PropertyValue(float value = 0, float min = DefaultMin, float max = DefaultMax) {
        if (max < min)
            // 兜底修正，避免传参错误导致全局异常
            (min, max) = (max, min);

        Min = min;
        Max = max;
        Value = value;
    }

    /// <summary>
    ///     构造函数（整数）
    /// </summary>
    /// <param name="value">初始值</param>
    /// <param name="min">最小值</param>
    /// <param name="max">最大值</param>
    public PropertyValue(int value, float min = DefaultMin, float max = DefaultMax)
        : this((float)value, min, max) { }

    /// <summary>
    ///     最小值
    /// </summary>
    public float Min { get; }

    /// <summary>
    ///     最大值
    /// </summary>
    public float Max { get; }

    /// <summary>
    ///     当前值（自动限制在 Min/Max 范围内）
    /// </summary>
    public float Value {
        get => _value;
        set => _value = Clamp(value, Min, Max);
    }

    /// <summary>
    ///     获取归一化值 (0.0 - 1.0)
    /// </summary>
    public float Normalized {
        get {
            if (Max <= Min) return 0f;
            return (Value - Min) / (Max - Min);
        }
    }

    /// <summary>
    ///     获取显示的整数值
    /// </summary>
    /// <returns>整数值</returns>
    public int DisplayInt() {
        return (int)_value;
    }

    /// <summary>
    ///     克隆
    /// </summary>
    /// <returns>新实例</returns>
    public PropertyValue Clone() {
        return new PropertyValue(Value, Min, Max);
    }

    /// <summary>
    ///     增加值
    /// </summary>
    /// <param name="delta">增量</param>
    public void Add(float delta) {
        Value += delta;
    }

    /// <summary>
    ///     减少值
    /// </summary>
    /// <param name="delta">减量</param>
    public void Subtract(float delta) {
        Value -= delta;
    }

    public override string ToString() {
        return DisplayInt().ToString();
    }

    // --- 隐式转换（用于简化调用，但不改变范围语义） ---
    public static implicit operator PropertyValue(int value) {
        return new PropertyValue(value);
    }

    public static implicit operator PropertyValue(float value) {
        return new PropertyValue(value);
    }

    public static implicit operator int(PropertyValue p) {
        return (int)p._value;
    }

    public static implicit operator float(PropertyValue p) {
        return p._value;
    }

    // --- 运算符重载（保留范围） ---
    public static PropertyValue operator +(PropertyValue a, int b) {
        return new PropertyValue(a._value + b, a.Min, a.Max);
    }

    public static PropertyValue operator +(int a, PropertyValue b) {
        return new PropertyValue(a + b._value, b.Min, b.Max);
    }

    public static PropertyValue operator -(PropertyValue a, int b) {
        return new PropertyValue(a._value - b, a.Min, a.Max);
    }

    public static PropertyValue operator -(int a, PropertyValue b) {
        return new PropertyValue(a - b._value, b.Min, b.Max);
    }

    public static PropertyValue operator *(PropertyValue a, int b) {
        return new PropertyValue(a._value * b, a.Min, a.Max);
    }

    public static PropertyValue operator *(int a, PropertyValue b) {
        return new PropertyValue(a * b._value, b.Min, b.Max);
    }

    public static PropertyValue operator /(PropertyValue a, int b) {
        return b == 0 ? throw new DivideByZeroException() : new PropertyValue(a._value / b, a.Min, a.Max);
    }

    public static PropertyValue operator /(int a, PropertyValue b) {
        return b._value == 0 ? throw new DivideByZeroException() : new PropertyValue(a / b._value, b.Min, b.Max);
    }

    public static PropertyValue operator +(PropertyValue a, float b) {
        return new PropertyValue(a._value + b, a.Min, a.Max);
    }

    public static PropertyValue operator +(float a, PropertyValue b) {
        return new PropertyValue(a + b._value, b.Min, b.Max);
    }

    public static PropertyValue operator -(PropertyValue a, float b) {
        return new PropertyValue(a._value - b, a.Min, a.Max);
    }

    public static PropertyValue operator -(float a, PropertyValue b) {
        return new PropertyValue(a - b._value, b.Min, b.Max);
    }

    public static PropertyValue operator *(PropertyValue a, float b) {
        return new PropertyValue(a._value * b, a.Min, a.Max);
    }

    public static PropertyValue operator *(float a, PropertyValue b) {
        return new PropertyValue(a * b._value, b.Min, b.Max);
    }

    public static PropertyValue operator /(PropertyValue a, float b) {
        return new PropertyValue(a._value / b, a.Min, a.Max);
    }

    public static PropertyValue operator /(float a, PropertyValue b) {
        return new PropertyValue(a / b._value, b.Min, b.Max);
    }

    public static PropertyValue operator +(PropertyValue a, PropertyValue b) {
        return new PropertyValue(a._value + b._value, a.Min, a.Max);
    }

    public static PropertyValue operator -(PropertyValue a, PropertyValue b) {
        return new PropertyValue(a._value - b._value, a.Min, a.Max);
    }

    public static PropertyValue operator *(PropertyValue a, PropertyValue b) {
        return new PropertyValue(a._value * b._value, a.Min, a.Max);
    }

    public static PropertyValue operator /(PropertyValue a, PropertyValue b) {
        return b._value == 0 ? throw new DivideByZeroException() : new PropertyValue(a._value / b._value, a.Min, a.Max);
    }

    private static float Clamp(float value, float min, float max) {
        if (value < min) return min;
        if (value > max) return max;
        return value;
    }
}