using System;
using System.Collections.Generic;
using System.Reflection;
using Coffee.UIEffectInternal;
using UnityEngine;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.UI;

namespace Coffee.UIEffects
{
    public sealed class UIEffectContext
    {
        private static readonly UIEffectContext s_DefaultContext = new UIEffectContext();
        private static readonly List<UIVertex> s_WorkingVertices = new List<UIVertex>(1024 * 8);
        private static readonly int s_SrcBlend = Shader.PropertyToID("_SrcBlend");
        private static readonly int s_DstBlend = Shader.PropertyToID("_DstBlend");
        private static readonly int s_ToneIntensity = Shader.PropertyToID("_ToneIntensity");
        private static readonly int s_ColorFilter = Shader.PropertyToID("_ColorFilter");
        private static readonly int s_ColorValue = Shader.PropertyToID("_ColorValue");
        private static readonly int s_ColorIntensity = Shader.PropertyToID("_ColorIntensity");
        private static readonly int s_ColorGlow = Shader.PropertyToID("_ColorGlow");
        private static readonly int s_SamplingIntensity = Shader.PropertyToID("_SamplingIntensity");
        private static readonly int s_SamplingWidth = Shader.PropertyToID("_SamplingWidth");
        private static readonly int s_SamplingScale = Shader.PropertyToID("_SamplingScale");
        private static readonly int s_TransitionRate = Shader.PropertyToID("_TransitionRate");
        private static readonly int s_TransitionReverse = Shader.PropertyToID("_TransitionReverse");
        private static readonly int s_TransitionTex = Shader.PropertyToID("_TransitionTex");
        private static readonly int s_TransitionTex_ST = Shader.PropertyToID("_TransitionTex_ST");
        private static readonly int s_TransitionTex_Speed = Shader.PropertyToID("_TransitionTex_Speed");
        private static readonly int s_TransitionWidth = Shader.PropertyToID("_TransitionWidth");
        private static readonly int s_TransitionSoftness = Shader.PropertyToID("_TransitionSoftness");
        private static readonly int s_TransitionRange = Shader.PropertyToID("_TransitionRange");
        private static readonly int s_TransitionColorFilter = Shader.PropertyToID("_TransitionColorFilter");
        private static readonly int s_TransitionColor = Shader.PropertyToID("_TransitionColor");
        private static readonly int s_TransitionColorGlow = Shader.PropertyToID("_TransitionColorGlow");
        private static readonly int s_TransitionPatternReverse = Shader.PropertyToID("_TransitionPatternReverse");
        private static readonly int s_TransitionAutoPlaySpeed = Shader.PropertyToID("_TransitionAutoPlaySpeed");
        private static readonly int s_TransitionGradientTex = Shader.PropertyToID("_TransitionGradientTex");
        private static readonly int s_TargetColor = Shader.PropertyToID("_TargetColor");
        private static readonly int s_TargetRange = Shader.PropertyToID("_TargetRange");
        private static readonly int s_TargetSoftness = Shader.PropertyToID("_TargetSoftness");
        private static readonly int s_ShadowColorFilter = Shader.PropertyToID("_ShadowColorFilter");
        private static readonly int s_ShadowColor = Shader.PropertyToID("_ShadowColor");
        private static readonly int s_ShadowBlurIntensity = Shader.PropertyToID("_ShadowBlurIntensity");
        private static readonly int s_ShadowColorGlow = Shader.PropertyToID("_ShadowColorGlow");
        private static readonly int s_EdgeWidth = Shader.PropertyToID("_EdgeWidth");
        private static readonly int s_EdgeColorFilter = Shader.PropertyToID("_EdgeColorFilter");
        private static readonly int s_EdgeColor = Shader.PropertyToID("_EdgeColor");
        private static readonly int s_EdgeColorGlow = Shader.PropertyToID("_EdgeColorGlow");
        private static readonly int s_EdgeShinyAutoPlaySpeed = Shader.PropertyToID("_EdgeShinyAutoPlaySpeed");
        private static readonly int s_EdgeShinyRate = Shader.PropertyToID("_EdgeShinyRate");
        private static readonly int s_EdgeShinyWidth = Shader.PropertyToID("_EdgeShinyWidth");
        private static readonly int s_PatternArea = Shader.PropertyToID("_PatternArea");
        private static readonly int s_DetailIntensity = Shader.PropertyToID("_DetailIntensity");
        private static readonly int s_DetailThreshold = Shader.PropertyToID("_DetailThreshold");
        private static readonly int s_DetailColor = Shader.PropertyToID("_DetailColor");
        private static readonly int s_DetailTex = Shader.PropertyToID("_DetailTex");
        private static readonly int s_DetailTex_ST = Shader.PropertyToID("_DetailTex_ST");
        private static readonly int s_DetailTex_Speed = Shader.PropertyToID("_DetailTex_Speed");
        private static readonly int s_GradationIntensity = Shader.PropertyToID("_GradationIntensity");
        private static readonly int s_GradationColorFilter = Shader.PropertyToID("_GradationColorFilter");
        private static readonly int s_GradationColor1 = Shader.PropertyToID("_GradationColor1");
        private static readonly int s_GradationColor2 = Shader.PropertyToID("_GradationColor2");
        private static readonly int s_GradationColor3 = Shader.PropertyToID("_GradationColor3");
        private static readonly int s_GradationColor4 = Shader.PropertyToID("_GradationColor4");
        private static readonly int s_GradationTex = Shader.PropertyToID("_GradationTex");
        private static readonly int s_GradationTex_ST = Shader.PropertyToID("_GradationTex_ST");
        private static readonly int s_GradationRadial = Shader.PropertyToID("_GradationRadial");
        private static readonly int s_RootViewMatrix = Shader.PropertyToID("_RootViewMatrix");
        private static readonly int s_GradViewMatrix = Shader.PropertyToID("_GradViewMatrix");
        private static readonly int s_MirrorRootViewMatrix = Shader.PropertyToID("_MirrorRootViewMatrix");
        private static readonly int s_MirrorGradViewMatrix = Shader.PropertyToID("_MirrorGradViewMatrix");
        private static readonly int s_CanvasToWorldMatrix = Shader.PropertyToID("_CanvasToWorldMatrix");

