#pragma once

#include <assert.h>
#include <cfloat>  // 添加FLT_MIN所需头文件
#include <vector>
#include <functional>

namespace CCOS::Dev::Detail
{
    template <typename T>
    class TmplMould
    {
    public:
        TmplMould(T init, T min, T max, T accuracy)
        {
            m_Value = init;
            m_LimitMin = min;
            m_LimitMax = max;
            m_Accuracy = accuracy;
            assert(m_LimitMin < m_LimitMax);
        }
        virtual ~TmplMould() {}
    public:
        bool CanInc() const;
        bool CanDec() const;
        bool Verify(T value) const;
        bool Inc();
        bool Dec();
        bool Update(T value);
        bool UpdateLimitMax(T value);
        bool UpdateLimitMin(T value);
        T Get() const;
        T GetLimitMax() const;
        T GetLimitMin() const;

        bool ToNext(const std::vector<T>& ar);
        bool ToPrev(const std::vector<T>& ar);
        bool ToUpdate(T value, const std::vector<T>& ar);

        bool CanToNext(T& value, const std::vector<T>& ar);
        bool CanToPrev(T& value, const std::vector<T>& ar);
        bool CanToUpdate(T& value, const std::vector<T>& ar);

    protected:
        T m_LimitMin;
        T m_LimitMax;
        T m_Accuracy;
        T m_Value;
    };

    // 模板成员函数实现直接放在头文件中
    template <typename T>
    bool TmplMould<T>::CanInc() const
    {
        return m_Value < m_LimitMax;
    }

    template <typename T>
    bool TmplMould<T>::CanDec() const
    {
        return m_Value > m_LimitMin;
    }

    template <typename T>
    bool TmplMould<T>::Verify(T value) const
    {
        return (m_LimitMin <= value && value <= m_LimitMax);
    }

    template <typename T>
    bool TmplMould<T>::Inc()
    {
        if (m_Value >= m_LimitMax) return false;
        m_Value += m_Accuracy;
        return true;
    }

    template <typename T>
    bool TmplMould<T>::Dec()
    {
        if (m_Value <= m_LimitMin) return false;
        m_Value -= m_Accuracy;
        return true;
    }

    template <typename T>
    bool TmplMould<T>::Update(T value)
    {
        if (value < m_LimitMin) return false;
        if (value > m_LimitMax) return false;
        if (value == m_Value) return false;
        m_Value = value;
        return true;
    }

    template <typename T>
    bool TmplMould<T>::UpdateLimitMax(T value)
    {
        m_LimitMax = value;
        return true;
    }

    template <typename T>
    bool TmplMould<T>::UpdateLimitMin(T value)
    {
        m_LimitMin = value;
        return true;
    }

    template <typename T>
    T TmplMould<T>::Get() const { return m_Value; }

    template <typename T>
    T TmplMould<T>::GetLimitMax() const { return m_LimitMax; }

    template <typename T>
    T TmplMould<T>::GetLimitMin() const { return m_LimitMin; }

    template <typename T>
    bool TmplMould<T>::CanToNext(T& value, const std::vector<T>& ar)
    {
        value = m_Value;
        int setSize = ar.size();
        for (int i = 0; i < setSize; i++)
        {
            if (ar[i] == value)
            {
                if (i < setSize - 1)
                {
                    value = ar[i + 1];
                    return (m_LimitMin <= value && value <= m_LimitMax);
                }
            }
            else if (ar[i] - value > FLT_MIN)
            {
                value = ar[i];
                return (m_LimitMin <= value && value <= m_LimitMax);
            }
        }
        return false;
    }

    template <typename T>
    bool TmplMould<T>::CanToPrev(T& value, const std::vector<T>& ar)
    {
        value = m_Value;
        int setSize = ar.size();
        for (int i = setSize - 1; i >= 0; i--)
        {
            if (ar[i] == value)
            {
                if (i > 0)
                {
                    value = ar[i - 1];
                    return (m_LimitMin <= value && value <= m_LimitMax);
                }
            }
            else if (value - ar[i] > FLT_MIN)
            {
                value = ar[i];
                return (m_LimitMin <= value && value <= m_LimitMax);
            }
        }
        return false;
    }

