[ExecuteAlways, DisallowMultipleComponent, RequireComponent(typeof(RectTransform))]
public class CutRectSetter : UIBehaviour, IClipper
{
    [SerializeField]
    private Canvas _canvas;
    [SerializeField]
    private MaskableGraphic _clipTarget;

    private bool m_shouldRecalculateClipRects = false;
    private Rect m_prevClipRect = default;
    private bool m_hasClipped = false;

    public void PerformClipping()
    {
        // IDK why unity use ReferenceEquals, I just copied it from RectMask2D.cs :(
        if (ReferenceEquals(_canvas, null) || null == _clipTarget)
        {
            return;
        }

        RectTransform selfRectTransform = transform as RectTransform;
        RectTransform targetTectTransform = _clipTarget.transform as RectTransform;
        if (!IsInsideRect(selfRectTransform, targetTectTransform))
        {
            CancelClip();
            m_prevClipRect = default;
            m_shouldRecalculateClipRects = false;
            return;
        }

        Rect currentRect = selfRectTransform.rect;
        Vector2 selfPivot = selfRectTransform.pivot;
        // get pivot position
        currentRect.position = SwitchToRectTransform(selfRectTransform, targetTectTransform);
        // rect's position is bottom left
        Vector2 delta = new Vector2(-currentRect.width * selfPivot.x, -currentRect.height * selfPivot.y);
        currentRect.position += delta;

        m_shouldRecalculateClipRects = m_shouldRecalculateClipRects || m_prevClipRect != currentRect;
        if (m_shouldRecalculateClipRects)
        {
            _clipTarget.SetClipRect(default, true);
            _clipTarget.SetClipRect(currentRect, true);
            _clipTarget.Cull(currentRect, true);
            m_prevClipRect = currentRect;
            m_shouldRecalculateClipRects = false;
        }
    }

    [ContextMenu(nameof(CancelClip))]
    private void CancelClip()
    {
        _clipTarget.SetClipRect(default, true);
        m_hasClipped = false;
    }

    protected override void OnEnable()
    {
        base.OnEnable();
        m_shouldRecalculateClipRects = true;
        ClipperRegistry.Register(this);
        MaskUtilities.Notify2DMaskStateChanged(this);
    }

    protected override void OnDisable()
    {
        base.OnDisable();
        ClipperRegistry.Unregister(this);
        MaskUtilities.Notify2DMaskStateChanged(this);
        CancelClip();
    }

    protected override void OnTransformParentChanged()
    {
        m_shouldRecalculateClipRects = true;
    }

    protected override void OnCanvasHierarchyChanged()
    {
        m_shouldRecalculateClipRects = true;
    }

    #region some utils

    private readonly Vector2 RECT_TOP = new Vector2(0.5f, 1f);
    private readonly Vector2 RECT_BOTTOM = new Vector2(0.5f, 0f);
    private readonly Vector2 RECT_LEFT = new Vector2(0f, 0.5f);
    private readonly Vector2 RECT_RIGHT = new Vector2(1f, 0.5f);
    private readonly Vector2 RECT_CENTER = new Vector2(0.5f, 0.5f);

    private readonly Vector2 RECT_BOTTOM_LEFT = new Vector2(0f, 0f);
    private readonly Vector2 RECT_BOTTOM_RIGHT = new Vector2(1f, 0f);
    private readonly Vector2 RECT_TOP_LEFT = new Vector2(0f, 1f);
    private readonly Vector2 RECT_TOP_RIGHT = new Vector2(1f, 1f);

    private Vector2 SwitchToRectTransform(RectTransform from, RectTransform to)
    {
        Vector2 screenP = RectTransformUtility.WorldToScreenPoint(null, from.position);
        RectTransformUtility.ScreenPointToLocalPointInRectangle(to, screenP, null, out Vector2 localPoint);
        return localPoint;
    }

    private bool IsInsideRect(RectTransform rectTransform, RectTransform outterRect)
    {
        Vector3 checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_BOTTOM_LEFT);
        bool bottomLeftOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);
        checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_BOTTOM_RIGHT);
        bool bottomRightOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);
        checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_TOP_LEFT);
        bool topLeftOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);
        checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_TOP_RIGHT);
        bool topRightOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);

        return !(bottomLeftOut || bottomRightOut || topLeftOut || topRightOut);
    }

    private Vector3 RectOffsetToWorld(RectTransform rectTransform, Vector2 normalizedRectPosition)
    {
        Rect selfRect = rectTransform.rect;
        Vector2 localposition = Vector2.zero;
        if (RECT_CENTER == normalizedRectPosition) // RectPositionType.Center
        {
            localposition = selfRect.center;
        }
        else if (RECT_TOP == normalizedRectPosition) // RectPositionType.Top
        {
            localposition = new Vector2(selfRect.center.x, selfRect.yMax);
        }
        else if (RECT_BOTTOM == normalizedRectPosition) // RectPositionType.Bottom
        {
            localposition = new Vector2(selfRect.center.x, selfRect.yMin);
        }
        else if (RECT_LEFT == normalizedRectPosition) // RectPositionType.Left
        {
            localposition = new Vector2(selfRect.xMin, selfRect.center.y);
        }
        else if (RECT_RIGHT == normalizedRectPosition) // RectPositionType.Right
        {
            localposition = new Vector2(selfRect.xMax, selfRect.center.y);
        }
        else if (RECT_TOP_LEFT == normalizedRectPosition) // RectPositionType.TopLeft
        {
            localposition = new Vector2(selfRect.xMin, selfRect.yMax);
        }
        else if (RECT_TOP_RIGHT == normalizedRectPosition) // RectPositionType.TopRight
        {
            localposition = selfRect.max;
        }
        else if (RECT_BOTTOM_LEFT == normalizedRectPosition) // RectPositionType.BottomLeft
        {
            localposition = selfRect.min;
        }
        else if (RECT_BOTTOM_RIGHT == normalizedRectPosition) // RectPositionType.BottomRight
        {
            localposition = new Vector2(selfRect.xMax, selfRect.yMin);
        }
        else
        {
            Debug.LogError($"{normalizedRectPosition} is not a normalized rect position");
        }

        return rectTransform.TransformPoint(localposition);
    }

    #endregion

}

