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);

    }
}

namespace Core.UI
{
    [RequireComponent(typeof(Image))]
    public class SlicesImageFill : FloatBehaviour
    {
        [Header("Fields")]
        [SerializeField]
        private Image m_target;
        [SerializeField]
        private bool m_reverse = false;
        [SerializeField]
        private Vector2 m_range = new Vector2(0, 1f);
        [SerializeField]
        private bool m_doTweenFill = false;
        [SerializeField]
        private TweenParameter m_tweenParameter;

        private Tween m_currentTween;

        protected override void NotifyValueChanged(float nextValue, bool instant)
        {
            m_currentTween?.Kill();
            float targetFill = CalculateFillValue(nextValue);
            if (instant || !m_doTweenFill)
            {
                m_target.fillAmount = targetFill;
                return;
            }
            m_currentTween = m_target.DOFillAmount(targetFill, m_tweenParameter.duration);
            m_currentTween.ApplyParam(m_tweenParameter);
        }

        private float CalculateFillValue(float rawValue)
        {
            return Mathf.Lerp(m_range.x, m_range.y, m_reverse ? 1 - rawValue : rawValue);
        }

        private void OnDestroy()
        {
            m_currentTween?.Kill();
        }

#if UNITY_EDITOR
        private void Reset()
        {
            m_target = GetComponent<Image>();
        }
#endif
    }

    public class BoolReactorObjectActive : BoolBehaviour
    {
        [Serializable]
        public struct ObjectActivePack
        {
            public GameObject target;
            public bool inverse;
        }

        [Header("Extra param")]
        [SerializeField]
        private ObjectActivePack[] m_packs;

        protected override void NotifyValueChanged(bool value, bool instant)
        {
            for (int i = 0, length = m_packs.Length; i < length; i++)
            {
                ObjectActivePack pack = m_packs[i];
                pack.target.SetActive(pack.inverse ? !value : value);
            }
        }
    }

}

    public interface UIAreaRect
    {
        Camera GetUICamera();
        Canvas GetRootCanvas();
        void Refresh();
    }

    [ExecuteAlways]
    [RequireComponent(typeof(RectTransform))]
    public class SafeAreaRect : UIBehaviour, ILayoutSelfController
    {
        private static readonly Vector2 s_specialPivot = Vector2.zero; // HACK @Hiko self pivot
        [SerializeField]
        private RectOffset _rectOffset = new RectOffset();

        [SerializeField]
        private Camera _uiCamera;
        [SerializeField]
        private Canvas _rootCanvas;

        private RectTransform m_rect;
        private DrivenRectTransformTracker m_tracker;

        private RectTransform selfRectTransform
        {
            get
            {
                if (m_rect == null)
                {
                    m_rect = GetComponent<RectTransform>();
                }
                return m_rect;
            }
        }

        public void SetLayoutHorizontal()
        {
            Refresh();
        }

        public void SetLayoutVertical()
        {
            Refresh();
        }

        [ContextMenu("Refresh")]
        public void Refresh()
        {
#if UNITY_EDITOR
            RebuildTracker();
#endif
            Canvas rootCanvas = GetRootCanvas();
            Camera uiCamera = GetUICamera();
            RectTransform rectTransform = selfRectTransform, rootCanvasRectTransform = rootCanvas.transform as RectTransform;
            RectTransform parent = rectTransform.transform as RectTransform;
            if (parent == null)
            {
                Debug.LogError("This behaviour can not to be used on root recttransform");
            }
            if (rootCanvas == null || uiCamera == null)
            {
                return;
            }
            Rect safeRect = CalcultateCurrentSafeAreaRect();
            rectTransform.pivot = s_specialPivot;
            Vector3 worldUIPos;
            Vector2 localPos = rootCanvasRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            localPos.x += safeRect.x + _rectOffset.left;
            float deltaX = _rectOffset.horizontal;
            rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, safeRect.width - deltaX);
            localPos.y += safeRect.y + _rectOffset.bottom;
            float deltaY = _rectOffset.vertical;
            rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, safeRect.height - deltaY);
            worldUIPos = rootCanvasRectTransform.TransformPoint(localPos);
            rectTransform.position = worldUIPos;
        }

        public Camera GetUICamera()
        {
            // TODO implement the actual code to get camera while in game or in editor 
            return _uiCamera;
        }

        public Canvas GetRootCanvas()
        {
            // TODO implement the actual code to get root canvas while in game or in editor 
            return _rootCanvas;
        }

        private Rect CalcultateCurrentSafeAreaRect()
        {
            Rect safeRect;
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootRectTransform = rootCanvas.transform as RectTransform;
            Rect rootCanvasRect = rootRectTransform.rect;
            float rootCanvasWidth = rootCanvasRect.width;
            float rootCanvasHeight = rootCanvasRect.height;

            // temp pretend it is ip12
            float horizontalGap = 0.055f;
            float verticalGap = 0.053f;
            switch (SystemInfo.deviceType)
            {
                case DeviceType.Handheld:
                    Rect deviceSafeRect = Screen.safeArea;
                    if (Mathf.Approximately(deviceSafeRect.x, 0f))
                    {
                        // a device with saferect as fullrect
                        safeRect = new Rect(new Vector2(rootCanvasWidth * horizontalGap, 0f), new Vector2(rootCanvasWidth * (1f - 2 * horizontalGap), rootCanvasHeight * (1f - verticalGap)));
                    }
                    else
                    {
                        Resolution resolution = Screen.currentResolution;
                        float scale = rootCanvasWidth / resolution.width;
                        safeRect = new Rect(deviceSafeRect.x * scale, deviceSafeRect.y * scale, deviceSafeRect.width * scale, deviceSafeRect.height * scale);
                    }
                    break;
                default:
                    // HACK @Hiko it's on PC, create a temp saferect and pretend it is ip12
                    safeRect = new Rect(new Vector2(rootCanvasWidth * horizontalGap, 0f), new Vector2(rootCanvasWidth * (1f - 2 * horizontalGap), rootCanvasHeight * (1f - verticalGap)));
                    break;
            }
            return safeRect;
        }

        private void RebuildTracker()
        {
            m_tracker.Clear();
            m_tracker.Add(this, selfRectTransform, DrivenTransformProperties.All);
        }

        protected override void OnEnable()
        {
            base.OnEnable();
            RebuildTracker();
            SetDirty();
            if (Application.isPlaying)
            {
                Refresh();
            }
        }

        protected override void OnDisable()
        {
            m_tracker.Clear();
            LayoutRebuilder.MarkLayoutForRebuild(selfRectTransform);
            base.OnDisable();
        }

        private void SetDirty()
        {
            if (!IsActive())
            {
                return;
            }
            LayoutRebuilder.MarkLayoutForRebuild(selfRectTransform);
        }

