using UnityEngine;

namespace AibisDream.MiniGame.HuoShan
{
    /// <summary>
    /// 波形渲染器 - 单个波形的渲染
    /// 支持噪波效果和清晰度控制，像录音软件中的声波
    /// </summary>
    [ExecuteInEditMode]
    [RequireComponent(typeof(LineRenderer))]
    public class WaveformRenderer : MonoBehaviour
    {
        public enum PreviewMode
        {
            Clean,          // 清晰波形，无噪波
            WithNoise,      // 显示噪波效果
            Runtime         // 模拟运行时（噪波+清晰度）
        }

        public enum ConfigPreviewType
        {
            None,           // 不使用Config，使用下方的手动设置
            Emotion,        // 预览情绪波形配置
            Logic,          // 预览逻辑波形配置
            Joke,           // 预览笑话波形配置
            FilterOutput,   // 预览滤波器输出配置
            NormalOutput    // 预览正常输出配置
        }

        [Header("═══ 从Config预览（拖入Config后选择类型即可预览）═══")]
        [Tooltip("拖入WaveformConfig资源")]
        [SerializeField] private WaveformConfig previewConfig;
        [Tooltip("选择要预览的波形类型（选择后立即生效）")]
        [SerializeField] private ConfigPreviewType previewFromConfig = ConfigPreviewType.None;
        
        [Header("═══ 预览效果 ═══")]
        [SerializeField] private PreviewMode editorPreviewMode = PreviewMode.Clean;
        [Tooltip("勾选强制刷新波形显示")]
        [SerializeField] private bool forceRefresh = false;

        [Header("═══ 波形设置（手动调整或从Config应用）═══")]
        [SerializeField] private WaveformType waveType = WaveformType.Emotion;
        [SerializeField] private float waveHeight = 1f;
        [SerializeField] private float waveWidth = 10f;
        [SerializeField] private float waveSpeed = 2f;
        [SerializeField] private float frequency = 1f;

        [Header("噪波设置")]
        [SerializeField] private float noiseAmount = 0.8f;       // 噪波强度 (0=无噪波, 1=完全噪波)
        [SerializeField] private float noiseFrequency = 15f;     // 噪波频率
        [SerializeField] private float noiseSpeed = 5f;          // 噪波变化速度

        [Header("清晰度设置")]
        [SerializeField] private float clarity = 0f;             // 清晰度 (0=模糊, 1=完全清晰)
        [SerializeField] private float clarityPosition = 0.5f;   // 清晰位置 (0-1)
        [SerializeField] private float clarityWidth = 0.1f;      // 清晰区域宽度

        [Header("绘图设置")]
        [SerializeField] private int resolution = 200;
        [SerializeField] private float lineWidth = 0.05f;

        [Header("颜色设置")]
        [SerializeField] private Color primaryColor = Color.cyan;
        [SerializeField] private Color secondaryColor = Color.blue;
        [SerializeField] private Color noiseColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
        [Tooltip("清晰区域使用主色调的高亮版本")]
        [SerializeField] private bool useBrightenedClearColor = true;
        [SerializeField] private float clearColorBrighten = 0.3f;

        [Header("发光点")]
        [SerializeField] private bool showGlowPoint = true;
        [SerializeField] private SpriteRenderer glowPointRenderer;
        [SerializeField] private float glowSize = 0.15f;

        [Header("扫描线设置")]
        [SerializeField] private Color scanLineColor = new Color(0.2f, 0.9f, 1f, 1f);
        [SerializeField] private float scanLineWidthMultiplier = 0.8f;  // 相对于波形线宽的倍数（更细）
        [SerializeField] private Color limitLineColor = new Color(1f, 0.8f, 0.2f, 1f);
        [SerializeField] private float limitLineWidthMultiplier = 0.6f;  // 相对于波形线宽的倍数（更细）
        [SerializeField] private string scanLineSortingLayer = "Tools";
        [SerializeField] private int scanLineSortingOrderOffset = 1;  // 在Tools层级上+1

        [Header("复古示波器质感（可选）")]
        [Tooltip("开启后会添加轻微的CRT抖动/亮度呼吸，让观感更像老式示波器/仪表屏")]
        [SerializeField] private bool enableOscilloscopeArtifacts = true;
        [Tooltip("亮度/透明度轻微闪烁强度（0-0.2建议）")]
        [Range(0f, 0.2f)]
        [SerializeField] private float crtFlickerAmount = 0.04f;
        [Tooltip("垂直微抖动强度（以波形高度为基准的比例）")]
        [Range(0f, 0.05f)]
        [SerializeField] private float crtVerticalJitter = 0.008f;
        [Tooltip("50/60Hz嗡鸣感（用于模拟电源纹波）")]
        [Range(10f, 90f)]
        [SerializeField] private float crtHumHz = 50f;

        private LineRenderer _lineRenderer;
        private LineRenderer _scanLineRenderer;
        private LineRenderer _upperLimitLineRenderer;
        private LineRenderer _lowerLimitLineRenderer;
        private Vector3[] _points;
        private float _phaseOffset = 0f;
        private float _noisePhase = 0f;
        private float _transformProgress = 0f;
        private WaveformType _transformFromType;
        private WaveformType _transformToType;
        private bool _isTransforming = false;
        private float _currentAlpha = 1f;
        private float _crtAlphaMul = 1f;
        