        private static readonly string[] s_ToneKeywords =
        {
            "",
            "TONE_GRAYSCALE",
            "TONE_SEPIA",
            "TONE_NEGATIVE",
            "TONE_RETRO",
            "TONE_POSTERIZE"
        };

        private static readonly string[] s_ColorKeywords =
        {
            "",
            "COLOR_FILTER"
        };

        private static readonly string[] s_SamplingKeywords =
        {
            "",
            "SAMPLING_BLUR_FAST",
            "SAMPLING_BLUR_MEDIUM",
            "SAMPLING_BLUR_DETAIL",
            "SAMPLING_PIXELATION",
            "SAMPLING_RGB_SHIFT",
            "SAMPLING_EDGE_LUMINANCE",
            "SAMPLING_EDGE_ALPHA"
        };

        private static readonly string[] s_TransitionKeywords =
        {
            "",
            "TRANSITION_FADE",
            "TRANSITION_CUTOFF",
            "TRANSITION_DISSOLVE",
            "TRANSITION_SHINY",
            "TRANSITION_MASK",
            "TRANSITION_MELT",
            "TRANSITION_BURN",
            "TRANSITION_PATTERN",
            "TRANSITION_BLAZE"
        };

        private static readonly string[] s_TargetKeywords =
        {
            "",
            "TARGET_HUE",
            "TARGET_LUMINANCE"
        };

        private static readonly string[] s_EdgeKeywords =
        {
            "",
            "EDGE_PLAIN",
            "EDGE_SHINY"
        };

        private static readonly string[] s_DetailKeywords =
        {
            "",
            "DETAIL_MASKING",
            "DETAIL_MULTIPLY",
            "DETAIL_ADDITIVE",
            "DETAIL_REPLACE",
            "DETAIL_MULTIPLY_ADDITIVE",
            "DETAIL_SUBTRACTIVE"
        };

        private static readonly string[] s_GradationKeywords =
        {
            "",
            "GRADATION_GRADIENT",
            "GRADATION_COLOR2",
            "GRADATION_COLOR4"
        };

        private static readonly Vector2[][] s_ShadowVectors = new[]
        {
            Array.Empty<Vector2>(), // None
            new[] { Vector2.one }, // Shadow
            new[] { Vector2.one, Vector2.right, Vector2.up }, // Shadow3
            new[] { Vector2.one, -Vector2.one, new Vector2(1, -1), new Vector2(-1, 1) }, // Outline
            new[]
            {
                Vector2.one, -Vector2.one, new Vector2(1, -1), new Vector2(-1, 1),
                Vector2.right, Vector2.up, Vector2.left, Vector2.down
            } // Outline8
        };

        public static Func<UIVertex, Rect, UIVertex> onModifyVertex;
        public ToneFilter m_ToneFilter;
        public float m_ToneIntensity;

        public ColorFilter m_ColorFilter;
        public float m_ColorIntensity;
        public Color m_Color;
        public bool m_ColorGlow;

        public SamplingFilter m_SamplingFilter;
        public float m_SamplingIntensity;
        public float m_SamplingWidth;

        public TransitionFilter m_TransitionFilter;
        public float m_TransitionRate;
        public bool m_TransitionReverse;
        public Texture m_TransitionTex;
        public Vector2 m_TransitionTexScale;
        public Vector2 m_TransitionTexOffset;
        public Vector2 m_TransitionTexSpeed;
        public float m_TransitionRotation;
        public bool m_TransitionKeepAspectRatio;
        public float m_TransitionWidth;
        public float m_TransitionSoftness;
        public MinMax01 m_TransitionRange;
        public ColorFilter m_TransitionColorFilter;
        public Color m_TransitionColor;
        public bool m_TransitionColorGlow;
        public bool m_TransitionPatternReverse;
        public float m_TransitionAutoPlaySpeed;
        public Gradient m_TransitionGradient;

        public TargetMode m_TargetMode;
        public Color m_TargetColor;
        public float m_TargetRange;
        public float m_TargetSoftness;

        public BlendMode m_SrcBlendMode;
        public BlendMode m_DstBlendMode;

        public ShadowMode m_ShadowMode;
        public Vector2 m_ShadowDistance;
        public int m_ShadowIteration;
        public float m_ShadowFade;
        public float m_ShadowMirrorScale;
        public float m_ShadowBlurIntensity;
        public ColorFilter m_ShadowColorFilter;
        public Color m_ShadowColor;
        public bool m_ShadowColorGlow;