namespace Cysharp.Threading.Tasks
{
    public enum TweenCancelBehaviour
    {
        KillAndCancelAwait,
        // TODO @Hiko finish those cancel behaviour if really need :)
        // Kill,
        //KillWithCompleteCallback,
    }

    public  static class PrimeTweenAsyncExtensions
    {
        public struct TweenAwaiter : ICriticalNotifyCompletion
        {
            private readonly Tween tween;
            private readonly Sequence warppedSequence;

            // killed(non active) as completed.
            public bool IsCompleted => !tween.isAlive;

            public TweenAwaiter(Tween tween)
            {
                this.tween = tween;
                warppedSequence = Sequence.Create(this.tween);
            }

            public TweenAwaiter GetAwaiter()
            {
                return this;
            }

            public void GetResult() { }

            public void OnCompleted(Action continuation)
            {
                UnsafeOnCompleted(continuation);
            }

            public void UnsafeOnCompleted(Action continuation)
            {
                // onKill is called after OnCompleted, both Complete(false/true) and Kill(false/true).
                warppedSequence.OnComplete(PooledPrimeTweenCallback.Create(continuation));
            }
        }

        public static TweenAwaiter GetAwaiter(this Tween tween)
        {
            return new TweenAwaiter(tween);
        }

        public static UniTask WithCancellation(in this Tween tween, CancellationToken cancellationToken)
        {
            if (!tween.isAlive) return UniTask.CompletedTask;
            return new UniTask(TweenConfiguredSource.Create(tween, TweenCancelBehaviour.KillAndCancelAwait, cancellationToken, out var token, out _), token);
        }

        public static UniTask WithCancellation(in this Tween tween, CancellationToken cancellationToken, out Sequence warppedTween)
        {
            warppedTween = default;
            if (!tween.isAlive) return UniTask.CompletedTask;
            return new UniTask(TweenConfiguredSource.Create(tween, TweenCancelBehaviour.KillAndCancelAwait, cancellationToken, out var token, out warppedTween), token);
        }

        private sealed class TweenConfiguredSource : IUniTaskSource, ITaskPoolNode<TweenConfiguredSource>
        {
            private static TaskPool<TweenConfiguredSource> s_pool;

            private TweenConfiguredSource m_nextNode;

            private Tween m_tween;
            // use sequence to warp the original tween cuz original tween may already bind a completion callback
            private Sequence m_warppedSequence;

            private TweenCancelBehaviour m_cancelBehaviour;
            private CancellationToken m_cancellationToken;
            private CancellationTokenRegistration m_cancellationRegistration;
            bool m_isCanceled;

            private UniTaskCompletionSourceCore<AsyncUnit> m_core;

            /// <summary>
            /// event will be triggered when the tween completes normally
            /// </summary>
            private readonly Action m_tweenCompleteNotifyCallback;

            public ref TweenConfiguredSource NextNode => ref m_nextNode;

            static TweenConfiguredSource()
            {
                TaskPool.RegisterSizeGetter(typeof(TweenConfiguredSource), () => s_pool.Size);
            }

            private TweenConfiguredSource()
            {
                m_tweenCompleteNotifyCallback = OnTweenCompleteCallbackDelegate;
            }

            public static IUniTaskSource Create(Tween tween, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, out short token)
            {
                return Create(tween, cancelBehaviour, cancellationToken, out token, out _);
            }

            public static IUniTaskSource Create(Tween tween, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, out short token, out Sequence warppedTween)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    DoCancelBeforeCreate(tween, cancelBehaviour);
                    warppedTween = default;
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

                if (!s_pool.TryPop(out var result))
                {
                    result = new TweenConfiguredSource();
                }

                result.m_tween = tween;
                result.m_cancelBehaviour = cancelBehaviour;
                result.m_cancellationToken = cancellationToken;
                result.m_isCanceled = false;
                // warp the original tween and bind our comlete callback
                result.m_warppedSequence = Sequence.Create(result.m_tween);
                result.m_warppedSequence.OnComplete(result.m_tweenCompleteNotifyCallback);