        // 变换效果参数
        private float _transformDistortion = 0f;  // 变换时的扭曲程度
        private float _transformCompression = 1f; // 变换时的压缩程度

        // 随机噪波种子
        private float[] _noiseSeed;

        // 合成模式参数
        private float _logicWeight = 0.3f;
        private float _jokeWeight = 0.85f;
        private float _synthesisProgress = 1f;

        // 情绪波形谐波参数（可通过配置调整）
        private float _harmonicA1 = 0.55f;      // 基波振幅
        private float _harmonicA2 = 0.28f;      // 二次谐波振幅
        private float _harmonicA3 = 0.12f;      // 三次谐波振幅
        private float _harmonicPhase2 = 0.3f;   // 二次谐波相位
        private float _harmonicPhase3 = 0.5f;   // 三次谐波相位
        private float _verticalOffset = -0.08f; // 整体偏移

        public WaveformType WaveType => waveType;
        public bool IsTransforming => _isTransforming;
        public float Clarity => clarity;
        public float ClarityPosition => clarityPosition;
        public float ClarityWidth => clarityWidth;
        public float NoiseAmount => noiseAmount;
        public Color PrimaryColor => primaryColor;
        public Color SecondaryColor => secondaryColor;
        public float CurrentAlpha => _currentAlpha;

        private void Awake()
        {
            InitializeLineRenderer();
            SetupGlowPoint();
            InitializeNoise();
            InitializeScanLines();
        }

        /// <summary>
        /// 响应 Inspector 中的值变化
        /// </summary>
        private void OnValidate()
        {
            // 确保在编辑器中能即时预览
            if (_lineRenderer == null)
            {
                _lineRenderer = GetComponent<LineRenderer>();
            }
            
            if (_lineRenderer != null)
            {
                _lineRenderer.startWidth = lineWidth;
                _lineRenderer.endWidth = lineWidth;
                
                if (_points == null || _points.Length != resolution)
                {
                    _points = new Vector3[resolution];
                    _lineRenderer.positionCount = resolution;
                }
                
                UpdateColors();
            }
            
            // 检查Config预览设置
            if (previewFromConfig != ConfigPreviewType.None && previewConfig == null)
            {
                Debug.LogWarning("WaveformRenderer: 请先拖入 WaveformConfig 资源到 Preview Config 字段！");
            }
            
            // 强制刷新按钮
            if (forceRefresh)
            {
                forceRefresh = false;
                InitializeNoise();
                
                // 显示实际使用的参数
                if (previewFromConfig != ConfigPreviewType.None && previewConfig != null)
                {
                    var settings = GetPreviewSettings();
                    if (settings != null)
                    {
                        Debug.Log($"WaveformRenderer: 预览Config [{previewFromConfig}] - 类型:{settings.waveType}, 高度:{settings.waveHeight}, 速度:{settings.waveSpeed}, 频率:{settings.frequency}");
                    }
                }
                else
                {
                    Debug.Log($"WaveformRenderer: 使用本地参数 - 类型:{waveType}, 高度:{waveHeight}, 速度:{waveSpeed}, 频率:{frequency}");
                }
            }
            
            if (_noiseSeed == null || _noiseSeed.Length != resolution)
            {
                InitializeNoise();
            }
            
            // 在编辑器中立即更新波形
            if (!Application.isPlaying)
            {
                UpdateWaveform();
            }
        }
        

        private void InitializeLineRenderer()
        {
            _lineRenderer = GetComponent<LineRenderer>();
            if (_lineRenderer == null) return;
            
            _lineRenderer.useWorldSpace = false;
            _lineRenderer.positionCount = resolution;
            _lineRenderer.startWidth = lineWidth;
            _lineRenderer.endWidth = lineWidth;
            
            _points = new Vector3[resolution];
            
            UpdateColors();
        }

        private void InitializeNoise()
        {
            _noiseSeed = new float[resolution];
            for (int i = 0; i < resolution; i++)
            {
                _noiseSeed[i] = Random.Range(0f, 100f);
            }
        }

        private void SetupGlowPoint()
        {
            if (!showGlowPoint) return;

            if (glowPointRenderer == null)
            {
                GameObject glowObj = new GameObject("GlowPoint");
                glowObj.transform.SetParent(transform);
                glowObj.transform.localPosition = Vector3.zero;
                glowPointRenderer = glowObj.AddComponent<SpriteRenderer>();

                Texture2D texture = new Texture2D(32, 32);
                Color[] colors = new Color[32 * 32];
                for (int i = 0; i < colors.Length; i++)
                {
                    float x = (i % 32) / 31f;
                    float y = (i / 32) / 31f;
                    float distance = Vector2.Distance(new Vector2(x, y), new Vector2(0.5f, 0.5f));
                    colors[i] = new Color(1, 1, 1, Mathf.Clamp01(1 - distance * 2));
                }
                texture.SetPixels(colors);
                texture.Apply();

                Sprite sprite = Sprite.Create(texture, new Rect(0, 0, 32, 32), new Vector2(0.5f, 0.5f));
                glowPointRenderer.sprite = sprite;
            }

            glowPointRenderer.color = primaryColor;
            glowPointRenderer.transform.localScale = Vector3.one * glowSize;
        }