        public EdgeMode m_EdgeMode;
        public float m_EdgeShinyRate;
        public float m_EdgeWidth;
        public ColorFilter m_EdgeColorFilter;
        public Color m_EdgeColor;
        public bool m_EdgeColorGlow;
        public float m_EdgeShinyWidth;
        public float m_EdgeShinyAutoPlaySpeed;
        public PatternArea m_PatternArea;

        public GradationMode m_GradationMode;
        public float m_GradationIntensity;
        public GradationColorFilter m_GradationColorFilter;
        public Color m_GradationColor1;
        public Color m_GradationColor2;
        public Color m_GradationColor3;
        public Color m_GradationColor4;
        public Gradient m_GradationGradient;
        public float m_GradationOffset;
        public float m_GradationScale;
        public float m_GradationRotation;
        public TextureWrapMode m_GradationWrapMode;
        public bool m_GradationReverse;

        public DetailFilter m_DetailFilter;
        public float m_DetailIntensity;
        public MinMax01 m_DetailThreshold;
        public Color m_DetailColor;
        public Texture m_DetailTex;
        public Vector2 m_DetailTexScale;
        public Vector2 m_DetailTexOffset;
        public Vector2 m_DetailTexSpeed;

        public Flip m_Flip;

        public bool willModifyMaterial => m_ToneFilter != ToneFilter.None
                                          || m_ColorFilter != ColorFilter.None
                                          || m_SamplingFilter != SamplingFilter.None
                                          || m_TransitionFilter != TransitionFilter.None
                                          || m_SrcBlendMode != BlendMode.One
                                          || m_DstBlendMode != BlendMode.OneMinusSrcAlpha
                                          || m_ShadowMode != ShadowMode.None
                                          || m_EdgeMode != EdgeMode.None
                                          || m_DetailFilter != DetailFilter.None
                                          || m_GradationMode != GradationMode.None;

        public bool willModifyVertex => willModifyMaterial;

        public bool useViewMatrix => m_TransitionFilter != TransitionFilter.None
                                     || m_GradationMode != GradationMode.None
                                     || m_DetailFilter != DetailFilter.None
                                     || m_EdgeMode == EdgeMode.Shiny;

        /// <summary>
        /// 特效配置的稳定指纹。自动遍历所有序列化配置字段生成，因此插件新增属性时无需手动维护字段清单。
        /// 相同配置会得到相同指纹，从而可以共享同一个材质并参与合批。
        /// </summary>
        public uint configId
        {
            get
            {
                unchecked
                {
                    var h = (uint)2166136261;
                    var fields = s_ConfigFields;
                    for (var i = 0; i < fields.Length; i++)
                    {
                        var f = fields[i];
                        h = Mix(h, (uint)f.Name.GetHashCode());
                        h = Mix(h, HashValue(f.GetValue(this)));
                    }

                    // Avalanche 混淆（MurmurHash3 终混），让相近配置散列到不同指纹。
                    h ^= h >> 16;
                    h *= 0x85ebca6b;
                    h ^= h >> 13;
                    h *= 0xc2b2ae35;
                    h ^= h >> 16;
                    return h;
                }
            }
        }

        private static uint Mix(uint h, uint v)
        {
            h ^= v;
            h *= 16777619;
            return h;
        }

        /// <summary>
        /// 对任意配置值做内容哈希。值类型会逐字段展开，嵌套结构体（Color、Vector2/3/4、MinMax01 等）
        /// 无需单独写类型处理即可贡献全部数据。只有 UnityEngine.Object 和 Gradient 需要显式处理，
        /// 因为它们的默认哈希基于引用而非内容。
        /// </summary>
        private static uint HashValue(object value)
        {
            if (value == null) return 0u;

            if (value is UnityEngine.Object obj)
            {
                return obj ? (uint)obj.GetInstanceID() : 0u;
            }

            if (value is Gradient gradient)
            {
                return GradientHash(gradient);
            }

            var type = value.GetType();
            if (type.IsPrimitive || type.IsEnum)
            {
                return unchecked((uint)value.GetHashCode());
            }

            if (type.IsValueType)
            {
                return HashFields(value, type);
            }

            return unchecked((uint)value.GetHashCode());
        }

        private static uint HashFields(object boxed, Type type)
        {
            unchecked
            {
                if (!s_FieldCache.TryGetValue(type, out var fields))
                {
                    fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                    s_FieldCache[type] = fields;
                }

                var h = (uint)2166136261;
                for (var i = 0; i < fields.Length; i++)
                {
                    h = Mix(h, HashValue(fields[i].GetValue(boxed)));
                }

                return h;
            }
        }

        private static uint GradientHash(Gradient gradient)
        {
            unchecked
            {
                var h = (uint)2166136261;

                var colorKeys = gradient.colorKeys;
                for (var i = 0; i < colorKeys.Length; i++)
                {
                    h = Mix(h, HashValue(colorKeys[i].color));
                    h = Mix(h, HashValue(colorKeys[i].time));
                }

                var alphaKeys = gradient.alphaKeys;
                for (var i = 0; i < alphaKeys.Length; i++)
                {
                    h = Mix(h, HashValue(alphaKeys[i].alpha));
                    h = Mix(h, HashValue(alphaKeys[i].time));
                }

                return h;
            }
        }

        private static readonly FieldInfo[] s_ConfigFields = typeof(UIEffectContext)
            .GetFields(BindingFlags.Public | BindingFlags.Instance);