                if (cancellationToken.CanBeCanceled)
                {
                    result.m_cancellationRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(x =>
                    {
                        TweenConfiguredSource source = (TweenConfiguredSource)x;
                        switch (source.m_cancelBehaviour)
                        {
                            case TweenCancelBehaviour.KillAndCancelAwait:
                            default:
                                // token canceled stop tween
                                source.m_isCanceled = true;
                                source.m_warppedSequence.Stop();
                                source.OnTweenCompleteCallbackDelegate();
                                break;
                        }
                    }, result);
                }

                TaskTracker.TrackActiveTask(result, 3);
                token = result.m_core.Version;
                warppedTween = result.m_warppedSequence;
                return result;
            }

            private static void DoCancelBeforeCreate(Tween tween, TweenCancelBehaviour tweenCancelBehaviour)
            {
                switch (tweenCancelBehaviour)
                {
                    case TweenCancelBehaviour.KillAndCancelAwait:
                    default:
                        tween.Stop();
                        break;
                }
            }

            public UniTaskStatus UnsafeGetStatus()
            {
                return m_core.UnsafeGetStatus();
            }

            public void OnCompleted(Action<object> continuation, object state, short token)
            {
                m_core.OnCompleted(continuation, state, token);
            }

            public void GetResult(short token)
            {
                try
                {
                    m_core.GetResult(token);
                }
                finally
                {
                    TryReturnSelfToPool();
                }
            }

            public UniTaskStatus GetStatus(short token)
            {
                return m_core.GetStatus(token);
            }

            private bool TryReturnSelfToPool()
            {
                TaskTracker.RemoveTracking(this);
                m_core.Reset();
                m_cancellationRegistration.Dispose();

                m_tween = default;
                m_warppedSequence = default;
                m_cancellationToken = default;
                return s_pool.TryPush(this);
            }

            /// <summary>
            /// Tween completes normally
            /// </summary>
            private void OnTweenCompleteCallbackDelegate()
            {
                if (m_isCanceled)
                {
                    m_core.TrySetCanceled(m_cancellationToken);
                }
                else
                {
                    m_core.TrySetResult(AsyncUnit.Default);
                }
            }
        }

        //----------------------------------

        public struct SequenceAwaiter : ICriticalNotifyCompletion
        {
            private readonly Sequence originSequence;
            private readonly Sequence warppedSequence;

            // killed(non active) as completed.
            public bool IsCompleted => !originSequence.isAlive;

            public SequenceAwaiter(Sequence sequence)
            {
                originSequence = sequence;
                warppedSequence = Sequence.Create();
                warppedSequence.Insert(0f, sequence);
            }

            public SequenceAwaiter GetAwaiter()
            {
                return this;
            }

            public void GetResult() { }

            public void OnCompleted(Action continuation)
            {
                UnsafeOnCompleted(continuation);
            }

            public void UnsafeOnCompleted(Action continuation)
            {
                // onKill is called after OnCompleted, both Complete(false/true) and Kill(false/true).
                warppedSequence.OnComplete(PooledPrimeTweenCallback.Create(continuation));
            }
        }

        public static SequenceAwaiter GetAwaiter(this Sequence tween)
        {
            return new SequenceAwaiter(tween);
        }

        public static UniTask WithCancellation(in this Sequence sequence, CancellationToken cancellationToken)
        {
            if (!sequence.isAlive) return UniTask.CompletedTask;
            return new UniTask(SequenceConfiguredSource.Create(sequence, TweenCancelBehaviour.KillAndCancelAwait, cancellationToken, out var token, out _), token);
        }

        public static UniTask WithCancellation(in this Sequence sequence, CancellationToken cancellationToken, out Sequence warppedTween)
        {
            warppedTween = default;
            if (!sequence.isAlive) return UniTask.CompletedTask;
            return new UniTask(SequenceConfiguredSource.Create(sequence, TweenCancelBehaviour.KillAndCancelAwait, cancellationToken, out var token, out warppedTween), token);
        }

        private sealed class SequenceConfiguredSource : IUniTaskSource, ITaskPoolNode<SequenceConfiguredSource>
        {
            private static TaskPool<SequenceConfiguredSource> s_pool;

            private SequenceConfiguredSource m_nextNode;

            private Sequence m_originSequence;
            // use sequence to warp the original sequence cuz original tween may already bind a completion callback
            private Sequence m_warppedSequence;

            private TweenCancelBehaviour m_cancelBehaviour;
            private CancellationToken m_cancellationToken;
            private CancellationTokenRegistration m_cancellationRegistration;
            bool m_isCanceled;

            private UniTaskCompletionSourceCore<AsyncUnit> m_core;

            private readonly Action m_SequenceCompleteNotifyCallback;

            public ref SequenceConfiguredSource NextNode => ref m_nextNode;

            static SequenceConfiguredSource()
            {
                TaskPool.RegisterSizeGetter(typeof(SequenceConfiguredSource), () => s_pool.Size);
            }

            private SequenceConfiguredSource()
            {
                m_SequenceCompleteNotifyCallback = OnSequenceCompleteCallbackDelegate;
            }

            public static IUniTaskSource Create(Sequence Sequence, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, out short token)
            {
                return Create(Sequence, cancelBehaviour, cancellationToken, out token, out _);
            }

            public static IUniTaskSource Create(Sequence Sequence, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, out short token, out Sequence warppedSequence)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    DoCancelBeforeCreate(Sequence, cancelBehaviour);
                    warppedSequence = default;
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