        private void Update()
        {
            if (_lineRenderer == null) InitializeLineRenderer();
            if (_points == null) _points = new Vector3[resolution];
            if (_noiseSeed == null) InitializeNoise();
            
            // 获取实际波形速度（优先使用Config预览）
            float actualWaveSpeed = waveSpeed;
            bool isEditor = !Application.isPlaying;
            if (isEditor && previewFromConfig != ConfigPreviewType.None && previewConfig != null)
            {
                WaveformSettings settings = GetPreviewSettings();
                if (settings != null)
                {
                    actualWaveSpeed = settings.waveSpeed;
                }
            }
            
            _phaseOffset += Time.deltaTime * actualWaveSpeed;
            _noisePhase += Time.deltaTime * noiseSpeed;

            // 轻微“电源纹波/亮度呼吸”，用于提升拟真仪表屏质感
            if (enableOscilloscopeArtifacts && Application.isPlaying)
            {
                // 使用低成本噪声 + 50Hz正弦混合，避免过于规律
                float t = Time.time;
                float hum = Mathf.Sin(t * Mathf.PI * 2f * crtHumHz) * 0.5f + 0.5f; // 0..1
                float rand = Mathf.PerlinNoise(t * 4.2f, 0.13f);                  // 0..1
                float mix = Mathf.Lerp(hum, rand, 0.6f);                          // 0..1
                _crtAlphaMul = Mathf.Clamp(1f - crtFlickerAmount + mix * crtFlickerAmount * 2f, 0.7f, 1.15f);
            }
            else
            {
                _crtAlphaMul = 1f;
            }

            UpdateWaveform();
        }

        private void UpdateWaveform()
        {
            if (_lineRenderer == null || _points == null) return;
            
            // 确定当前使用的预览模式
            bool isEditor = !Application.isPlaying;
            PreviewMode currentMode = isEditor ? editorPreviewMode : PreviewMode.Runtime;
            
            // 获取实际使用的参数（优先使用Config预览）
            WaveformType actualWaveType = waveType;
            float actualFrequency = frequency;
            float actualWaveHeight = waveHeight;
            float actualWaveSpeed = waveSpeed;
            
            if (isEditor && previewFromConfig != ConfigPreviewType.None && previewConfig != null)
            {
                WaveformSettings settings = GetPreviewSettings();
                if (settings != null)
                {
                    actualWaveType = settings.waveType;
                    actualFrequency = settings.frequency;
                    actualWaveHeight = settings.waveHeight;
                    actualWaveSpeed = settings.waveSpeed;
                }
            }
            
            for (int i = 0; i < resolution; i++)
            {
                float x = ((float)i / resolution) * waveWidth - waveWidth * 0.5f;
                float normalizedX = (float)i / resolution;
                float timeOffset = normalizedX * actualFrequency + _phaseOffset;

                // 获取基础波形值
                float baseWaveValue;
                if (_isTransforming)
                {
                    baseWaveValue = GetTransformingWaveValue(timeOffset, normalizedX);
                }
                else
                {
                    baseWaveValue = GetWaveValue(actualWaveType, timeOffset, normalizedX);
                }

                float finalValue;
                switch (currentMode)
                {
                    case PreviewMode.Clean:
                        // 清晰模式：直接显示波形
                        finalValue = baseWaveValue;
                        break;
                    
                    case PreviewMode.WithNoise:
                        // 噪波模式：只显示噪波效果，不考虑清晰度
                        float noise = GenerateNoise(i, normalizedX);
                        finalValue = Mathf.Lerp(noise, baseWaveValue, 1f - noiseAmount);
                        break;
                    
                    case PreviewMode.Runtime:
                    default:
                        // 运行时模式：应用噪波和清晰度
                        float localClarity = CalculateLocalClarity(normalizedX);
                        float runtimeNoise = GenerateNoise(i, normalizedX);
                        finalValue = Mathf.Lerp(runtimeNoise, baseWaveValue, localClarity);
                        break;
                }

                // 复古示波器：给“非清晰区域”加一点点垂直抖动（更像硬件采样/显示抖动）
                if (enableOscilloscopeArtifacts && Application.isPlaying && currentMode == PreviewMode.Runtime)
                {
                    float localClarity = CalculateLocalClarity(normalizedX);
                    float jitterMask = Mathf.Clamp01(1f - localClarity);
                    float n = (Mathf.PerlinNoise(_noisePhase * 1.7f, normalizedX * 8.0f) - 0.5f) * 2f; // -1..1
                    float hum = Mathf.Sin((Time.time * crtHumHz + normalizedX * 3.5f) * Mathf.PI * 2f);  // -1..1
                    float jitter = (n * 0.7f + hum * 0.3f) * crtVerticalJitter * jitterMask;
                    finalValue += jitter;
                }

                _points[i] = new Vector3(x, finalValue * actualWaveHeight, 0f);
            }

            _lineRenderer.SetPositions(_points);
            UpdateLineColors();

            if (showGlowPoint && glowPointRenderer != null && resolution > 0)
            {
                glowPointRenderer.transform.localPosition = _points[resolution - 1];
            }
        }
        