#if UNITY_EDITOR

        [Header("Editor readonly debug stuff")]
        [SerializeField]
        private Rect _editorSafeRect;
        [SerializeField]
        private Vector2 _editorCurrentResolution;
        [SerializeField]
        private Vector2 _editorScreenSize;
        [SerializeField]
        private float _editorScreenFactor;
        [SerializeField]
        private float _editorScreenDpi;
        [SerializeField]
        private float _editorCanvasFactor;
        [SerializeField]
        private Rect _editorRootCanvasRect;

        private void OnDrawGizmosSelected()
        {
            UpdateEditorPreviewData();
            Color color = Color.blue;
            Rect safeRect = CalcultateCurrentSafeAreaRect();
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootRectTransform = rootCanvas.transform as RectTransform;
            Vector2 bottomLeft = rootRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            bottomLeft.x += safeRect.x;
            bottomLeft.y += safeRect.y;
            DrawBox(rootRectTransform, bottomLeft, safeRect.size, color);
            // draw safe area end

            if (Mathf.Approximately(_rectOffset.horizontal, 0f) && Mathf.Approximately(_rectOffset.vertical, 0f))
            {
                return;
            }
            Rect nextRect = safeRect;
            nextRect.width -= _rectOffset.horizontal;
            nextRect.height -= _rectOffset.vertical;
            nextRect.x += _rectOffset.left;
            nextRect.y += _rectOffset.bottom;
            bottomLeft = rootRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            bottomLeft.x += nextRect.x;
            bottomLeft.y += nextRect.y;
            color.a *= 0.8f;
            DrawBox(rootRectTransform, bottomLeft, nextRect.size, color);
            // draw actual safe area end
        }

        private void DrawBox(RectTransform reference, Vector2 bottomLeftLocalPos, Vector2 size, Color color)
        {
            Color cachedColor = Gizmos.color;
            Gizmos.color = color;
            if (reference != null)
            {
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x));
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y));
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
            }
            Gizmos.color = cachedColor;
        }

        private void UpdateEditorPreviewData()
        {
            _editorSafeRect = CalcultateCurrentSafeAreaRect();
            _editorScreenSize = new Vector2(Screen.width, Screen.height);
            _editorCurrentResolution = new Vector2(Screen.currentResolution.width, Screen.currentResolution.height);
            _editorScreenFactor = Screen.currentResolution.width / Screen.width;
            _editorScreenDpi = Screen.dpi;
            Canvas rootCanvas = GetRootCanvas();
            if (rootCanvas != null)
            {
                _editorCanvasFactor = rootCanvas.scaleFactor;
                _editorRootCanvasRect = (rootCanvas.transform as RectTransform).rect;
            }
        }