        private static readonly Dictionary<Type, FieldInfo[]> s_FieldCache =
            new Dictionary<Type, FieldInfo[]>();

        private Texture2D _gradationRampTex;
        private Texture2D _transitionRampTex;
        private bool _isGradientDirty = true;
        private bool _isTransitionGradientDirty = true;
        private static readonly Color[] s_Colors = new Color[256];

        private static readonly InternalObjectPool<Texture2D> s_TexturePool = new InternalObjectPool<Texture2D>(
            () =>
            {
                var texture = new Texture2D(s_Colors.Length, 1, TextureFormat.RGBAFloat, false, false)
                {
                    name = "GradationRamp",
                    hideFlags = HideFlags.DontSave,
                    wrapMode = TextureWrapMode.Repeat,
                    anisoLevel = 0
                };

                return texture;
            },
            texture => texture,
            _ => { });

        private Texture2D gradationRampTex
        {
            get
            {
                if (m_GradationGradient == null) return null;
                if (_gradationRampTex == null) _gradationRampTex = s_TexturePool.Rent();
                if (!_isGradientDirty) return _gradationRampTex;
                _isGradientDirty = false;

                var w = s_Colors.Length;
                for (var i = 0; i < w; i++)
                {
                    var x = m_GradationReverse ? w - 1 - i : i;
                    var t = (float)i / (w - 1);
                    s_Colors[x] = ApplyColorSpace(m_GradationGradient.Evaluate(t));
                }

                _gradationRampTex.wrapMode = m_GradationWrapMode;
                _gradationRampTex.filterMode = m_GradationGradient.mode == GradientMode.Blend
                    ? FilterMode.Bilinear
                    : FilterMode.Point;
                _gradationRampTex.SetPixels(s_Colors);
                _gradationRampTex.Apply();
                return _gradationRampTex;
            }
        }

        private Texture2D transitionRampTex
        {
            get
            {
                if (m_TransitionGradient == null) return null;
                if (_transitionRampTex == null) _transitionRampTex = s_TexturePool.Rent();
                if (!_isTransitionGradientDirty) return _transitionRampTex;
                _isTransitionGradientDirty = false;

                var w = s_Colors.Length;
                for (var i = 0; i < w; i++)
                {
                    var t = (float)i / (w - 1);
                    s_Colors[i] = ApplyColorSpace(m_TransitionGradient.Evaluate(t));
                }

                s_Colors[w - 1].a = 0;

                _transitionRampTex.wrapMode = TextureWrapMode.Clamp;
                _transitionRampTex.filterMode = m_TransitionGradient.mode == GradientMode.Blend
                    ? FilterMode.Bilinear
                    : FilterMode.Point;
                _transitionRampTex.SetPixels(s_Colors);
                _transitionRampTex.Apply();
                return _transitionRampTex;
            }
        }

        public void Reset()
        {
            _isGradientDirty = true;
            _isTransitionGradientDirty = true;
            s_TexturePool.Return(ref _gradationRampTex);
            s_TexturePool.Return(ref _transitionRampTex);
            CopyFrom(s_DefaultContext);
        }