        /// <summary>
        /// 获取当前预览的Config设置
        /// </summary>
        private WaveformSettings GetPreviewSettings()
        {
            if (previewConfig == null) return null;
            
            switch (previewFromConfig)
            {
                case ConfigPreviewType.Emotion:
                    return previewConfig.emotionWaveform;
                case ConfigPreviewType.Logic:
                    return previewConfig.logicWaveform;
                case ConfigPreviewType.Joke:
                    return previewConfig.jokeWaveform;
                case ConfigPreviewType.FilterOutput:
                    return previewConfig.filterOutputWaveform;
                case ConfigPreviewType.NormalOutput:
                    return previewConfig.normalOutputWaveform;
                default:
                    return null;
            }
        }

        /// <summary>
        /// 计算指定位置的局部清晰度
        /// </summary>
        private float CalculateLocalClarity(float normalizedX)
        {
            // 基础清晰度
            float baseClarity = clarity;
            
            // 如果清晰度大于0，在清晰位置附近更清晰
            if (clarity > 0)
            {
                float distanceFromClear = Mathf.Abs(normalizedX - clarityPosition);
                float clearZone = 1f - Mathf.Clamp01(distanceFromClear / clarityWidth);
                baseClarity = Mathf.Max(clarity, clearZone);
            }
            
            return Mathf.Clamp01(baseClarity);
        }

        /// <summary>
        /// 生成噪波（像录音软件中的声波）
        /// </summary>
        private float GenerateNoise(int index, float normalizedX)
        {
            float seed = _noiseSeed[index];
            
            // 多层噪波叠加，产生声波效果
            float noise = 0f;
            
            // 低频噪波 - 整体起伏
            noise += Mathf.PerlinNoise(seed + _noisePhase * 0.3f, normalizedX * 2f) * 0.6f;
            
            // 中频噪波 - 细节
            noise += Mathf.PerlinNoise(seed * 2f + _noisePhase * 0.7f, normalizedX * 5f) * 0.3f;
            
            // 高频噪波 - 毛刺
            noise += (Mathf.PerlinNoise(seed * 3f + _noisePhase, normalizedX * noiseFrequency) - 0.5f) * 0.4f;
            
            // 随机尖峰（像声波的峰值）
            float spike = Mathf.Sin((normalizedX + _noisePhase * 0.1f) * Mathf.PI * 20f);
            spike = Mathf.Pow(Mathf.Abs(spike), 3f) * Mathf.Sign(spike);
            noise += spike * 0.2f;
            
            // 归一化到 -1 到 1
            noise = (noise - 0.5f) * 2f * noiseAmount;
            
            return Mathf.Clamp(noise, -1f, 1f);
        }

        /// <summary>
        /// 更新线条颜色（清晰区域显示高亮的主色调）
        /// </summary>
        private void UpdateLineColors()
        {
            if (_lineRenderer == null) return;

            Gradient gradient = new Gradient();
            float effectiveAlpha = Mathf.Clamp01(_currentAlpha * _crtAlphaMul);
            
            if (clarity > 0.5f)
            {
                // 有清晰区域时，显示清晰位置的颜色变化
                float clearStart = Mathf.Clamp01(clarityPosition - clarityWidth);
                float clearEnd = Mathf.Clamp01(clarityPosition + clarityWidth);
                
                // 使用高亮的主色调作为清晰区域颜色（不再使用绿色）
                Color brightenedColor = GetBrightenedClearColor();
                
                gradient.SetKeys(
                    new GradientColorKey[] {
                        new GradientColorKey(primaryColor, 0f),
                        new GradientColorKey(primaryColor, clearStart),
                        new GradientColorKey(brightenedColor, clarityPosition),
                        new GradientColorKey(primaryColor, clearEnd),
                        new GradientColorKey(secondaryColor, 1f)
                    },
                    new GradientAlphaKey[] {
                        new GradientAlphaKey(effectiveAlpha, 0f),
                        new GradientAlphaKey(effectiveAlpha, 1f)
                    }
                );
            }
            else
            {
                gradient.SetKeys(
                    new GradientColorKey[] {
                        new GradientColorKey(primaryColor, 0f),
                        new GradientColorKey(secondaryColor, 1f)
                    },
                    new GradientAlphaKey[] {
                        new GradientAlphaKey(effectiveAlpha, 0f),
                        new GradientAlphaKey(effectiveAlpha, 1f)
                    }
                );
            }
            
            _lineRenderer.colorGradient = gradient;
        }
        
        /// <summary>
        /// 获取高亮的清晰区域颜色（基于主色调）
        /// </summary>
        private Color GetBrightenedClearColor()
        {
            if (!useBrightenedClearColor)
            {
                return primaryColor;
            }
            
            // 将主色调提亮
            Color.RGBToHSV(primaryColor, out float h, out float s, out float v);
            v = Mathf.Clamp01(v + clearColorBrighten);
            s = Mathf.Clamp01(s * 0.8f); // 稍微降低饱和度使其更亮
            Color brightened = Color.HSVToRGB(h, s, v);
            brightened.a = primaryColor.a;
            return brightened;
        }