                if (!s_pool.TryPop(out var result))
                {
                    result = new SequenceConfiguredSource();
                }

                result.m_originSequence = Sequence;
                result.m_cancelBehaviour = cancelBehaviour;
                result.m_cancellationToken = cancellationToken;
                result.m_isCanceled = false;

                result.m_warppedSequence = Sequence.Create();
                result.m_warppedSequence.Insert(0f, result.m_originSequence);
                result.m_warppedSequence.OnComplete(result.m_SequenceCompleteNotifyCallback);

                if (cancellationToken.CanBeCanceled)
                {
                    result.m_cancellationRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(x =>
                    {
                        SequenceConfiguredSource source = (SequenceConfiguredSource)x;
                        switch (source.m_cancelBehaviour)
                        {
                            case TweenCancelBehaviour.KillAndCancelAwait:
                                source.m_isCanceled = true;
                                source.m_warppedSequence.Stop();
                                source.OnSequenceCompleteCallbackDelegate();
                                break;
                            default:
                                break;
                        }
                    }, result);
                }

                TaskTracker.TrackActiveTask(result, 3);
                token = result.m_core.Version;
                warppedSequence = result.m_warppedSequence;
                return result;
            }

            private static void DoCancelBeforeCreate(Sequence Sequence, TweenCancelBehaviour tweenCancelBehaviour)
            {
                switch (tweenCancelBehaviour)
                {
                    case TweenCancelBehaviour.KillAndCancelAwait:
                    default:
                        Sequence.Stop();
                        break;
                }
            }

            public UniTaskStatus UnsafeGetStatus()
            {
                return m_core.UnsafeGetStatus();
            }

            public void OnCompleted(Action<object> continuation, object state, short token)
            {
                m_core.OnCompleted(continuation, state, token);
            }

            public void GetResult(short token)
            {
                try
                {
                    m_core.GetResult(token);
                }
                finally
                {
                    TryReturnSelfToPool();
                }
            }

            public UniTaskStatus GetStatus(short token)
            {
                return m_core.GetStatus(token);
            }

            private bool TryReturnSelfToPool()
            {
                TaskTracker.RemoveTracking(this);
                m_core.Reset();
                m_cancellationRegistration.Dispose();

                m_originSequence = default;
                m_warppedSequence = default;
                m_cancellationToken = default;
                return s_pool.TryPush(this);
            }

            private void OnSequenceCompleteCallbackDelegate()
            {
                if (m_isCanceled)
                {
                    m_core.TrySetCanceled(m_cancellationToken);
                }
                else
                {
                    m_core.TrySetResult(AsyncUnit.Default);
                }
            }
        }

    }

    public sealed class PooledPrimeTweenCallback
    {
        private static readonly ConcurrentQueue<PooledPrimeTweenCallback> s_pool = new ConcurrentQueue<PooledPrimeTweenCallback>();

        private readonly Action m_runDelegate;
        private Action m_continuation;

        private PooledPrimeTweenCallback()
        {
            m_runDelegate = Run;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Action Create(Action continuation)
        {
            if (!s_pool.TryDequeue(out PooledPrimeTweenCallback item))
            {
                item = new PooledPrimeTweenCallback();
            }

            item.m_continuation = continuation;
            return item.m_runDelegate;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void Run()
        {
            Action call = m_continuation;
            m_continuation = null;
            if (call != null)
            {
                s_pool.Enqueue(this);
                call.Invoke();
            }
        }

    }
}

[CustomPropertyDrawer(typeof(NormalizedCurve))]
public class NormalizedCurvePropertyDrawer : PropertyDrawer
{
    const string CURVE_FIELD = "_curve";
    static readonly Rect RANGES = new Rect(0.0f, 0.0f, 1.0f, 1.0f);
    
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        EditorGUI.BeginProperty(position, label, property);
        var curveProperty = property.FindPropertyRelative(CURVE_FIELD);
		// ....
    }
}

string guidString = AssetDatabase.AssetPathToGUID(assetPath);
string hash = AssetDatabaseExperimental.GetArtifactHash(guidString);
AssetDatabaseExperimental.GetArtifactPaths(hash, out var paths);

CanEditMultipleObjects]
[CustomEditor(typeof(UnityEngine.Object), true)]
public class NaughtyInspector : UnityEditor.Editor
{
    // ......
}

[CustomEditor(typeof(NetworkBehaviour), true)]
[CanEditMultipleObjects]
public partial class NetworkBehaviourInspector : Editor
{
    // ......
}

namespace Core
{
    public class TempShowInInspectorAttribute : Attribute
    {
        public bool IsReadonlyField { get; private set; }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="isReadonly">If this field is readonly in inspector.
        /// Set it to readonly would save some performance</param>
        public TempShowInInspectorAttribute(bool isReadonly = true)
        {
            IsReadonlyField = isReadonly;
        }
    }
}

namespace Core.Editor
{
    public static class TempGUIHelper
    {
        public const int DRAW_DEPTH_LIMIT = 2;