        private void CopyFrom(UIEffectContext src)
        {
            var dst = this;
            dst.m_ToneFilter = src.m_ToneFilter;
            dst.m_ToneIntensity = src.m_ToneIntensity;

            dst.m_ColorFilter = src.m_ColorFilter;
            dst.m_Color = src.m_Color;
            dst.m_ColorIntensity = src.m_ColorIntensity;
            dst.m_ColorGlow = src.m_ColorGlow;

            dst.m_SamplingFilter = src.m_SamplingFilter;
            dst.m_SamplingIntensity = src.m_SamplingIntensity;
            dst.m_SamplingWidth = src.m_SamplingWidth;

            dst.m_TransitionFilter = src.m_TransitionFilter;
            dst.m_TransitionRate = src.m_TransitionRate;
            dst.m_TransitionReverse = src.m_TransitionReverse;
            dst.m_TransitionTex = src.m_TransitionTex;
            dst.m_TransitionTexScale = src.m_TransitionTexScale;
            dst.m_TransitionTexOffset = src.m_TransitionTexOffset;
            dst.m_TransitionTexSpeed = src.m_TransitionTexSpeed;
            dst.m_TransitionKeepAspectRatio = src.m_TransitionKeepAspectRatio;
            dst.m_TransitionRotation = src.m_TransitionRotation;
            dst.m_TransitionWidth = src.m_TransitionWidth;
            dst.m_TransitionSoftness = src.m_TransitionSoftness;
            dst.m_TransitionRange = src.m_TransitionRange;
            dst.m_TransitionColor = src.m_TransitionColor;
            dst.m_TransitionColorFilter = src.m_TransitionColorFilter;
            dst.m_TransitionColorGlow = src.m_TransitionColorGlow;
            dst.m_TransitionPatternReverse = src.m_TransitionPatternReverse;
            dst.m_TransitionAutoPlaySpeed = src.m_TransitionAutoPlaySpeed;
            dst.m_TransitionGradient = src.m_TransitionGradient;

            dst.m_TargetMode = src.m_TargetMode;
            dst.m_TargetColor = src.m_TargetColor;
            dst.m_TargetRange = src.m_TargetRange;
            dst.m_TargetSoftness = src.m_TargetSoftness;

            dst.m_SrcBlendMode = src.m_SrcBlendMode;
            dst.m_DstBlendMode = src.m_DstBlendMode;

            dst.m_ShadowMode = src.m_ShadowMode;
            dst.m_ShadowDistance = src.m_ShadowDistance;
            dst.m_ShadowIteration = src.m_ShadowIteration;
            dst.m_ShadowFade = src.m_ShadowFade;
            dst.m_ShadowMirrorScale = src.m_ShadowMirrorScale;
            dst.m_ShadowBlurIntensity = src.m_ShadowBlurIntensity;
            dst.m_ShadowColorFilter = src.m_ShadowColorFilter;
            dst.m_ShadowColor = src.m_ShadowColor;
            dst.m_ShadowColorGlow = src.m_ShadowColorGlow;

            dst.m_EdgeMode = src.m_EdgeMode;
            dst.m_EdgeShinyRate = src.m_EdgeShinyRate;
            dst.m_EdgeWidth = src.m_EdgeWidth;
            dst.m_EdgeColorFilter = src.m_EdgeColorFilter;
            dst.m_EdgeColor = src.m_EdgeColor;
            dst.m_EdgeColorGlow = src.m_EdgeColorGlow;
            dst.m_EdgeShinyAutoPlaySpeed = src.m_EdgeShinyAutoPlaySpeed;
            dst.m_EdgeShinyWidth = src.m_EdgeShinyWidth;
            dst.m_PatternArea = src.m_PatternArea;

            dst.m_GradationMode = src.m_GradationMode;
            dst.m_GradationIntensity = src.m_GradationIntensity;
            dst.m_GradationColorFilter = src.m_GradationColorFilter;
            dst.m_GradationColor1 = src.m_GradationColor1;
            dst.m_GradationColor2 = src.m_GradationColor2;
            dst.m_GradationColor3 = src.m_GradationColor3;
            dst.m_GradationColor4 = src.m_GradationColor4;
            dst.m_GradationGradient = src.m_GradationGradient;
            dst.m_GradationScale = src.m_GradationScale;
            dst.m_GradationOffset = src.m_GradationOffset;
            dst.m_GradationRotation = src.m_GradationRotation;
            dst.m_GradationWrapMode = src.m_GradationWrapMode;
            dst.m_GradationReverse = src.m_GradationReverse;

            dst.m_DetailFilter = src.m_DetailFilter;
            dst.m_DetailIntensity = src.m_DetailIntensity;
            dst.m_DetailColor = src.m_DetailColor;
            dst.m_DetailThreshold = src.m_DetailThreshold;
            dst.m_DetailTex = src.m_DetailTex;
            dst.m_DetailTexScale = src.m_DetailTexScale;
            dst.m_DetailTexOffset = src.m_DetailTexOffset;
            dst.m_DetailTexSpeed = src.m_DetailTexSpeed;

            dst.m_Flip = src.m_Flip;
        }

        public void SetGradationDirty()
        {
            _isGradientDirty = true;
        }

        public void SetTransitionGradationDirty()
        {
            _isTransitionGradientDirty = true;
        }