        private float GetWaveValue(WaveformType type, float time, float normalizedX)
        {
            switch (type)
            {
                case WaveformType.Emotion:
                    return GenerateEmotionWave(time, normalizedX);
                case WaveformType.Logic:
                    return GenerateLogicWave(time);
                case WaveformType.Joke:
                    return GenerateJokeWave(time, normalizedX);
                case WaveformType.FilterOutput:
                    return GenerateFilterOutput(time, normalizedX);
                case WaveformType.NormalOutput:
                    return GenerateNormalOutput(time, normalizedX);
                default:
                    return Mathf.Sin(time * Mathf.PI * 2f);
            }
        }

        #region 波形生成

        /// <summary>
        /// 情绪波形 - 基于谐波叠加的简洁实现
        /// 采用傅里叶合成：基波 + 二次谐波 + 三次谐波
        /// 特征：低频、缓慢、通过谐波叠加表达悲伤/压抑情绪
        /// 谐波参数可通过 WaveformSettings 配置
        /// </summary>
        private float GenerateEmotionWave(float time, float normalizedX)
        {
            // 慢速时间，体现低沉感
            float slowTime = time * 0.4f;
            float t = slowTime * Mathf.PI * 2f;  // 基频角度

            // 傅里叶合成：基波 + 二次谐波 + 三次谐波（使用可配置参数）
            float fundamental = Mathf.Sin(t) * _harmonicA1;                           // 基波
            float harmonic2 = Mathf.Sin(2f * t + _harmonicPhase2) * _harmonicA2;      // 二次谐波
            float harmonic3 = Mathf.Sin(3f * t + _harmonicPhase3) * _harmonicA3;      // 三次谐波

            // 叠加得到最终波形
            float result = fundamental + harmonic2 + harmonic3;
            
            // 整体偏移（负值表示下沉，体现压抑感）
            result += _verticalOffset;

            return Mathf.Clamp(result, -1f, 1f);
        }

        /// <summary>
        /// 逻辑波形 - 清晰的方波
        /// </summary>
        private float GenerateLogicWave(float time)
        {
            float t = time % 1f;
            if (t < 0) t += 1f;

            float amplitude = 0.7f;
            float squareWave = t < 0.5f ? amplitude : -amplitude;
            
            // 非常短的边缘过渡
            float edgeSmooth = 0.015f;
            if (t < edgeSmooth)
            {
                squareWave = Mathf.Lerp(-amplitude, amplitude, t / edgeSmooth);
            }
            else if (t > 0.5f - edgeSmooth && t < 0.5f + edgeSmooth)
            {
                float localT = (t - (0.5f - edgeSmooth)) / (edgeSmooth * 2f);
                squareWave = Mathf.Lerp(amplitude, -amplitude, localT);
            }
            else if (t > 1f - edgeSmooth)
            {
                squareWave = Mathf.Lerp(-amplitude, amplitude, (t - (1f - edgeSmooth)) / edgeSmooth);
            }

            return squareWave;
        }

        /// <summary>
        /// 笑话波形 - 高频、尖锐、跳动
        /// 特征：快速的脉冲、突然的尖峰、亢奋的跳动
        /// </summary>
        private float GenerateJokeWave(float time, float normalizedX)
        {
            // 使用更快的时间，让波形看起来更尖锐跳动
            float fastTime = time * 2.5f;  // 快2.5倍
            float t = fastTime % 1f;
            if (t < 0) t += 1f;

            // 快速三角脉冲（尖锐的笑声节奏）
            float pulsePhase = (t * 4f) % 1f;  // 每周期4个脉冲
            float pulse = 0f;
            if (pulsePhase < 0.1f)
            {
                // 非常快速的上升
                pulse = pulsePhase / 0.1f;
            }
            else if (pulsePhase < 0.2f)
            {
                // 快速下降
                pulse = 1f - (pulsePhase - 0.1f) / 0.1f;
            }
            pulse *= 0.9f;
            
            // 高频振荡（尖锐感）
            float highFreq = Mathf.Sin(t * Mathf.PI * 12f) * 0.35f;
            
            // 随机尖峰（突然的"笑点"爆发）
            float spike = 0f;
            float spikeT = (t * 7f) % 1f;
            if (spikeT < 0.08f)
            {
                spike = Mathf.Sin(spikeT / 0.08f * Mathf.PI) * 0.5f;
            }
            
            // 额外的高频颤动（亢奋感）
            float tremor = Mathf.Sin(t * Mathf.PI * 25f + normalizedX * 5f) * 0.12f;
            
            float result = pulse + highFreq + spike + tremor;

            return Mathf.Clamp(result, -1f, 1f);
        }

        private float GenerateFilterOutput(float time, float normalizedX)
        {
            float logic = GenerateLogicWave(time);
            float joke = GenerateJokeWave(time, normalizedX);
            
            float effectiveLogicWeight = _logicWeight;
            float effectiveJokeWeight = _jokeWeight * _synthesisProgress;
            
            float result = logic * effectiveLogicWeight + joke * effectiveJokeWeight;

            return Mathf.Clamp(result, -1f, 1f);
        }

        private float GenerateNormalOutput(float time, float normalizedX)
        {
            float logic = GenerateLogicWave(time) * 0.4f;
            float emotion = GenerateEmotionWave(time, normalizedX) * 0.4f;
            float result = logic + emotion;
            result += Mathf.Sin(time * Mathf.PI * 3f) * 0.1f;

            return Mathf.Clamp(result, -1f, 1f);
        }