#endif

    }

     [ExecuteAlways]
    [RequireComponent(typeof(RectTransform))]
    public class ScreenRawRect : UIBehaviour, ILayoutSelfController, UIAreaRect
    {
        private static readonly Vector2 s_specialPivot = Vector2.zero; // HACK @Hiko self pivot

        [SerializeField]
        private RectOffset _rectOffset = new RectOffset();

        private RectTransform m_rect;

        private RectTransform selfRectTransform
        {
            get
            {
                if (m_rect == null)
                {
                    m_rect = GetComponent<RectTransform>();
                }
                return m_rect;
            }
        }

        // temp solution for testing
        [SerializeField]
        private Camera m_uiCamera;
        [SerializeField]
        private Canvas m_rootCanvas;

        private DrivenRectTransformTracker m_tracker;
        private RectTransform m_rectTransform;

        private RectTransform rectTransform
        {
            get
            {
                if (m_rectTransform == null)
                    m_rectTransform = GetComponent<RectTransform>();
                return m_rectTransform;
            }
        }

        public void SetLayoutHorizontal()
        {
            Refresh();
        }

        public void SetLayoutVertical()
        {
            Refresh();
        }

        [ContextMenu("Refresh")]
        public void Refresh()
        {
            Camera uiCamera = GetUICamera();
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootCanvasRectTransform = rootCanvas.transform as RectTransform;
            Rect sizeRect = rootCanvasRectTransform.rect;
            RectTransform selfRectTransform = rectTransform;
            selfRectTransform.pivot = s_specialPivot;
            Vector3 worldUIPos = RectTransformEx.ScreenToWorld(Vector2.zero, rootCanvas, uiCamera);
            selfRectTransform.position = worldUIPos;
            Vector2 localPos = selfRectTransform.localPosition;
            float leftOffset = _rectOffset.left;
            localPos.x += leftOffset;
            float deltaX = _rectOffset.horizontal;
            selfRectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, sizeRect.width - deltaX);
            float bottomOffset = _rectOffset.bottom;
            localPos.y += bottomOffset;
            float deltaY = _rectOffset.vertical;
            selfRectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, sizeRect.height - deltaY);
            selfRectTransform.localPosition = localPos;
        }

        public Camera GetUICamera()
        {
            return m_uiCamera;
        }

        public Canvas GetRootCanvas()
        {
            return m_rootCanvas;
        }

        private void SetDirty()
        {
            if (!IsActive())
            {
                return;
            }
            LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
        }

        private void RebuildTracker()
        {
            m_tracker.Clear();
            m_tracker.Add(this, selfRectTransform, DrivenTransformProperties.All);
        }

        protected override void OnEnable()
        {
            base.OnEnable();
            RebuildTracker();
            SetDirty();
        }

        protected override void OnDisable()
        {
            m_tracker.Clear();
            LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
            base.OnDisable();
        }

#if UNITY_EDITOR

        [Header("Editor readonly debug stuff")]
        [SerializeField]
        private Vector2 _editorCurrentResolution;
        [SerializeField]
        private Vector2 _editorScreenSize;
        [SerializeField]
        private float _editorScreenFactor;
        [SerializeField]
        private float _editorScreenDpi;
        [SerializeField]
        private float _editorCanvasFactor;
        [SerializeField]
        private Rect _editorRootCanvasRect;

        private void OnDrawGizmosSelected()
        {
            Color color = Color.blue;
            UpdateEditorPreviewData();
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootRectTransform = rootCanvas.transform as RectTransform;
            Rect rect = rootRectTransform.rect;
            Vector2 bottomLeft = rootRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            DrawBox(rootRectTransform, bottomLeft, new Vector2(rect.width, rect.height), color);
            // draw raw rect

            if (Mathf.Approximately(_rectOffset.horizontal, 0f) && Mathf.Approximately(_rectOffset.vertical, 0f))
            {
                return;
            }
            rect.width -= _rectOffset.horizontal;
            rect.height -= _rectOffset.vertical;
            bottomLeft.x += _rectOffset.left;
            bottomLeft.y += _rectOffset.bottom;
            DrawBox(rootRectTransform, bottomLeft, new Vector2(rect.width, rect.height), color);
        }

        private void DrawBox(RectTransform reference, Vector2 bottomLeftLocalPos, Vector2 size, Color color)
        {
            Color cachedColor = Gizmos.color;
            Gizmos.color = color;
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x));
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y));
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
            Gizmos.color = cachedColor;
        }

        private void UpdateEditorPreviewData()
        {
            _editorScreenSize = new Vector2(Screen.width, Screen.height);
            _editorCurrentResolution = new Vector2(Screen.currentResolution.width, Screen.currentResolution.height);
            _editorScreenFactor = Screen.currentResolution.width / Screen.width;
            _editorScreenDpi = Screen.dpi;
            Canvas rootCanvas = GetRootCanvas();
            if (rootCanvas != null)
            {
                _editorCanvasFactor = rootCanvas.scaleFactor;
                _editorRootCanvasRect = (rootCanvas.transform as RectTransform).rect;
            }
        }