        public void ApplyToMaterial(Material material, float actualSamplingScale = 1f)
        {
            if (material == null) return;

            Profiler.BeginSample("(UIE)[UIEffect] ApplyToMaterial");

            material.SetInt(s_SrcBlend, (int)m_SrcBlendMode);
            material.SetInt(s_DstBlend, (int)m_DstBlendMode);

            material.SetFloat(s_ToneIntensity, Mathf.Clamp01(m_ToneIntensity));

            material.SetInt(s_ColorFilter, (int)m_ColorFilter);
            material.SetColor(s_ColorValue, ApplyColorSpace(m_Color));
            material.SetFloat(s_ColorIntensity, Mathf.Clamp01(m_ColorIntensity));
            material.SetInt(s_ColorGlow, m_ColorGlow ? 1 : 0);

            material.SetFloat(s_SamplingIntensity, Mathf.Clamp01(m_SamplingIntensity));
            material.SetFloat(s_SamplingWidth, m_SamplingWidth);
            material.SetFloat(s_SamplingScale, actualSamplingScale);

            material.SetFloat(s_TransitionRate, Mathf.Clamp01(m_TransitionRate));
            material.SetInt(s_TransitionReverse, m_TransitionReverse ? 1 : 0);
            material.SetTexture(s_TransitionTex, m_TransitionFilter != 0 ? m_TransitionTex : null);
            material.SetVector(s_TransitionTex_ST,
                new Vector4(m_TransitionTexScale.x, m_TransitionTexScale.y,
                    m_TransitionTexOffset.x, m_TransitionTexOffset.y));
            material.SetVector(s_TransitionTex_Speed, m_TransitionTexSpeed);
            material.SetFloat(s_TransitionWidth, Mathf.Clamp01(m_TransitionWidth));
            material.SetFloat(s_TransitionSoftness, Mathf.Clamp01(m_TransitionSoftness));
            material.SetVector(s_TransitionRange, new Vector2(m_TransitionRange.min, m_TransitionRange.max));
            material.SetInt(s_TransitionColorFilter, (int)m_TransitionColorFilter);
            material.SetColor(s_TransitionColor, ApplyColorSpace(m_TransitionColor));
            material.SetInt(s_TransitionColorGlow, m_TransitionColorGlow ? 1 : 0);
            material.SetInt(s_TransitionPatternReverse, m_TransitionPatternReverse ? 1 : 0);
            material.SetFloat(s_TransitionAutoPlaySpeed, m_TransitionAutoPlaySpeed);
            material.SetTexture(s_TransitionGradientTex,
                m_TransitionFilter == TransitionFilter.Blaze ? transitionRampTex : null);

            material.SetColor(s_TargetColor, ApplyColorSpace(m_TargetColor));
            material.SetFloat(s_TargetRange, Mathf.Clamp01(m_TargetRange));
            material.SetFloat(s_TargetSoftness, Mathf.Clamp01(m_TargetSoftness));

            switch (m_SamplingFilter)
            {
                case SamplingFilter.BlurFast:
                case SamplingFilter.BlurMedium:
                case SamplingFilter.BlurDetail:
                    material.SetFloat(s_ShadowBlurIntensity, Mathf.Clamp01(m_ShadowBlurIntensity));
                    break;
                default:
                    material.SetFloat(s_ShadowBlurIntensity, Mathf.Clamp01(m_SamplingIntensity));
                    break;
            }

            material.SetInt(s_ShadowColorFilter, (int)m_ShadowColorFilter);
            material.SetColor(s_ShadowColor, ApplyColorSpace(m_ShadowColor));
            material.SetInt(s_ShadowColorGlow, m_ShadowColorGlow ? 1 : 0);

            material.SetFloat(s_EdgeWidth, Mathf.Clamp01(m_EdgeWidth));
            material.SetInt(s_EdgeColorFilter, (int)m_EdgeColorFilter);
            material.SetColor(s_EdgeColor, ApplyColorSpace(m_EdgeColor));
            material.SetInt(s_EdgeColorGlow, m_EdgeColorGlow ? 1 : 0);
            material.SetFloat(s_EdgeShinyRate, Mathf.Clamp01(m_EdgeShinyRate));
            material.SetFloat(s_EdgeShinyWidth, Mathf.Clamp01(m_EdgeShinyWidth));
            material.SetFloat(s_EdgeShinyAutoPlaySpeed, m_EdgeShinyAutoPlaySpeed);
            material.SetInt(s_PatternArea, m_EdgeMode != EdgeMode.None ? (int)m_PatternArea : 0);

            material.SetTexture(s_GradationTex, m_GradationMode != 0 ? gradationRampTex : null);
            material.SetVector(s_GradationTex_ST, GetGradationScaleAndOffset());

            material.SetFloat(s_GradationIntensity, m_GradationIntensity);
            material.SetInt(s_GradationColorFilter, (int)m_GradationColorFilter);
            material.SetColor(s_GradationColor1, ApplyColorSpace(m_GradationColor1));
            material.SetColor(s_GradationColor2, ApplyColorSpace(m_GradationColor2));
            material.SetColor(s_GradationColor3, ApplyColorSpace(m_GradationColor3));
            material.SetColor(s_GradationColor4, ApplyColorSpace(m_GradationColor4));
            material.SetInt(s_GradationRadial, m_GradationMode == GradationMode.Radial
#pragma warning disable CS0612 // Type or member is obsolete
                                               || m_GradationMode == GradationMode.RadialDetail
#pragma warning restore CS0612
                                               || m_GradationMode == GradationMode.RadialGradient
                ? 1
                : 0);

            material.SetFloat(s_DetailIntensity, Mathf.Clamp01(m_DetailIntensity));
            material.SetColor(s_DetailColor, ApplyColorSpace(m_DetailColor));
            material.SetVector(s_DetailThreshold, new Vector2(m_DetailThreshold.min, m_DetailThreshold.max));
            material.SetTexture(s_DetailTex, m_DetailFilter != 0 ? m_DetailTex : null);
            material.SetVector(s_DetailTex_ST,
                new Vector4(m_DetailTexScale.x, m_DetailTexScale.y,
                    m_DetailTexOffset.x, m_DetailTexOffset.y));
            material.SetVector(s_DetailTex_Speed, m_DetailTexSpeed);

            SetKeyword(material, s_ToneKeywords, (int)m_ToneFilter);
            SetKeyword(material, s_ColorKeywords, m_ColorFilter != 0 || m_ShadowMode != 0 ? 1 : 0);
            SetKeyword(material, s_SamplingKeywords, (int)m_SamplingFilter);
            SetKeyword(material, s_TransitionKeywords, (int)m_TransitionFilter);
            SetKeyword(material, s_EdgeKeywords, (int)m_EdgeMode);
            SetKeyword(material, s_DetailKeywords, (int)m_DetailFilter);
            SetKeyword(material, s_TargetKeywords, (int)m_TargetMode);

            switch (m_GradationMode)
            {
                case GradationMode.None:
                    SetKeyword(material, s_GradationKeywords, 0);
                    break;
                case GradationMode.HorizontalGradient:
                case GradationMode.VerticalGradient:
                case GradationMode.AngleGradient:
                case GradationMode.RadialGradient:
                    SetKeyword(material, s_GradationKeywords, 1);
                    break;
                case GradationMode.Horizontal:
                case GradationMode.Vertical:
                case GradationMode.DiagonalToRightBottom:
                case GradationMode.DiagonalToLeftBottom:
                case GradationMode.Angle:
                case GradationMode.Radial:
#pragma warning disable CS0612 // Type or member is obsolete
                case GradationMode.RadialDetail:
#pragma warning restore CS0612
                    SetKeyword(material, s_GradationKeywords, 2);
                    break;
                case GradationMode.Diagonal:
                    SetKeyword(material, s_GradationKeywords, 3);
                    break;
            }

            Profiler.EndSample();
        }