    template <typename T>
    bool TmplMould<T>::CanToUpdate(T& value, const std::vector<T>& ar)
    {
        int setSize = ar.size();
        if (setSize == 0) return false;  // 添加空数组保护

        if (value <= ar[0])
        {
            value = ar[0];
            return (m_LimitMin <= value && value <= m_LimitMax);
        }
        else if (value >= ar[setSize - 1])
        {
            value = ar[setSize - 1];
            return (m_LimitMin <= value && value <= m_LimitMax);
        }
        else
        {
            for (int i = 0; i < setSize - 1; i++)
            {
                if (value == ar[i])
                {
                    value = ar[i];
                    return (m_LimitMin <= value && value <= m_LimitMax);
                }
                else if (value == ar[i + 1])
                {
                    value = ar[i + 1];
                    return (m_LimitMin <= value && value <= m_LimitMax);
                }
                else if (value > ar[i] && value < ar[i + 1])
                {
                    (value - ar[i]) > (ar[i + 1] - value) ? value = ar[i + 1] : value = ar[i];
                    return (m_LimitMin <= value && value <= m_LimitMax);
                }
            }
        }
        return false;
    }

    template <typename T>
    bool TmplMould<T>::ToNext(const std::vector<T>& ar)
    {
        int setSize = ar.size();
        for (int i = 0; i < setSize; i++)
        {
            if (ar[i] == m_Value)
            {
                if (i < setSize - 1)
                {
                    m_Value = ar[i + 1];
                    return true;
                }
            }
            else if (ar[i] - m_Value > FLT_MIN)
            {
                m_Value = ar[i];
                return true;
            }
        }
        return false;
    }

    template <typename T>
    bool TmplMould<T>::ToPrev(const std::vector<T>& ar)
    {
        int setSize = ar.size();
        for (int i = setSize - 1; i >= 0; i--)
        {
            if (ar[i] == m_Value)
            {
                if (i > 0)
                {
                    m_Value = ar[i - 1];
                    return true;
                }
            }
            else if (m_Value - ar[i] > FLT_MIN)
            {
                m_Value = ar[i];
                return true;
            }
        }
        return false;
    }

    template <typename T>
    bool TmplMould<T>::ToUpdate(T value, const std::vector<T>& ar)
    {
        int setSize = ar.size();
        if (setSize == 0) return false;  // 添加空数组保护

        if (value <= ar[0])
        {
            m_Value = ar[0];
            return true;
        }
        else if (value >= ar[setSize - 1])
        {
            m_Value = ar[setSize - 1];
            return true;
        }
        else
        {
            for (int i = 0; i < setSize - 1; i++)
            {
                if (value == ar[i])
                {
                    m_Value = ar[i];
                    return true;
                }
                else if (value == ar[i + 1])
                {
                    m_Value = ar[i + 1];
                    return true;
                }
                else if (value > ar[i] && value < ar[i + 1])
                {
                    (value - ar[i]) > (ar[i + 1] - value) ? m_Value = ar[i + 1] : m_Value = ar[i];
                    return true;
                }
            }
        }
        return false;
    }

    // 继续保留 TmplMouldWithWarn 的声明
    template <typename T>
    class TmplMouldWithWarn : public TmplMould<T>
    {
    protected:
        T m_WarningMin;
        T m_WarningMax;
        T m_CalibWarningMin;
        T m_CalibWarningMax;
        T m_ErrorMin;
        T m_ErrorMax;

    public:
        std::function<void()> m_OnWarningMin;
        std::function<void()> m_OnWarningMax;
        std::function<void()> m_OnCalibWarningMin;
        std::function<void()> m_OnCalibWarningMax;
        std::function<void()> m_OnErrorMin;
        std::function<void()> m_OnErrorMax;

    public:
        using super = TmplMould<T>;
        TmplMouldWithWarn(T init, T min, T WarnMin, T WarnMax, T CalibWarnMin, T CalibWarnMax, T max, T accuracy)
            : super(init, min, max, accuracy)
        {
            m_WarningMin = WarnMin;
            m_WarningMax = WarnMax;
            m_CalibWarningMin = CalibWarnMin;
            m_CalibWarningMax = CalibWarnMax;
            m_ErrorMin = min;
            m_ErrorMax = max;

            assert(m_CalibWarningMin < m_CalibWarningMax);
            assert(m_ErrorMin < m_ErrorMax);
        }
    };
}  // namespace CCOS::Dev::Detail