        #endregion

        #region 公共方法

        /// <summary>
        /// 设置清晰度（0=完全噪波, 1=完全清晰）
        /// </summary>
        public void SetClarity(float value)
        {
            clarity = Mathf.Clamp01(value);
        }

        /// <summary>
        /// 设置清晰位置（进度条位置，0-1）
        /// </summary>
        public void SetClarityPosition(float position)
        {
            clarityPosition = Mathf.Clamp01(position);
        }

        /// <summary>
        /// 设置清晰区域宽度
        /// </summary>
        public void SetClarityWidth(float width)
        {
            clarityWidth = Mathf.Clamp(width, 0.01f, 0.5f);
        }

        /// <summary>
        /// 设置噪波强度
        /// </summary>
        public void SetNoiseAmount(float amount)
        {
            noiseAmount = Mathf.Clamp01(amount);
        }

        /// <summary>
        /// 检查当前位置是否清晰（用于锁定检测）
        /// </summary>
        public bool IsPositionClear(float position, float threshold = 0.8f)
        {
            float localClarity = CalculateLocalClarity(position);
            return localClarity >= threshold;
        }

        public void ApplySettings(WaveformSettings settings)
        {
            waveType = settings.waveType;
            waveHeight = settings.waveHeight;
            waveSpeed = settings.waveSpeed;
            frequency = settings.frequency;
            primaryColor = settings.primaryColor;
            secondaryColor = settings.secondaryColor;
            
            // 应用谐波配置（用于情绪波形的傅里叶合成）
            _harmonicA1 = settings.harmonicA1;
            _harmonicA2 = settings.harmonicA2;
            _harmonicA3 = settings.harmonicA3;
            _harmonicPhase2 = settings.harmonicPhase2;
            _harmonicPhase3 = settings.harmonicPhase3;
            _verticalOffset = settings.verticalOffset;
            
            UpdateColors();
        }

        public void SetWaveType(WaveformType type)
        {
            waveType = type;
            _isTransforming = false;
        }

        public void SetColors(Color primary, Color secondary)
        {
            primaryColor = primary;
            secondaryColor = secondary;
            UpdateColors();
        }

        public void StartTransform(WaveformType fromType, WaveformType toType)
        {
            _transformFromType = fromType;
            _transformToType = toType;
            _transformProgress = 0f;
            _transformDistortion = 0f;
            _transformCompression = 1f;
            _isTransforming = true;
        }

        public void UpdateTransformProgress(float progress)
        {
            _transformProgress = Mathf.Clamp01(progress);
            
            // 计算变换过程中的效果参数
            // 0-0.3: 开始扭曲，波形开始不稳定
            // 0.3-0.7: 最大扭曲+压缩，波形被"挤压"
            // 0.7-1.0: 扭曲消退，新波形稳定
            if (_transformProgress < 0.3f)
            {
                float t = _transformProgress / 0.3f;
                _transformDistortion = Mathf.Sin(t * Mathf.PI) * 0.5f;
                _transformCompression = 1f;
            }
            else if (_transformProgress < 0.7f)
            {
                float t = (_transformProgress - 0.3f) / 0.4f;
                _transformDistortion = 0.5f + Mathf.Sin(t * Mathf.PI * 3f) * 0.3f;
                // 压缩效果：低频被压缩成高频的感觉
                _transformCompression = Mathf.Lerp(1f, 2.5f, t);
            }
            else
            {
                float t = (_transformProgress - 0.7f) / 0.3f;
                _transformDistortion = Mathf.Lerp(0.5f, 0f, t);
                _transformCompression = Mathf.Lerp(2.5f, 1f, t);
            }
            
            if (_transformProgress >= 1f)
            {
                waveType = _transformToType;
                _isTransforming = false;
                _transformDistortion = 0f;
                _transformCompression = 1f;
            }
        }

        public void FinishTransform()
        {
            waveType = _transformToType;
            _transformProgress = 1f;
            _isTransforming = false;
            _transformDistortion = 0f;
            _transformCompression = 1f;
        }
        
        /// <summary>
        /// 获取变换过程中的波形值（带有戏剧性的过渡效果）
        /// </summary>
        private float GetTransformingWaveValue(float timeOffset, float normalizedX)
        {
            float fromValue = GetWaveValue(_transformFromType, timeOffset, normalizedX);
            float toValue = GetWaveValue(_transformToType, timeOffset * _transformCompression, normalizedX);
            
            // 基础混合
            float blendedValue = Mathf.Lerp(fromValue, toValue, _transformProgress);
            
            // 添加扭曲效果（波形被挤压、扭曲的感觉）
            if (_transformDistortion > 0)
            {
                // 添加不规则的高频扰动
                float distortion = Mathf.Sin(timeOffset * 15f + normalizedX * 10f) * _transformDistortion;
                distortion += Mathf.Sin(timeOffset * 23f) * _transformDistortion * 0.5f;
                
                // 压缩效果：让波形看起来像是被挤压
                float compressionEffect = Mathf.Sin(normalizedX * Mathf.PI * _transformCompression * 2f) * _transformDistortion * 0.3f;
                
                blendedValue += distortion + compressionEffect;
            }
            
            return Mathf.Clamp(blendedValue, -1.2f, 1.2f); // 允许稍微超出范围增加戏剧感
        }