        public void SetEnablePreview(bool enable, Material material)
        {
            if (material == null) return;
            material.SetVector(s_TransitionTex_Speed, enable ? (Vector4)m_TransitionTexSpeed : Vector4.zero);
            material.SetVector(s_DetailTex_Speed, enable ? (Vector4)m_DetailTexSpeed : Vector4.zero);
            material.SetFloat(s_TransitionAutoPlaySpeed, enable ? m_TransitionAutoPlaySpeed : 0);
            material.SetFloat(s_EdgeShinyAutoPlaySpeed, enable ? m_EdgeShinyAutoPlaySpeed : 0);
        }

        public void UpdateViewMatrix(Material material, RectTransform transitionRoot, Canvas canvas)
        {
            if (material == null) return;

            var size = transitionRoot.rect.size;
            var scale = new Vector3(1f / size.x, 1f / size.y, 1f);
            if (m_TransitionKeepAspectRatio && !Mathf.Approximately(scale.x, scale.y))
            {
                scale.x = scale.y = Mathf.Min(scale.x, scale.y);
            }

            if (0 != (m_Flip & Flip.Effect))
            {
                scale.x = 0 != (m_Flip & Flip.Horizontal) ? -scale.x : scale.x;
                scale.y = 0 != (m_Flip & Flip.Vertical) ? -scale.y : scale.y;
            }

            var pivot = new Vector3(0.5f, 0.5f);
            var offset = (transitionRoot.pivot - (Vector2)pivot) * size;
            var w2LMat = Matrix4x4.Translate(offset) * transitionRoot.worldToLocalMatrix;

            var rootRotation = Quaternion.Euler(0, 0, m_TransitionRotation);
            var rootScale = 1f / GetMultiplier(m_TransitionRotation);
            material.SetMatrix(s_RootViewMatrix, Matrix4x4.TRS(pivot, rootRotation, scale * rootScale) * w2LMat);

            var rotation = GetGradationRotation();
            var gradRotation = Quaternion.Euler(0, 0, rotation);
            var gradScale = 1f / GetMultiplier(rotation);
            material.SetMatrix(s_GradViewMatrix, Matrix4x4.TRS(pivot, gradRotation, scale * gradScale) * w2LMat);

            if (m_ShadowMode == ShadowMode.Mirror)
            {
                var mirrorInv = 1f / m_ShadowMirrorScale;
                var mirrorOffset = new Vector3(0, size.y / 2 * (mirrorInv + 1) - m_ShadowDistance.y * mirrorInv, 0);
                var mirrorScale = new Vector3(1, mirrorInv, 1);
                var udScale = new Vector3(scale.x, -scale.y, scale.z);
                var mirrorTranslation = Matrix4x4.TRS(mirrorOffset, Quaternion.identity, mirrorScale) * w2LMat;
                material.SetMatrix(
                    s_MirrorRootViewMatrix,
                    Matrix4x4.TRS(pivot, rootRotation, udScale * rootScale) * mirrorTranslation
                );
                material.SetMatrix(
                    s_MirrorGradViewMatrix,
                    Matrix4x4.TRS(pivot, gradRotation, udScale * gradScale) * mirrorTranslation
                );
            }

            var useIdentity =
                canvas.renderMode == RenderMode.WorldSpace ||
                (canvas.renderMode != RenderMode.ScreenSpaceOverlay && canvas.worldCamera);

            material.SetMatrix(
                s_CanvasToWorldMatrix,
                useIdentity ? Matrix4x4.identity : canvas.transform.localToWorldMatrix
            );
        }

        private Vector4 GetGradationScaleAndOffset()
        {
            var gScale = 1 / m_GradationScale;
            switch (m_GradationMode)
            {
                case GradationMode.HorizontalGradient:
                case GradationMode.VerticalGradient:
                case GradationMode.AngleGradient:
                    return new Vector4(gScale, 1, -0.5f * (gScale + 1) - m_GradationOffset, 0);
                case GradationMode.Radial:
#pragma warning disable CS0612 // Type or member is obsolete
                case GradationMode.RadialDetail:
#pragma warning restore CS0612
                {
                    return new Vector4(gScale, 1, m_GradationOffset, 0);
                }
                default:
                    return new Vector4(gScale, 1, m_GradationOffset * (gScale + 1) / 2 - gScale * 0.5f + 0.5f, 0);
            }
        }

        private float GetGradationRotation()
        {
            switch (m_GradationMode)
            {
                case GradationMode.DiagonalToLeftBottom:
                    return 135;
                case GradationMode.DiagonalToRightBottom:
                    return 45;
                case GradationMode.Vertical:
                    return 90;
                case GradationMode.VerticalGradient:
                    return -90;
                case GradationMode.Angle:
                case GradationMode.AngleGradient:
                    return m_GradationRotation;
                default:
                    return 0;
            }
        }