        public static void DrawTempShowInInspectorField(UnityObject target, FieldInfo field, bool isReadonly = false)
        {
            object value = field.GetValue(target);
            string niceVariableName = ObjectNames.NicifyVariableName(field.Name);
            if (field.IsStatic)
            {
                niceVariableName = $"{niceVariableName}(static) ";
            }
            if (null == value)
            {
                // TODO @Hiko if field is a class pack, better to spawn one for it; But why do ppl make a data pack into class, it should just be struct;
                return;
            }
            if (TryDrawField(value, niceVariableName, field.FieldType, 0, out object nextValueObject, out bool setNextValue, isReadonly))
            {
                if (setNextValue && !isReadonly)
                {
                    field.SetValue(target, nextValueObject);
                }
            }
        }

        public static bool TryDrawField(object value, string lable, Type expectedType, int depth, out object nextValue, out bool setNextValue, bool readonlyField = false)
        {
            nextValue = null;
            setNextValue = false;
            string showLableName = lable;
            if (0 < depth) // HACK @Hiko pad left
            {
                showLableName = lable.PadLeft(lable.Length + depth * 4);
            }
            if (depth >= DRAW_DEPTH_LIMIT)
            {
                EditorGUILayout.BeginVertical();
                EditorGUILayout.LabelField($"{showLableName}(OutOfDrawDepthLimit):");
                string tempContent = value.ToString();
                tempContent = tempContent.PadLeft(tempContent.Length + depth * 4);
                EditorGUILayout.LabelField(tempContent);
                EditorGUILayout.EndVertical();
                return true;
            }
            using (new EditorGUI.DisabledScope(disabled: readonlyField))
            {
                bool isDrawn = true;
                Type valueType = Equals(value, null) ? expectedType : value.GetType();
                if (null == valueType)
                {
                    return false;
                }
                if (valueType == typeof(bool))
                {
                    bool prevBool = (bool)value;
                    bool nextBool = EditorGUILayout.Toggle(showLableName, prevBool);
                    if (setNextValue = prevBool != nextBool)
                    {
                        nextValue = nextBool;
                    }
                }
                else if (valueType == typeof(short))
                {
                    short prevShort = (short)value;
                    short nextShort = (short)Mathf.Clamp(EditorGUILayout.IntField(showLableName, (int)prevShort), short.MinValue, short.MaxValue); // need clamp
                    if (setNextValue = prevShort != nextShort)
                    {
                        nextValue = nextShort;
                    }
                }
                else if (valueType == typeof(ushort))
                {
                    ushort prevUshort = (ushort)value;
                    ushort nextUshort = (ushort)Mathf.Clamp(EditorGUILayout.IntField(showLableName, (ushort)value), ushort.MinValue, ushort.MaxValue); // need clamp
                    if (setNextValue = prevUshort != nextUshort)
                    {
                        nextValue = nextUshort;
                    }
                }
                else if (valueType == typeof(int))
                {
                    int prevInt = (int)value;
                    int nextInt = EditorGUILayout.IntField(showLableName, prevInt);
                    if (setNextValue = prevInt != nextInt)
                    {
                        nextValue = nextInt;
                    }
                }
                else if (valueType == typeof(uint))
                {
                    uint prevUint = (uint)value;
                    uint nextUint = (uint)Mathf.Clamp(EditorGUILayout.LongField(showLableName, prevUint), uint.MinValue, uint.MaxValue); // need clamp
                    if (setNextValue = prevUint != nextUint)
                    {
                        nextValue = nextUint;
                    }
                }
                else if (valueType == typeof(long))
                {
                    long prevLong = (long)value;
                    long nextLong = EditorGUILayout.LongField(showLableName, prevLong);
                    if (setNextValue = prevLong != nextLong)
                    {
                        nextValue = nextLong;
                    }
                }
                else if (valueType == typeof(ulong))
                {
                    ulong prevUlong = (ulong)value;
                    string nextUlongStr = EditorGUILayout.TextField(showLableName, prevUlong.ToString());
                    nextUlongStr = Regex.Replace(nextUlongStr, @"[^a-zA-Z0-9 ]", ""); // force convert all to number
                    if (ulong.TryParse(nextUlongStr, out ulong nextUlong) && (setNextValue = prevUlong != nextUlong))
                    {
                        nextValue = nextUlongStr;
                    }
                }
                else if (valueType == typeof(float))
                {
                    float prevFloat = (float)value;
                    float nextFloat = EditorGUILayout.FloatField(showLableName, (float)value);
                    if (setNextValue = !Mathf.Approximately(prevFloat, nextFloat))
                    {
                        nextValue = nextFloat;
                    }
                }
                else if (valueType == typeof(double))
                {
                    double prevDouble = (double)value;
                    double nextDouble = EditorGUILayout.DoubleField(showLableName, prevDouble);
                    if (setNextValue = prevDouble != nextDouble)
                    {
                        nextValue = nextDouble;
                    }
                }
                else if (valueType == typeof(string))
                {
                    string prevString = (string)value;
                    string nextString = EditorGUILayout.TextField(showLableName, prevString);
                    if (setNextValue = prevString != nextString)
                    {
                        nextValue = nextString;
                    }
                }
                else if (valueType == typeof(Vector2))
                {
                    Vector2 prevVector2 = (Vector2)value;
                    Vector2 nextVector2 = EditorGUILayout.Vector2Field(showLableName, prevVector2);
                    if (setNextValue = prevVector2 != nextVector2)
                    {
                        nextValue = prevVector2;
                    }
                }
                else if (valueType == typeof(Vector3))
                {
                    Vector3 prevVector3 = (Vector3)value;
                    Vector3 nextVector3 = EditorGUILayout.Vector3Field(showLableName, prevVector3);
                    if (setNextValue = prevVector3 != nextVector3)
                    {
                        nextValue = nextVector3;
                    }
                }
                else if (valueType == typeof(Vector4))
                {
                    Vector4 prevVector4 = (Vector4)value;
                    Vector4 nextVector4 = EditorGUILayout.Vector4Field(showLableName, prevVector4);
                    if (setNextValue = prevVector4 != nextVector4)
                    {
                        nextValue = nextVector4;
                    }
                }
                else if (valueType == typeof(Vector2Int))
                {
                    Vector2Int prevV2int = (Vector2Int)value;
                    Vector2Int nextV2int = EditorGUILayout.Vector2IntField(showLableName, prevV2int);
                    if (setNextValue = prevV2int != nextV2int)
                    {
                        nextValue = nextV2int;
                    }
                }
                else if (valueType == typeof(Vector3Int))
                {
                    Vector3Int prevV3int = (Vector3Int)value;
                    Vector3Int nextV3int = EditorGUILayout.Vector3IntField(showLableName, prevV3int);
                    if (setNextValue = prevV3int != nextV3int)
                    {
                        nextValue = nextV3int;
                    }
                }
                else if (valueType == typeof(Color))
                {
                    Color prevColor = (Color)value;
                    Color nextColor = EditorGUILayout.ColorField(showLableName, prevColor);
                    if (setNextValue = prevColor != nextColor)
                    {
                        nextValue = nextColor;
                    }
                }
                else if (valueType == typeof(Bounds))
                {
                    Bounds prevBounds = (Bounds)value;
                    Bounds nextBounds = EditorGUILayout.BoundsField(showLableName, prevBounds);
                    if (setNextValue = prevBounds != nextBounds)
                    {
                        nextValue = nextBounds;
                    }
                }
                else if (valueType == typeof(Rect))
                {
                    Rect prevRect = (Rect)value;
                    Rect nextRect = EditorGUILayout.RectField(showLableName, prevRect);
                    if (setNextValue = prevRect != nextRect)
                    {
                        nextValue = nextRect;
                    }
                }
                else if (valueType == typeof(RectInt))
                {
                    RectInt prevRectInt = (RectInt)value;
                    RectInt nextRectInt = EditorGUILayout.RectIntField(showLableName, prevRectInt);
                    if (setNextValue = !prevRectInt.Equals(nextRectInt))
                    {
                        nextValue = nextRectInt;
                    }
                }
                else if (typeof(UnityObject).IsAssignableFrom(valueType))
                {
                    UnityObject prevUnityObj = (UnityObject)value;
                    UnityObject nextUnityObj = EditorGUILayout.ObjectField(showLableName, prevUnityObj, valueType, true);
                    if (setNextValue = prevUnityObj != nextUnityObj)
                    {
                        nextValue = nextUnityObj;
                    }
                }
                else if (valueType.BaseType == typeof(Enum))
                {
                    Enum prevEnum = (Enum)value;
                    Enum nextEnum = EditorGUILayout.EnumPopup(showLableName, prevEnum);
                    if (setNextValue = prevEnum != nextEnum)
                    {
                        nextValue = nextEnum;
                    }
                }
                else if (valueType.BaseType == typeof(TypeInfo))
                {
                    bool tempPrev = GUI.enabled;
                    GUI.enabled = tempPrev;
                    EditorGUILayout.TextField(showLableName, value.ToString());
                    GUI.enabled = tempPrev;
                }
                else
                {
                    // TODO @Hiko add fold/unfold to save some space
                    bool isSerializable = null != valueType.GetCustomAttribute<SerializableAttribute>(); // check if target is Serializable.
                    if (isSerializable)
                    {
                        object structValueObject = value;
                        EditorGUILayout.LabelField(showLableName);
                        FieldInfo[] members = valueType.GetFields();
                        for (int i = 0, length = members.Length; i < length; i++)
                        {
                            FieldInfo memberInfo = members[i];
                            if (MemberTypes.Field == memberInfo.MemberType && !memberInfo.IsStatic) // I dun need static/const field
                            {
                                Type fieldType = memberInfo.FieldType; // better to pass this type in, cuz value could be null
                                object prevValueObj = memberInfo.GetValue(value);
                                if (TryDrawField(prevValueObj, memberInfo.Name, fieldType, depth + 1, out object nextValueObj, out bool setNext, readonlyField))
                                {
                                    if (setNext)
                                    {
                                        setNextValue = true;
                                        memberInfo.SetValue(structValueObject, nextValueObj);
                                    }
                                }
                                isDrawn = true;
                            }
                        }
                        nextValue = structValueObject;
                    }
                    else
                    {
                        EditorGUILayout.BeginVertical();
                        EditorGUILayout.LabelField($"{showLableName}(NonSupprtType/NonSerializable):");
                        string valueStr = value.ToString();
                        valueStr = valueStr.PadLeft(valueStr.Length + (depth + 1) * 4);
                        EditorGUILayout.LabelField(valueStr);
                        EditorGUILayout.EndVertical();
                        isDrawn = true;
                    }
                }
                return isDrawn;
            }
        }