        public void SetSynthesisWeights(float logicWeight, float jokeWeight)
        {
            _logicWeight = Mathf.Clamp01(logicWeight);
            _jokeWeight = Mathf.Clamp01(jokeWeight);
        }

        public void SetSynthesisProgress(float progress)
        {
            _synthesisProgress = Mathf.Clamp01(progress);
        }

        public void SetVisible(bool visible)
        {
            if (_lineRenderer != null)
                _lineRenderer.enabled = visible;
            if (glowPointRenderer != null)
                glowPointRenderer.enabled = visible;
        }

        public void SetAlpha(float alpha)
        {
            _currentAlpha = Mathf.Clamp01(alpha);
            if (_lineRenderer == null) return;
            
            Color startColor = primaryColor;
            Color endColor = secondaryColor;
            startColor.a = _currentAlpha;
            endColor.a = _currentAlpha;

            Gradient gradient = new Gradient();
            gradient.SetKeys(
                new GradientColorKey[] { new GradientColorKey(startColor, 0f), new GradientColorKey(endColor, 1f) },
                new GradientAlphaKey[] { new GradientAlphaKey(_currentAlpha, 0f), new GradientAlphaKey(_currentAlpha, 1f) }
            );
            _lineRenderer.colorGradient = gradient;

            if (glowPointRenderer != null)
            {
                Color glowColor = primaryColor;
                glowColor.a = _currentAlpha;
                glowPointRenderer.color = glowColor;
            }
        }

        private void UpdateColors()
        {
            if (_lineRenderer == null) return;

            // 获取实际颜色（优先使用Config预览）
            Color actualPrimaryColor = primaryColor;
            Color actualSecondaryColor = secondaryColor;
            
            bool isEditor = !Application.isPlaying;
            if (isEditor && previewFromConfig != ConfigPreviewType.None && previewConfig != null)
            {
                WaveformSettings settings = GetPreviewSettings();
                if (settings != null)
                {
                    actualPrimaryColor = settings.primaryColor;
                    actualSecondaryColor = settings.secondaryColor;
                }
            }

            Gradient gradient = new Gradient();
            gradient.SetKeys(
                new GradientColorKey[] { new GradientColorKey(actualPrimaryColor, 0f), new GradientColorKey(actualSecondaryColor, 1f) },
                new GradientAlphaKey[] { new GradientAlphaKey(_currentAlpha, 0f), new GradientAlphaKey(_currentAlpha, 1f) }
            );
            _lineRenderer.colorGradient = gradient;

            if (glowPointRenderer != null)
            {
                glowPointRenderer.color = actualPrimaryColor;
            }
        }

        #endregion

        #region 扫描线系统

        /// <summary>
        /// 初始化扫描线
        /// </summary>
        private void InitializeScanLines()
        {
            // 确保主LineRenderer已初始化
            if (_lineRenderer == null)
            {
                _lineRenderer = GetComponent<LineRenderer>();
            }
            
            // 计算扫描线宽度（相对于波形线宽，更细一点）
            float scanWidth = lineWidth * scanLineWidthMultiplier;
            float limitWidth = lineWidth * limitLineWidthMultiplier;
            
            // 创建垂直扫描线（用于屏蔽词检测）
            _scanLineRenderer = CreateScanLineRenderer("ScanLine", scanLineColor, scanWidth);
            if (_scanLineRenderer != null) _scanLineRenderer.gameObject.SetActive(false);

            // 创建上限线（用于限幅检测）
            _upperLimitLineRenderer = CreateScanLineRenderer("UpperLimitLine", limitLineColor, limitWidth);
            if (_upperLimitLineRenderer != null) _upperLimitLineRenderer.gameObject.SetActive(false);

            // 创建下限线（用于限幅检测）
            _lowerLimitLineRenderer = CreateScanLineRenderer("LowerLimitLine", limitLineColor, limitWidth);
            if (_lowerLimitLineRenderer != null) _lowerLimitLineRenderer.gameObject.SetActive(false);
            
            Debug.Log($"WaveformRenderer: 扫描线初始化完成 - ScanLine:{_scanLineRenderer != null}, UpperLimit:{_upperLimitLineRenderer != null}, LowerLimit:{_lowerLimitLineRenderer != null}, ScanWidth:{scanWidth:F4}, LimitWidth:{limitWidth:F4}");
        }

        private LineRenderer CreateScanLineRenderer(string name, Color color, float width)
        {
            GameObject lineObj = new GameObject(name);
            lineObj.transform.SetParent(transform);
            lineObj.transform.localPosition = Vector3.zero;
            lineObj.transform.localScale = Vector3.one;

            LineRenderer lr = lineObj.AddComponent<LineRenderer>();
            
            // 使用主LineRenderer的材质，或者创建一个简单的材质
            if (_lineRenderer != null && _lineRenderer.material != null)
            {
                lr.material = new Material(_lineRenderer.material);
            }
            else
            {
                // 回退方案：使用内置的UI shader
                Shader shader = Shader.Find("UI/Default");
                if (shader == null) shader = Shader.Find("Sprites/Default");
                if (shader == null) shader = Shader.Find("Unlit/Color");
                lr.material = new Material(shader);
            }
            
            lr.startColor = color;
            lr.endColor = color;
            lr.startWidth = width;
            lr.endWidth = width;
            lr.positionCount = 2;
            lr.useWorldSpace = false;
            
            // 设置层级：Tools层 + offset
            lr.sortingLayerName = scanLineSortingLayer;
            lr.sortingOrder = scanLineSortingOrderOffset;

            return lr;
        }