        private static float GetMultiplier(float deg)
        {
            var rad = Mathf.Deg2Rad * deg;
            var sin = Mathf.Sin(rad);
            var cos = Mathf.Cos(rad);
            return Mathf.Max(Mathf.Abs(cos - sin), Mathf.Abs(cos + sin));
        }

#if UNITY_2021_2_OR_NEWER
        private static void SetKeyword(Material material, Span<string> keywords, int index)
#else
        private static void SetKeyword(Material material, string[] keywords, int index)
#endif
        {
            var length = keywords.Length;
            if (index < length && !string.IsNullOrEmpty(keywords[index]))
            {
                material.EnableKeyword(keywords[index]);
            }

            for (var i = 0; i < length; i++)
            {
                if (i == index) continue;
                material.DisableKeyword(keywords[i]);
            }
        }

        public void ModifyMesh(Graphic graphic, Canvas canvas, RectTransform transitionRoot, VertexHelper vh,
            bool canModifyShape)
        {
            // Apply flip (without effect).
            ApplyFlipWithoutEffect(vh, m_Flip);

            var count = vh.currentIndexCount;
            if (!willModifyVertex || count == 0) return;

            var effectProxy = GraphicProxy.Find(graphic);
            var isText = effectProxy.IsText(graphic);
            effectProxy.OnPreModifyMesh(graphic, canvas);

            var verts = s_WorkingVertices;
            var expandSize = effectProxy.ModifyExpandSize(graphic, GetExpandSize(canModifyShape));

            // Get the rectangle to calculate the normalized position.
            vh.GetUIVertexStream(verts);
            var bundleSize = isText ? 6 : count;

            // Modify vertices for each bundled-quad.
            for (var i = 0; i < count; i += bundleSize)
            {
                // min/max for bundled-quad
                UIVertexUtil.GetBounds(verts, i, bundleSize, out var bounds, out var uvMask);
                UIVertexUtil.Expand(verts, i, bundleSize, expandSize, bounds);
                for (var j = 0; j < bundleSize; j++)
                {
                    var vt = verts[i + j];
                    if (onModifyVertex != null)
                    {
                        vt = onModifyVertex(vt, uvMask);
                    }
                    else
                    {
                        vt.uv1 = new Vector4(uvMask.xMin, uvMask.yMin, uvMask.xMax, uvMask.yMax);
                    }

                    verts[i + j] = vt;
                }
            }

            // Apply flip (with effect).
            ApplyFlipWithEffect(verts, m_Flip);

            // Apply shadow.
            ApplyShadow(verts, transitionRoot, m_Flip);

            vh.Clear();
            vh.AddUIVertexTriangleStream(verts);
        }

        private void ApplyShadow(List<UIVertex> verts, RectTransform transitionRoot, Flip flip)
        {
            var distance = m_ShadowDistance;
            if (distance == Vector2.zero) return;

            if ((flip & Flip.Shadow) != 0)
            {
                distance.x = (flip & Flip.Horizontal) != 0 ? -distance.x : distance.x;
                distance.y = (flip & Flip.Vertical) != 0 ? -distance.y : distance.y;
            }

            switch (m_ShadowMode)
            {
                case ShadowMode.Shadow:
                case ShadowMode.Shadow3:
                case ShadowMode.Outline:
                case ShadowMode.Outline8:
                    ShadowUtil.DoShadow(verts, s_ShadowVectors[(int)m_ShadowMode], distance, m_ShadowIteration,
                        m_ShadowFade);
                    break;
                case ShadowMode.Mirror:
                    ShadowUtil.DoMirror(verts, distance, m_ShadowMirrorScale, m_ShadowFade, transitionRoot);
                    break;
            }
        }

        private static void ApplyFlipWithoutEffect(VertexHelper vh, Flip flip)
        {
            if ((flip & Flip.Effect) != 0) return;

            var flipHorizontal = 0 != (flip & Flip.Horizontal);
            var flipVertical = 0 != (flip & Flip.Vertical);
            if (!flipHorizontal && !flipVertical) return;

            UIVertexUtil.Flip(vh, flipHorizontal, flipVertical);
        }

        private static void ApplyFlipWithEffect(List<UIVertex> verts, Flip flip)
        {
            if ((flip & Flip.Effect) == 0) return;

            var flipHorizontal = 0 != (flip & Flip.Horizontal);
            var flipVertical = 0 != (flip & Flip.Vertical);
            if (!flipHorizontal && !flipVertical) return;

            UIVertexUtil.Flip(verts, flipHorizontal, flipVertical);
        }

        private Vector4 GetExpandSize(bool canModifyShape)
        {
            if (!canModifyShape) return Vector4.zero;

            var expandSize = Vector4.zero;
            switch (m_SamplingFilter)
            {
                case SamplingFilter.BlurFast:
                    expandSize += Vector4.one * 10;
                    break;
                case SamplingFilter.BlurMedium:
                    expandSize += Vector4.one * 15;
                    break;
                case SamplingFilter.BlurDetail:
                    expandSize += Vector4.one * 20;
                    break;
                case SamplingFilter.RgbShift:
                    expandSize.x += 40;
                    expandSize.z += 40;
                    break;
            }

            switch (m_TransitionFilter)
            {
                case TransitionFilter.Melt:
                    expandSize.y += 40;
                    break;
                case TransitionFilter.Burn:
                    expandSize.w += 40;
                    break;
            }

            return expandSize;
        }

        private static Color ApplyColorSpace(Color color)
        {
            return QualitySettings.activeColorSpace == ColorSpace.Linear ? color.linear : color;
        }
    }
}