#endif
    }

    public static class RectTransformEx
    {
        public static Vector3 GetLocalRectPosition(this RectTransform target, RectPositionType offsetType)
        {
            Vector3 result = Vector3.zero;
            Vector2 targetSize = target.rect.size;
            Vector2 targetPivot = target.pivot;

            Vector2 pivotOffset = Vector2.one * 0.5f - targetPivot;
            pivotOffset.x *= targetSize.x;
            pivotOffset.y *= targetSize.y;

            result += (Vector3)pivotOffset;

            switch (offsetType)
            {
                case RectPositionType.Top:
                    result.y += targetSize.y * 0.5f;
                    break;
                case RectPositionType.Bottom:
                    result.y -= targetSize.y * 0.5f;
                    break;
                case RectPositionType.Left:
                    result.x -= targetSize.x * 0.5f;
                    break;
                case RectPositionType.Right:
                    result.x += targetSize.x * 0.5f;
                    break;

                case RectPositionType.TopLeft:
                    result.y += targetSize.y * 0.5f;
                    result.x -= targetSize.x * 0.5f;
                    break;
                case RectPositionType.TopRight:
                    result.y += targetSize.y * 0.5f;
                    result.x += targetSize.x * 0.5f;
                    break;

                case RectPositionType.BottomLeft:
                    result.y -= targetSize.y * 0.5f;
                    result.x -= targetSize.x * 0.5f;
                    break;

                case RectPositionType.BottomRight:
                    result.y -= targetSize.y * 0.5f;
                    result.x += targetSize.x * 0.5f;
                    break;

                default:
                    break;
            }

            return result;
        }

        public static Vector3 ScreenToWorld(Vector2 screenPoint, Canvas rootCanvas, Camera uiCamera)
        {
            switch (rootCanvas.renderMode)
            {
                case RenderMode.ScreenSpaceOverlay:
                    return screenPoint;
                case RenderMode.ScreenSpaceCamera:
                    RectTransformUtility.ScreenPointToWorldPointInRectangle((RectTransform)rootCanvas.transform, screenPoint, uiCamera, out Vector3 worldPoint);
                    return worldPoint;
                case RenderMode.WorldSpace:
                    break;
            }
            throw new System.NotImplementedException();
        }

    }

    // use a string to temply store the type

    [AttributeUsage(AttributeTargets.Field)]
    public class EnumTypeQualifiedName: Attribute { }

    [DrawerPriority(DrawerPriorityLevel.WrapperPriority)]
    public class EnumTypeQualifiedNameAttributeDrawer : OdinAttributeDrawer<EnumTypeQualifiedName, string>
    {
        class EditingState
        {
            public static IEnumerable<Type> tempQuery;

            public bool wannaSet = false;
            public Type selectedType = null;
        }

        protected override void DrawPropertyLayout(GUIContent label)
        {
            string currentName = this.ValueEntry.SmartValue;
            Type enumType = string.IsNullOrEmpty(currentName) ? null : Type.GetType(currentName);
            string enumTypeNiceName = enumType == null ? "invalid!!!" : enumType.GetNiceName();

            int controlId = GUIUtility.GetControlID(FocusType.Passive);
            EditingState state = GUIUtility.GetStateObject(typeof(EditingState), controlId) as EditingState;
            if (state.wannaSet)
            {
                currentName = state.selectedType.AssemblyQualifiedName;
                state.selectedType = null;
                state.wannaSet = false;
                this.ValueEntry.SmartValue = currentName;
            }
            EditorGUILayout.BeginVertical();
            GUIStyle guiStyle = new GUIStyle(EditorStyles.label);
            guiStyle.alignment = TextAnchor.MiddleLeft;
            EditorGUILayout.LabelField(this.Property.NiceName, guiStyle);

            guiStyle = new GUIStyle(EditorStyles.popup);
            guiStyle.alignment = TextAnchor.MiddleLeft;
            if (EditorGUILayout.DropdownButton(new GUIContent($"Preview Enum Type ({enumTypeNiceName})"), FocusType.Keyboard, guiStyle))
            {
                if (EditingState.tempQuery == null)
                {
                    EditingState.tempQuery = GetTargetEnumTypes();
                }

                TypeSelector selector = new TypeSelector(EditingState.tempQuery, false);
                selector.EnableSingleClickToSelect();
                selector.ShowInPopup();
                selector.SelectionConfirmed += selection =>
                {
                    var resultTypeArray = selection.ToArray();
                    if (resultTypeArray.Length > 0)
                    {
                        Type selectedType = resultTypeArray.GetValue(0) as Type;
                        EditingState state = GUIUtility.GetStateObject(typeof(EditingState), controlId) as EditingState;
                        state.selectedType = selectedType;
                        state.wannaSet = true;
                    }
                };
            }
            EditorGUILayout.EndVertical();
        }

        private static IEnumerable<Type> GetTargetEnumTypes()
        {
            // TODO @Hiko here to get actual enum types
            TypeCache.TypeCollection cache = TypeCache.GetTypesDerivedFrom<Enum>();
            var query = cache.Where(t => t.IsEnum && t.IsPublic);
            return query;
        }

    }

    // put temply data into a sturct 

    [Serializable]
    public struct IntAsEnumEditorPack
    {
        public bool showIntAsEnumForTaggedField;
        [EnumTypeQualifiedName]
        public string enumTypeQualifiedName;
    }

    public interface IIntAsEnumPackHolder
    {
#if UNITY_EDITOR
        IntAsEnumEditorPack holderData { get; }
#endif
    }

    // draw enum popup for int

    [AttributeUsage(AttributeTargets.Field)]
    public class IntAsEnumAttribute : Attribute { }

    [DrawerPriority(DrawerPriorityLevel.WrapperPriority)]
    public class IntAsEnumAttributeDrawer : OdinAttributeDrawer<IntAsEnumAttribute, int>
    {
        protected override void DrawPropertyLayout(GUIContent label)
        {
            int nextValue, prevValue = this.ValueEntry.SmartValue;
            InspectorProperty containerProterty = this.ValueEntry.Property;
            Type holderType = typeof(IIntAsEnumPackHolder);
            Type containerType = containerProterty.ParentType;
            bool doContinue = true;
            while (doContinue)
            {
                Type parentType = containerProterty.ParentType;
                if (parentType == null)
                {
                    break;
                }
                containerType = parentType;
                containerProterty = containerProterty.Parent;
                if (holderType.IsAssignableFrom(containerType))
                {
                    break;
                }
            }

            GUIStyle guiStyle = new GUIStyle(EditorStyles.label);
            guiStyle.alignment = TextAnchor.MiddleLeft;
            if (containerType != null && holderType.IsAssignableFrom(containerType))
            {
                IIntAsEnumPackHolder holder = containerProterty.ValueEntry.WeakSmartValue as IIntAsEnumPackHolder;
                IntAsEnumEditorPack packData = holder.holderData;
                if (packData.showIntAsEnumForTaggedField)
                {
                    EditorGUILayout.BeginVertical();
                    EditorGUILayout.LabelField(this.Property.NiceName, guiStyle);
                    Type enumType = string.IsNullOrEmpty(packData.enumTypeQualifiedName) ? null : Type.GetType(packData.enumTypeQualifiedName);
                    if (enumType != null && enumType.IsEnum)
                    {
                        Enum prevEnumValue;
                        if (!enumType.IsEnumDefined(prevValue))
                        {
                            prevEnumValue = Enum.GetValues(enumType).GetValue(0) as Enum;
                        }
                        else
                        {
                            prevEnumValue = (Enum)Enum.ToObject(enumType, prevValue);
                        }
                        guiStyle = new GUIStyle(EditorStyles.popup);
                        guiStyle.stretchWidth = false;
                        guiStyle.alignment = TextAnchor.MiddleLeft;
                        Enum nextEnumValue = EditorGUILayout.EnumPopup(prevEnumValue, guiStyle);
                        nextValue = Convert.ToInt32(nextEnumValue);
                        this.ValueEntry.SmartValue = nextValue;
                        guiStyle = new GUIStyle(EditorStyles.label);
                        guiStyle.alignment = TextAnchor.MiddleLeft;
                        guiStyle.stretchWidth = false;
                        EditorGUILayout.LabelField($"int value: ({nextValue})", guiStyle);
                    }
                    EditorGUILayout.EndVertical();
                    return;
                }

            }
            // can not find the target preview enum type, draw normal int field
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField(this.Property.NiceName);
            nextValue = EditorGUILayout.IntField(prevValue);
            this.ValueEntry.SmartValue = nextValue;
            EditorGUILayout.EndHorizontal();
        }
    }

    // test case
    public class TesterA : MonoBehaviour, IIntAsEnumPackHolder
    {
    #if UNITY_EDITOR
        [SerializeField]
        private IntAsEnumEditorPack intAsEnumEditorPack;
        public IntAsEnumEditorPack holderData => intAsEnumEditorPack;
    #endif

        [Serializable]
        public struct TempStructA
        {
            [IntAsEnum]
            public int tempInt;
            public Color tempColor;
        }

        public TempStructA[] tempArray;

        [IntAsEnum]
        public int tempIntA;
    }