        public static IEnumerable<FieldInfo> GetAllFields(object target, Func<FieldInfo, bool> predicate)
        {
            if (target == null)
            {
                Debug.LogError("The target object is null. Check for missing scripts.");
                yield break;
            }

            List<Type> types = GetSelfAndBaseTypes(target);

            for (int i = types.Count - 1; i >= 0; i--)
            {
                IEnumerable<FieldInfo> fieldInfos = types[i]
                    .GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly)
                    .Where(predicate);

                foreach (var fieldInfo in fieldInfos)
                {
                    yield return fieldInfo;
                }
            }
        }

        private static List<Type> GetSelfAndBaseTypes(object target)
        {
            List<Type> types = new List<Type>()
            {
                target.GetType()
            };

            while (types.Last().BaseType != null)
            {
                types.Add(types.Last().BaseType);
            }

            return types;
        }
    }
}

namespace Core.Editor
{
    [CanEditMultipleObjects]
    [CustomEditor(typeof(UnityObject), true)]
    public class TempInspector : UnityEditor.Editor
    {
        private IEnumerable<FieldInfo> m_nonSerializedFields;

        protected virtual void OnEnable()
        {
            m_nonSerializedFields = TempGUIHelper.GetAllFields(target, f => f.GetCustomAttributes(typeof(TempShowInInspectorAttribute), true).Length > 0);
        }