        /// <summary>
        /// 显示垂直扫描线在指定位置
        /// </summary>
        public void ShowScanLine(float normalizedX, float height = -1f)
        {
            if (_scanLineRenderer == null)
            {
                Debug.LogWarning("WaveformRenderer: 扫描线未初始化！尝试重新初始化...");
                InitializeScanLines();
                if (_scanLineRenderer == null) return;
            }

            float actualHeight = height > 0 ? height : waveHeight * 1.5f;
            float xPos = (normalizedX - 0.5f) * waveWidth;

            _scanLineRenderer.SetPosition(0, new Vector3(xPos, -actualHeight, 0));
            _scanLineRenderer.SetPosition(1, new Vector3(xPos, actualHeight, 0));
            _scanLineRenderer.gameObject.SetActive(true);
            
            Debug.Log($"WaveformRenderer: 显示扫描线 - X:{xPos:F2}, Height:{actualHeight:F2}, WaveWidth:{waveWidth}, WaveHeight:{waveHeight}");
        }

        /// <summary>
        /// 隐藏垂直扫描线
        /// </summary>
        public void HideScanLine()
        {
            if (_scanLineRenderer != null)
            {
                _scanLineRenderer.gameObject.SetActive(false);
            }
        }

        /// <summary>
        /// 设置扫描线位置（用于动画）
        /// </summary>
        public void SetScanLinePosition(float normalizedX)
        {
            if (_scanLineRenderer == null || !_scanLineRenderer.gameObject.activeSelf) return;

            float xPos = (normalizedX - 0.5f) * waveWidth;
            Vector3 pos0 = _scanLineRenderer.GetPosition(0);
            Vector3 pos1 = _scanLineRenderer.GetPosition(1);
            _scanLineRenderer.SetPosition(0, new Vector3(xPos, pos0.y, 0));
            _scanLineRenderer.SetPosition(1, new Vector3(xPos, pos1.y, 0));
        }

        /// <summary>
        /// 显示限幅线（上下限）
        /// </summary>
        public void ShowLimitLines(float upperLimit = -1f, float lowerLimit = -1f)
        {
            if (_upperLimitLineRenderer == null || _lowerLimitLineRenderer == null)
            {
                Debug.LogWarning("WaveformRenderer: 限幅线未初始化！尝试重新初始化...");
                InitializeScanLines();
                if (_upperLimitLineRenderer == null || _lowerLimitLineRenderer == null) return;
            }

            float actualUpper = upperLimit > 0 ? upperLimit : waveHeight * 0.8f;
            float actualLower = lowerLimit > 0 ? lowerLimit : -waveHeight * 0.8f;
            float halfWidth = waveWidth * 0.5f;

            // 上限线
            _upperLimitLineRenderer.SetPosition(0, new Vector3(-halfWidth, actualUpper, 0));
            _upperLimitLineRenderer.SetPosition(1, new Vector3(halfWidth, actualUpper, 0));
            _upperLimitLineRenderer.gameObject.SetActive(true);

            // 下限线
            _lowerLimitLineRenderer.SetPosition(0, new Vector3(-halfWidth, actualLower, 0));
            _lowerLimitLineRenderer.SetPosition(1, new Vector3(halfWidth, actualLower, 0));
            _lowerLimitLineRenderer.gameObject.SetActive(true);
            
            Debug.Log($"WaveformRenderer: 显示限幅线 - Upper:{actualUpper:F2}, Lower:{actualLower:F2}, Width:{halfWidth * 2:F2}");
        }

        /// <summary>
        /// 隐藏限幅线
        /// </summary>
        public void HideLimitLines()
        {
            if (_upperLimitLineRenderer != null)
            {
                _upperLimitLineRenderer.gameObject.SetActive(false);
            }
            if (_lowerLimitLineRenderer != null)
            {
                _lowerLimitLineRenderer.gameObject.SetActive(false);
            }
        }

        /// <summary>
        /// 设置限幅线透明度（用于闪烁动画）
        /// </summary>
        public void SetLimitLinesAlpha(float alpha)
        {
            Color color = limitLineColor;
            color.a = alpha;

            if (_upperLimitLineRenderer != null)
            {
                _upperLimitLineRenderer.startColor = color;
                _upperLimitLineRenderer.endColor = color;
            }
            if (_lowerLimitLineRenderer != null)
            {
                _lowerLimitLineRenderer.startColor = color;
                _lowerLimitLineRenderer.endColor = color;
            }
        }

        /// <summary>
        /// 设置扫描线颜色
        /// </summary>
        public void SetScanLineColor(Color color)
        {
            if (_scanLineRenderer != null)
            {
                _scanLineRenderer.startColor = color;
                _scanLineRenderer.endColor = color;
            }
        }

        #endregion
    }
}