using UnityEngine;
using UnityEngine.UI;

[ExecuteAlways]
public class LayoutGroupTempAnimationParam : MonoBehaviour
{
    [SerializeField]
    private LayoutGroup _target;

    [SerializeField]
    private int _left;
    [SerializeField]
    private int _right;
    [SerializeField]
    private int _top;
    [SerializeField]
    private int _bottom;

    [Header("GridLayout must use GridSpacing")]
    [SerializeField]
    private bool _alsoControlSpacing;
    [SerializeField]
    private int _normalSpacing = 0;
    [SerializeField]
    private Vector2 _gridSpacing = Vector2.zero;

    private RectOffset m_targetPadding;

    public void OnDidApplyAnimationProperties()
    {
        if (_target == null)
        {
            return;
        }
        ApplyPadding();
        if (_alsoControlSpacing)
        {
            ApplySpacing();
        }
        // need to notify refresh
        RectTransform rectTransform = this.transform as RectTransform;
        LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
    }

    private void ApplyPadding()
    {
        m_targetPadding = _target.padding;
        if (m_targetPadding != null)
        {
            m_targetPadding.left = _left;
            m_targetPadding.right = _right;
            m_targetPadding.top = _top;
            m_targetPadding.bottom = _bottom;
        }
    }

    private void ApplySpacing()
    {
        if (_target is HorizontalOrVerticalLayoutGroup layoutGroup)
        {
            layoutGroup.spacing = _normalSpacing;
        }
        else if (_target is GridLayoutGroup gridLayoutGroup)
        {
            gridLayoutGroup.spacing = _gridSpacing;
        }
    }

#if UNITY_EDITOR

    private void OnValidate()
    {
        ApplyPadding();
        if (_alsoControlSpacing)
        {
            ApplySpacing();
        }
        if (!Application.isPlaying)
        {
            // need to notify refresh
            RectTransform rectTransform = this.transform as RectTransform;
            LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
        }
    }

    private void Reset()
    {
        _target = this.GetComponent<LayoutGroup>();
        m_targetPadding = _target.padding;
    }

#endif
}

public static class EditorWwiseManager
{
    static bool m_isPaused = false;

    static EditorWwiseManager()
    {
        EditorApplication.update += OnUpdate;
        EditorApplication.pauseStateChanged += OnPauseStateChanged;
    }

    private static void OnPauseStateChanged(PauseState state)
    {
        switch (state)
        {
            case PauseState.Paused:
                m_isPaused = true;
                break;
            case PauseState.Unpaused:
                m_isPaused = false;
                break;
        }
    }

    static void OnUpdate()
    {
        if (EditorUtility.audioMasterMute && !m_isPaused)
        {
            AkSoundEngine.Suspend(true);
            m_isPaused = true;
        }
        else if (!EditorUtility.audioMasterMute && m_isPaused)
        {
            AkSoundEngine.WakeupFromSuspend();
            m_isPaused = false;
        }
    }
}