        public override void OnInspectorGUI()
        {
            DrawDefaultInspector(); // draw default, make sure old stuff works
            DrawNonSerializeFileds();
        }

        protected void DrawNonSerializeFileds()
        {
            if (m_nonSerializedFields.Any())
            {
                foreach (var field in m_nonSerializedFields)
                {
                    TempShowInInspectorAttribute fieldAttribute = field.GetCustomAttribute<TempShowInInspectorAttribute>();
                    bool isReadonlyField = null == fieldAttribute || fieldAttribute.IsReadonlyField || field.IsStatic; // make static fields readonly cuz I just think we should not change them
                    TempGUIHelper.DrawTempShowInInspectorField(serializedObject.targetObject, field, isReadonlyField);
                }
            }
        }

    }
}

namespace Core.UI
{
    // where T : IComparable, IComparable<T>, IConvertible, IEquatable<T> 其实就是为了限制 T 必须是这些基础类型，但是感觉还是没必要这么写
    public interface IBehaviourDispatcher<T> where T : IComparable, IComparable<T>, IConvertible, IEquatable<T>
    {
        void DispatchValueChange(T nextValue, bool instant);
    }

    public abstract class PrimitiveBehaviour<T> : MonoBehaviour where T : IComparable, IComparable<T>, IConvertible, IEquatable<T>
    {
        [SerializeField]
        private bool m_instantApplyInitValue = true;

        private bool m_hasInit = false;
        private T m_currentValue;
        private T m_previousValue;

        public T currentValue => m_currentValue;
        public T previousValue => m_previousValue;
        public bool hasInited => m_hasInit;

        /// <summary>
        /// 持有数据的一方主动调用该方法，以对表现进行更新
        /// </summary>
        /// <param name="nextValue"></param>
        /// <param name="instant">instant changing value can also used to fast forward anim</param>
        public void ChangeValue(T nextValue, bool instant)
        {
            if (m_hasInit)
            {
                if (!instant && IsValueEqual(currentValue, nextValue))
                {
                    return;
                }
                m_previousValue = m_currentValue;
                m_currentValue = nextValue;
                NotifyValueChanged(nextValue, instant);
                return;
            }

            instant = instant || m_instantApplyInitValue;
            NotifyValueChanged(nextValue, instant);
            m_previousValue = m_currentValue = nextValue;
            m_hasInit = true;
        }

        protected bool IsValueEqual(T l, T r) => 0 == l.CompareTo(r);

        protected abstract void NotifyValueChanged(T nextValue, bool instant);

    }

}

namespace Core.UI
{
    [Serializable]
    public struct BoolBehaviourDispatcher : IBehaviourDispatcher<bool>
    {
        [SerializeField]
        private BoolBehaviour[] m_behaviours;

        public void DispatchValueChange(bool nextValue, bool instant)
        {
            int count = m_behaviours.Length;
            for (int i = 0; i < count; i++)
            {
                BoolBehaviour behaviour = m_behaviours[i];
                if (behaviour.gameObject.activeInHierarchy && behaviour.enabled)
                {
                    behaviour.ChangeValue(nextValue, instant);
                }
            }
        }

#if UNITY_EDITOR
        [ContextMenu("FindInChildren")]
        private void FindInChildren(GameObject source)
        {
            var behaviors = source.GetComponentsInChildren<BoolBehaviour>();
            m_behaviours = behaviors;
        }
#endif

    }

    public abstract class BoolBehaviour : PrimitiveBehaviour<bool> 
    {
        #if UNITY_EDITOR
        [Header("Editor preview"), NonReorderable]
        public bool previewValue_editor = false;
        public bool previrwInstant = true;