public class PredicateTempTest
{
    public struct TempPack
    {
        public int tempValue;
        private static Random s_random = new Random(DateTime.Now.Millisecond);
        public static TempPack CreateTempPack()
        {
            TempPack pack = default;
            if (s_random == null)
            {
                s_random = new Random(DateTime.Now.Millisecond);
            }
            pack.tempValue = s_random.Next(0, 10);
            return pack;
        }
    }

    private static List<List<TempPack>> s_tempListContainer = new List<List<TempPack>>(10000);

    public static void DoTest(int tempCount)
    {
        FillTestData(tempCount);
        DoTestLambda();
        DoTestPassMethod();
        DoTestPassExistPredicate();
    }

    private static void FillTestData(int tempCount)
    {
        s_tempListContainer.Clear();
        s_tempListContainer.Capacity = tempCount;
        for (int i = 0; i < tempCount; i++)
        {
            List<TempPack> tempList = new List<TempPack>(tempCount);
            s_tempListContainer.Add(tempList);
            for (int j = 0; j < tempCount; j++)
            {
                tempList.Add(TempPack.CreateTempPack());
            }
        }
    }

    private static void DoTestLambda()
    {
        Console.WriteLine("");
        Console.WriteLine("TestLambda start");
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        for (int i = 0, containerSize = s_tempListContainer.Count; i < containerSize; i++)
        {
            List<TempPack> tempList = s_tempListContainer[i];
            tempList.Find((existPack) => existPack.tempValue % 5 == 0);
        }
        stopWatch.Stop();
        Console.WriteLine($"TestLambda end, result_{stopWatch.ElapsedMilliseconds}ms");
    }

    private static void DoTestPassMethod()
    {
        Console.WriteLine("");
        Console.WriteLine("PassMethod start");
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        for (int i = 0, containerSize = s_tempListContainer.Count; i < containerSize; i++)
        {
            List<TempPack> tempList = s_tempListContainer[i];
            tempList.Find(CheckPack);
        }
        stopWatch.Stop();
        Console.WriteLine($"PassMethod end, result_{stopWatch.ElapsedMilliseconds}ms");
    }

    private static void DoTestPassExistPredicate()
    {
        Console.WriteLine("");
        Console.WriteLine("PassExistPredicate start");
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        Predicate<TempPack> predicate = new Predicate<TempPack>(CheckPack);
        for (int i = 0, containerSize = s_tempListContainer.Count; i < containerSize; i++)
        {
            List<TempPack> tempList = s_tempListContainer[i];
            tempList.Find(predicate);
        }
        stopWatch.Stop();
        Console.WriteLine($"PassExistPredicate end, result_{stopWatch.ElapsedMilliseconds}ms");
    }

    private static bool CheckPack(TempPack pack)
    {
        return pack.tempValue % 5 == 0;
    }
        
}

using UnityEngine;
using UnityEngine.UI;

namespace Temp
{
    public enum RectPositionType
    {
        Center = 0,

        Top = 1,
        Bottom = 2,
        Left = 3,
        Right = 4,

        TopLeft = 5,
        TopRight = 6,

        BottomLeft = 7,
        BottomRight = 8,
    }

    public class UIElementPositionSetter : MonoBehaviour
    {
        [Header("Target setting")]
        [SerializeField]
        private RectPositionType _targetRectPosition = RectPositionType.Center;
        [SerializeField]
        private Vector2 _targetPivot = Vector2.zero;
        [SerializeField]
        private Vector2 _extraOffset = Vector2.zero;
        [SerializeField]
        private RectOffset _adaptionOffset;
        [SerializeField]
        private bool _doScreenAdaption;

        [Header("Other setting")]
        [SerializeField]
        private RectTransform _defaultBoundsCanvasTransform;
        [SerializeField]
        private bool _adjustHorizontal = true;
        [SerializeField]
        private bool _adjustVertical = true;

        public void SetPosition(RectTransform target)
        {
            RectTransform self = transform as RectTransform;
            Vector3 spawnPos = GetLocalRectPosition(self, _targetRectPosition);
            spawnPos += new Vector3(_extraOffset.x, _extraOffset.y, 0f);
            spawnPos = self.localToWorldMatrix.MultiplyPoint(spawnPos);
            target.pivot = _targetPivot;
            target.position = spawnPos;
            if (_doScreenAdaption)
            {
                // HACK @Hiko force rebuild to make sure the size is correct
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
                DoAdaption(target);
            }
        }

        public void DoAdaption(RectTransform targetTransform)
        {
            if (_adjustHorizontal)
            {
                AdjustHorizontal(targetTransform, _defaultBoundsCanvasTransform);
            }
            if (_adjustVertical)
            {
                AdjustVertical(targetTransform, _defaultBoundsCanvasTransform);
            }
        }

        public void AdjustHorizontal(RectTransform target, RectTransform outterBoundRectTransform)
        {
            Vector2 targetSize = target.rect.size;
            Matrix4x4 targetLocalToWorld = target.localToWorldMatrix;
            Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;
            Vector2 topLeftPos = GetLocalRectPosition(target, RectPositionType.TopLeft);

            Vector3 checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y * 0.5f + Vector2.left * _adaptionOffset.left);
            Vector2 leftCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 leftCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Left);
            bool leftOut = leftCheckLocalPoint.x < leftCheckBoundPoint.x;

            checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y * 0.5f + Vector2.right * targetSize.x + Vector2.right * _adaptionOffset.right);
            Vector2 rightCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 rightCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Right);
            bool rightOut = rightCheckLocalPoint.x > rightCheckBoundPoint.x;

            if (leftOut && rightOut)
            {
                // outter bound is too small
                return;
            }

            if (leftOut)
            {
                float xDelta = leftCheckLocalPoint.x - leftCheckBoundPoint.x;
                Vector3 tempPos = target.localPosition;
                tempPos.x -= xDelta;
                target.localPosition = tempPos;
            }
            if (rightOut)
            {
                float xDelta = rightCheckLocalPoint.x - rightCheckBoundPoint.x;
                Vector3 tempPos = target.localPosition;
                tempPos.x -= xDelta;
                target.localPosition = tempPos;
            }
            if (leftOut || rightOut)
            {
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
            }
        }

        public void AdjustVertical(RectTransform target, RectTransform outterBoundRectTransform)
        {
            Vector2 targetSize = target.rect.size;
            Matrix4x4 targetLocalToWorld = target.localToWorldMatrix;
            Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;
            Vector2 topLeftPos = GetLocalRectPosition(target, RectPositionType.TopLeft);

            Vector3 checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.right * targetSize.x * 0.5f + Vector2.up * _adaptionOffset.top);
            Vector2 topCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 topCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Top);
            bool topOut = topCheckLocalPoint.y > topCheckBoundPoint.y;

            checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y + Vector2.right * targetSize.x * 0.5f + Vector2.down * _adaptionOffset.bottom);
            Vector2 bottomCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 bottomCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Bottom);
            bool bottomOut = bottomCheckLocalPoint.y < bottomCheckBoundPoint.y;

            if (topOut && bottomOut)
            {
                // outter bound is too small
                return;
            }

            if (topOut)
            {
                float yDelta = topCheckLocalPoint.y - topCheckBoundPoint.y;
                Vector3 tempPos = target.localPosition;
                tempPos.y -= yDelta;
                target.localPosition = tempPos;
            }
            if (bottomOut)
            {
                float yDelta = bottomCheckLocalPoint.y - bottomCheckBoundPoint.y;
                Vector3 tempPos = target.localPosition;
                tempPos.y -= yDelta;
                target.localPosition = tempPos;
            }
            if (topOut || bottomOut)
            {
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
            }
        }

        #region position util

        public static Vector2 GetLocalRectPosition(RectTransform target, RectPositionType offsetType)
        {
            return GetLocalRectPosition(target, offsetType, Vector2.zero);
        }

        public static Vector2 GetLocalRectPosition(RectTransform target, RectPositionType offsetType, Vector2 offset)
        {
            return GetLocalRectPosition(target.rect.size, target.pivot, offsetType, offset);
        }

        public static Vector2 GetLocalRectPosition(Vector2 targetSize, Vector2 targetPivot, RectPositionType offsetType, Vector2 offset)
        {
            Vector2 bottomLeft = Vector2.zero;
            bottomLeft.x -= targetPivot.x * targetSize.x;
            bottomLeft.y -= targetPivot.y * targetSize.y;
            Vector2 result = bottomLeft;
            switch (offsetType)
            {
                case RectPositionType.Top:
                    result += Vector2.right * 0.5f * targetSize.x + Vector2.up * targetSize.y;
                    break;
                case RectPositionType.Bottom:
                    result += Vector2.right * 0.5f * targetSize.x;
                    break;
                case RectPositionType.Left:
                    result += Vector2.up * 0.5f * targetSize.y;
                    break;
                case RectPositionType.Right:
                    result += Vector2.right * targetSize.x + Vector2.up * 0.5f * targetSize.y;
                    break;
                case RectPositionType.TopLeft:
                    result += Vector2.up * targetSize.y;
                    break;
                case RectPositionType.TopRight:
                    result += Vector2.right * targetSize.x + Vector2.up * targetSize.y;
                    break;
                case RectPositionType.BottomRight:
                    result += Vector2.right * targetSize.x;
                    break;
                case RectPositionType.BottomLeft:
                default:
                    break;
            }
            return result + offset;
        }

        public static Vector3 RectPositionToWorld(RectTransform rect, RectPositionType offsetType)
        {
            return RectPositionToWorld(rect, offsetType, Vector2.zero);
        }

        public static Vector3 RectPositionToWorld(RectTransform rect, RectPositionType offsetType, Vector2 offset)
        {
            var localPosition = GetLocalRectPosition(rect, offsetType, offset);
            return rect.TransformPoint(localPosition);
        }

        private Vector2 GetTargetRectPositionInLocalReference(RectPositionType offsetType)
        {
            RectTransform self = transform as RectTransform;
            Vector2 targetPivotPos = GetLocalRectPosition(self, _targetRectPosition, _extraOffset);
            Vector2 virtualCenterPos = targetPivotPos;
            virtualCenterPos += GetLocalRectPosition(_targetSize, _targetPivot, offsetType, Vector2.zero);
            return virtualCenterPos;
        }

        #endregion

#if UNITY_EDITOR

        [Header("Preview setting")]
        [SerializeField]
        private Vector2 _targetSize = Vector2.one * 128f;
        [SerializeField]
        private Color _previewColor = Color.white;
        [SerializeField]
        private bool _doDrawAdaptionOffsetRect = false;

        [System.Serializable]
        private struct TempCheckResult
        {
            public bool previewLeftOut;
            public bool previewRightOut;
            public bool previewTopOut;
            public bool previewBottomOut;
        }

        [SerializeField]
        private TempCheckResult _checkResult;

        private bool _previewLeftOut;
        private bool _previewRightOut;
        private bool _previewTopOut;
        private bool _previewBottomOut;

        private void OnDrawGizmosSelected()
        {
            // draw A box to show the position of target
            RectTransform self = transform as RectTransform;
            Vector2 localSpawnPos = GetLocalRectPosition(self, _targetRectPosition);
            localSpawnPos += _extraOffset;

            Vector2 pivot = _targetPivot;
            Vector2 topLeftPos = localSpawnPos;
            topLeftPos.x -= pivot.x * _targetSize.x;
            topLeftPos.y -= (pivot.y - 1f) * _targetSize.y;

            if (_doScreenAdaption)
            {
                // do adaption
                if (_defaultBoundsCanvasTransform != null) // if there is no bound, we can take the screen as the bound
                {
                    Matrix4x4 localToWorld = self.localToWorldMatrix;
                    RectTransform outterBoundRectTransform = _defaultBoundsCanvasTransform;
                    Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;

                    Vector3 checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y * 0.5f + Vector2.left * _adaptionOffset.left);
                    Vector2 leftCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 leftCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Left);
                    _previewLeftOut = leftCheckLocalPoint.x < leftCheckBoundPoint.x;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y * 0.5f + Vector2.right * _targetSize.x + Vector2.right * _adaptionOffset.right);
                    Vector2 rightCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 rightCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Right);
                    _previewRightOut = rightCheckLocalPoint.x > rightCheckBoundPoint.x;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.right * _targetSize.x * 0.5f + Vector2.up * _adaptionOffset.top);
                    Vector2 topCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 topCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Top);
                    _previewTopOut = topCheckLocalPoint.y > topCheckBoundPoint.y;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y + Vector2.right * _targetSize.x * 0.5f + Vector2.down * _adaptionOffset.bottom);
                    Vector2 bottomCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 bottomCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Bottom);
                    _previewBottomOut = bottomCheckLocalPoint.y < bottomCheckBoundPoint.y;

                    if (_adjustHorizontal)
                    {
                        if (_previewLeftOut && _previewRightOut)
                        {
                            // bound too small
                        }
                        else
                        {
                            if (_previewLeftOut)
                            {
                                float xDelta = leftCheckLocalPoint.x - leftCheckBoundPoint.x;
                                Vector3 tempPos = topLeftPos;
                                tempPos.x -= xDelta;
                                topLeftPos = tempPos;
                            }
                            if (_previewRightOut)
                            {
                                float xDelta = rightCheckLocalPoint.x - rightCheckBoundPoint.x;
                                Vector3 tempPos = topLeftPos;
                                tempPos.x -= xDelta;
                                topLeftPos = tempPos;
                            }
                        }
                    }

                    if (_adjustVertical)
                    {
                        if (_previewTopOut && _previewBottomOut)
                        {
                            // bound too small
                        }
                        else
                        {
                            if (_previewTopOut)
                            {
                                float yDelta = topCheckLocalPoint.y - topCheckBoundPoint.y;
                                Vector3 tempPos = topLeftPos;
                                tempPos.y -= yDelta;
                                topLeftPos = tempPos;
                            }
                            if (_previewBottomOut)
                            {
                                float yDelta = bottomCheckLocalPoint.y - bottomCheckBoundPoint.y;
                                Vector3 tempPos = topLeftPos;
                                tempPos.y -= yDelta;
                                topLeftPos = tempPos;
                            }
                        }
                    }
                }
            }

            _checkResult.previewLeftOut = _previewLeftOut;
            _checkResult.previewRightOut = _previewRightOut;
            _checkResult.previewTopOut = _previewTopOut;
            _checkResult.previewBottomOut = _previewBottomOut;

            if (_doDrawAdaptionOffsetRect && _defaultBoundsCanvasTransform != null)
            {
                Vector2 innerBoundLeftPos = GetLocalRectPosition(_defaultBoundsCanvasTransform, RectPositionType.TopLeft, new Vector2(_adaptionOffset.left, -_adaptionOffset.top));
                Vector2 size = _defaultBoundsCanvasTransform.rect.size;
                size.x -= _adaptionOffset.horizontal;
                size.y -= _adaptionOffset.vertical;
                DrawBox(_defaultBoundsCanvasTransform, innerBoundLeftPos, size, Color.blue);
            }
            DrawBox(self, topLeftPos, _targetSize, _previewColor);
        }

        private void DrawBox(RectTransform reference, Vector2 topLeftPos, Vector2 size, Color color)
        {
            Color cachedColor = Gizmos.color;
            Gizmos.color = color;
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos), reference.TransformPoint(topLeftPos + Vector2.right * size.x));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos), reference.TransformPoint(topLeftPos + Vector2.down * size.y));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos + Vector2.right * size.x), reference.TransformPoint(topLeftPos + Vector2.right * size.x + Vector2.down * size.y));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos + Vector2.down * size.y), reference.TransformPoint(topLeftPos + Vector2.right * size.x + Vector2.down * size.y));
            Gizmos.color = cachedColor;
        }

#endif

    }
}