        [ContextMenu("SetValuePreview")]
        public void SetValuePreview()
        {
            if (Application.isPlaying)
            {
                NotifyValueChanged(previewValue_editor, previrwInstant);
                return;
            }
            NotifyValueChanged(previewValue_editor, true);
        }
#endif
    }

}

namespace Core.UI
{
    [Serializable]
    public struct FloatBehaviourDispatcher: IBehaviourDispatcher<float>
    {
        [SerializeField]
        private FloatBehaviour[] m_behaviours;

        public void DispatchValueChange(float nextValue, bool instant)
        {
            int count = m_behaviours.Length;
            for (int i = 0; i < count; i++)
            {
                var behaviour = m_behaviours[i];
                if (behaviour.gameObject.activeInHierarchy && behaviour.enabled)
                {
                    behaviour.ChangeValue(nextValue, instant);
                }
            }
        }

#if UNITY_EDITOR
        [ContextMenu("FindInChildren")]
        private void FindInChildren(GameObject source)
        {
            var behaviors = source.GetComponentsInChildren<FloatBehaviour>();
            m_behaviours = behaviors;
        }
#endif

    }

    public abstract class FloatBehaviour : PrimitiveBehaviour<float>
    {
#if UNITY_EDITOR
        [Header("Editor preview"), NonReorderable]
        public float previewValue_editor = 1f;
        public bool previrwInstant = true;

        [ContextMenu("SetValuePreview")]
        public void SetValuePreview()
        {
            if (Application.isPlaying)
            {
                NotifyValueChanged(previewValue_editor, previrwInstant);
                return;
            }
            NotifyValueChanged(previewValue_editor, true);
        }
#endif
    }

}

namespace Core.UI
{
    [Serializable]
    public struct IntBehaviourDispatcher : IBehaviourDispatcher<int>
    {
        [SerializeField]
        private IntBehaviour[] m_behaviours;

        public void DispatchValueChange(int nextValue, bool instant)
        {
            int count = m_behaviours.Length;
            for (int i = 0; i < count; i++)
            {
                var behaviour = m_behaviours[i];
                if (behaviour.gameObject.activeInHierarchy && behaviour.enabled)
                {
                    behaviour.ChangeValue(nextValue, instant);
                }
            }
        }

#if UNITY_EDITOR
        [ContextMenu("FindInChildren")]
        private void FindInChildren(GameObject source)
        {
            var behaviors = source.GetComponentsInChildren<IntBehaviour>();
            m_behaviours = behaviors;
        }
#endif

    }

    public abstract class IntBehaviour : PrimitiveBehaviour<int> 
    {
        #if UNITY_EDITOR
        [Header("Editor preview"), NonReorderable]
        public int previewValue_editor = 0;
        public bool previrwInstant = true;

        [ContextMenu("SetValuePreview")]
        public void SetValuePreview()
        {
            if (Application.isPlaying)
            {
                NotifyValueChanged(previewValue_editor, previrwInstant);
                return;
            }
            NotifyValueChanged(previewValue_editor, true);
        }
#endif
    }

    // 根据收到的值不同 而作不同表现
    public abstract class IntSwitchBehaviour<T> : PrimitiveBehaviour<int>
    {
        [Serializable]
        public struct IntPack
        {
            public int intValue;
            public T targetValueDataPack;
        }

        [Header("Extra param")]
        [SerializeField]
        private bool m_hasDefaultPack = false;
        [SerializeField]
        private int m_defaultPackIndex = 0;
        [SerializeField]
        private bool m_unapplyPrevPack = true;
        [SerializeField]
        private IntPack[] m_packArray;

        protected sealed override void NotifyValueChanged(int nextValue, bool instant)
        {
            int length = m_packArray.Length;
            int meetIndex = -1;
            IntPack pack;
            for (int i = 0; i < length; i++)
            {
                pack = m_packArray[i];
                if (pack.intValue == nextValue)
                {
                    meetIndex = i;
                    continue;
                }
                else if (m_unapplyPrevPack)
                {
                    UnApplyPack(pack.targetValueDataPack);
                }
            }
            if (meetIndex > 0) // has meet
            {
                pack = m_packArray[meetIndex];
                ApplyPack(pack.targetValueDataPack, instant);
                return;
            }
            // apply default one
            pack = m_packArray[m_defaultPackIndex];
            ApplyPack(pack.targetValueDataPack, instant);
        }

        protected abstract void ApplyPack(T pack, bool instant);
        protected abstract void UnApplyPack(T pack);
    }

    // 持有一个数值，判断传进来的值是否相等，再做表现
    public abstract class IntEqualBehaviour : IntBehaviour
    {
        [SerializeField]
        private int m_targetValue;

        private bool m_isPreviousValueEqual = false;

        protected sealed override void NotifyValueChanged(int nextValue, bool instant)
        {
            bool isEqual = IsValueEqual(nextValue, m_targetValue);
            bool hasChanged = isEqual != m_isPreviousValueEqual;
            if (hasInited)
            {
                if (hasChanged)
                {
                    NotifyValueEqual(isEqual, instant);
                }
                return;
            }
            NotifyValueEqual(isEqual, instant);
        }

        protected abstract void NotifyValueEqual(bool equal, bool instant);

    }
}