using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
using System.Linq;
using System.IO;
 
namespace Exploder.Editor
{
    /// <summary>
    /// 动画帧提取器 - 专门用于精简 AnimationClip 中的冗余关键帧
    /// </summary>
    public class AnimationFrameExtractor : EditorWindow
    {
        private AnimationClip selectedClip;
        private float threshold = 0.01f;
        private bool showAdvanced = false;
        private float positionThreshold = 0.001f;
        private float rotationThreshold = 0.1f;
        private float scaleThreshold = 0.001f;
        private bool keepFirstAndLast = true;
        private int originalKeyCount;
        private int optimizedKeyCount;
        private float reductionPercent;
 
        [MenuItem("Tools/优化/动画帧提取器")]
        public static void ShowWindow()
        {
            var window = GetWindow<AnimationFrameExtractor>("动画帧提取器");
            window.Show();
        }
 
        void OnGUI()
        {
            GUILayout.Label("动画帧提取优化", EditorStyles.boldLabel);
            
            selectedClip = (AnimationClip)EditorGUILayout.ObjectField("动画剪辑 (Clip)", selectedClip, typeof(AnimationClip), false);
            
            EditorGUILayout.Space();
            GUILayout.Label("提取设置", EditorStyles.boldLabel);
            
            threshold = EditorGUILayout.Slider("敏感度阈值", threshold, 0.001f, 0.1f);
            keepFirstAndLast = EditorGUILayout.Toggle("保留首尾帧", keepFirstAndLast);
            
            showAdvanced = EditorGUILayout.Foldout(showAdvanced, "高级设置 (针对不同属性)");
            if (showAdvanced)
            {
                EditorGUI.indentLevel++;
                positionThreshold = EditorGUILayout.FloatField("位置阈值 (Position)", positionThreshold);
                rotationThreshold = EditorGUILayout.FloatField("旋转阈值 (Rotation)", rotationThreshold);
                scaleThreshold = EditorGUILayout.FloatField("缩放阈值 (Scale)", scaleThreshold);
                EditorGUI.indentLevel--;
            }
            
            EditorGUILayout.Space();
            
            if (selectedClip != null)
            {
                if (GUILayout.Button("分析动画 (Analyze)"))
                {
                    AnalyzeAnimation();
                }
                
                if (originalKeyCount > 0)
                {
                    EditorGUILayout.Space();
                    EditorGUILayout.BeginVertical(EditorStyles.helpBox);
                    GUILayout.Label($"原始关键帧总数: {originalKeyCount}", EditorStyles.label);
                    GUILayout.Label($"优化后关键帧数: {optimizedKeyCount}", EditorStyles.label);
                    GUI.color = Color.green;
                    GUILayout.Label($"预计减少比例: {reductionPercent:F1}%", EditorStyles.boldLabel);
                    GUI.color = Color.white;
                    EditorGUILayout.EndVertical();
                    
                    EditorGUILayout.Space();
                    if (GUILayout.Button("执行提取并保存 (Extract)"))
                    {
                        ExtractAnimationFrames();
                    }
                }
            }
            
            EditorGUILayout.Space();
            if (GUILayout.Button("从选定对象批量提取 (Selection)"))
            {
                ExtractFromSelection();
            }
            
            EditorGUILayout.Space();
            EditorGUILayout.HelpBox("提示：该工具使用 Douglas-Peucker 算法移除对动画形状影响不大的冗余帧。操作前会自动创建 _backup 备份文件。", MessageType.Info);
        }
 
        private void AnalyzeAnimation()
        {
            if (selectedClip == null) return;
 
            EditorCurveBinding[] bindings = AnimationUtility.GetCurveBindings(selectedClip);
            originalKeyCount = 0;
            optimizedKeyCount = 0;
 
            foreach (var binding in bindings)
            {
                AnimationCurve curve = AnimationUtility.GetEditorCurve(selectedClip, binding);
                if (curve == null) continue;
 
                originalKeyCount += curve.length;
                
                // 模拟提取后的关键帧数量
                AnimationCurve optimized = ExtractKeyframes(curve, selectedClip.length);
                optimizedKeyCount += optimized.length;
            }
 
            reductionPercent = originalKeyCount > 0 ? (1f - (float)optimizedKeyCount / originalKeyCount) * 100f : 0f;
        }
 
        private void ExtractAnimationFrames()
        {
            if (selectedClip == null) return;
 
            string backupPath = CreateBackup(selectedClip);
            
            try
            {
                Undo.RecordObject(selectedClip, "Extract Animation Frames");
                
                EditorCurveBinding[] bindings = AnimationUtility.GetCurveBindings(selectedClip);
                bool hasChanges = false;
 
                foreach (var binding in bindings)
                {
                    AnimationCurve originalCurve = AnimationUtility.GetEditorCurve(selectedClip, binding);
                    if (originalCurve == null || originalCurve.length <= 2) continue;
 
                    AnimationCurve optimizedCurve = ExtractKeyframes(originalCurve, selectedClip.length);
                    
                    if (optimizedCurve.length < originalCurve.length)
                    {
                        AnimationUtility.SetEditorCurve(selectedClip, binding, optimizedCurve);
                        hasChanges = true;
                    }
                }
 
                if (hasChanges)
                {
                    EditorUtility.SetDirty(selectedClip);
                    AssetDatabase.SaveAssets();
                    AssetDatabase.Refresh();
                    
                    Debug.Log($"[动画优化] 成功提取帧: {selectedClip.name}");
                    Debug.Log($"[动画优化] 关键帧精简: {originalKeyCount} → {optimizedKeyCount} (减少了 {reductionPercent:F1}%)");
                    
                    // 重新分析显示最新数据
                    AnalyzeAnimation();
                }
                else
                {
                    Debug.Log("[动画优化] 当前设置下没有可进一步精简的帧。");
                }
            }
            catch (System.Exception e)
            {
                RestoreBackup(selectedClip, backupPath);
                Debug.LogError($"[动画优化] 提取失败: {e.Message}");
            }
            finally
            {
                CleanupBackup(backupPath);
            }
        }
 
        private AnimationCurve ExtractKeyframes(AnimationCurve curve, float clipLength)
        {
            if (curve.length <= 2) return curve;
 
            List<Keyframe> keyframes = new List<Keyframe>(curve.keys);
            List<Keyframe> result = new List<Keyframe>();
            
            // 总是保留第一帧
            if (keepFirstAndLast && keyframes.Count > 0)
            {
                result.Add(keyframes[0]);
            }
 
            // 使用 Douglas-Peucker 算法简化曲线
            SimplifyCurve(keyframes, result, 0, keyframes.Count - 1, GetPropertyThreshold(curve));
 
            // 总是保留最后一帧
            if (keepFirstAndLast && keyframes.Count > 1 && !result.Any(k => Mathf.Approximately(k.time, keyframes.Last().time)))
            {
                result.Add(keyframes[keyframes.Count - 1]);
            }
 
            // 确保时间顺序
            result = result.OrderBy(k => k.time).ToList();
 
            // 重新计算切线以保持曲线平滑
            AnimationCurve newCurve = new AnimationCurve(result.ToArray()) { preWrapMode = curve.preWrapMode, postWrapMode = curve.postWrapMode };
            for (int i = 0; i < newCurve.length; i++)
            {
                AnimationUtility.SetKeyLeftTangentMode(newCurve, i, AnimationUtility.GetKeyLeftTangentMode(curve, 0));
                AnimationUtility.SetKeyRightTangentMode(newCurve, i, AnimationUtility.GetKeyRightTangentMode(curve, 0));
            }
            return newCurve;
        }
 
        private void SimplifyCurve(List<Keyframe> points, List<Keyframe> result, int startIndex, int endIndex, float epsilon)
        {
            if (endIndex <= startIndex + 1) return;
 
            // 找到距离起点和终点连线最远的点
            float maxDistance = 0f;
            int maxIndex = startIndex;
            
            Keyframe start = points[startIndex];
            Keyframe end = points[endIndex];
            
            for (int i = startIndex + 1; i < endIndex; i++)
            {
                float distance = PointToLineDistance(start, end, points[i]);
                if (distance > maxDistance)
                {
                    maxDistance = distance;
                    maxIndex = i;
                }
            }
 
            // 如果最大距离大于阈值，递归处理
            if (maxDistance > epsilon)
            {
                SimplifyCurve(points, result, startIndex, maxIndex, epsilon);
                if (!result.Any(k => Mathf.Approximately(k.time, points[maxIndex].time)))
                {
                    result.Add(points[maxIndex]);
                }
                SimplifyCurve(points, result, maxIndex, endIndex, epsilon);
            }
        }
 
        private float PointToLineDistance(Keyframe lineStart, Keyframe lineEnd, Keyframe point)
        {
            // 计算点到直线的距离
            float lineLength = Vector2.Distance(new Vector2(lineStart.time, lineStart.value), 
                                              new Vector2(lineEnd.time, lineEnd.value));
            
            if (lineLength == 0) 
                return Vector2.Distance(new Vector2(lineStart.time, lineStart.value), 
                                      new Vector2(point.time, point.value));
            
            float t = Mathf.Clamp01(Vector2.Dot(
                new Vector2(point.time - lineStart.time, point.value - lineStart.value),
                new Vector2(lineEnd.time - lineStart.time, lineEnd.value - lineStart.value)
            ) / (lineLength * lineLength));
            
            Vector2 projection = new Vector2(lineStart.time, lineStart.value) + 
                               t * new Vector2(lineEnd.time - lineStart.time, lineEnd.value - lineStart.value);
            
            return Vector2.Distance(new Vector2(point.time, point.value), projection);
        }
 
        private float GetPropertyThreshold(AnimationCurve curve)
        {
            return threshold;
        }
 
        private void ExtractFromSelection()
        {
            List<AnimationClip> clips = new List<AnimationClip>();
            
            // 从选中的对象中获取动画组件
            foreach (GameObject obj in Selection.gameObjects)
            {
                Animation animation = obj.GetComponent<Animation>();
                if (animation != null)
                {
                    foreach (AnimationState state in animation)
                    {
                        if (state.clip != null && !clips.Contains(state.clip))
                        {
                            clips.Add(state.clip);
                        }
                    }
                }
                
                Animator animator = obj.GetComponent<Animator>();
                if (animator != null && animator.runtimeAnimatorController != null)
                {
                    foreach (AnimationClip clip in animator.runtimeAnimatorController.animationClips)
                    {
                        if (!clips.Contains(clip))
                        {
                            clips.Add(clip);
                        }
                    }
                }
            }
            
            // 从选中的资源中获取动画片段
            foreach (Object obj in Selection.objects)
            {
                if (obj is AnimationClip clip && !clips.Contains(clip))
                {
                    clips.Add(clip);
                }
            }
            
            if (clips.Count == 0)
            {
                EditorUtility.DisplayDialog("未找到动画", "请选择包含 Animation/Animator 组件的游戏对象或动画剪辑资源。", "确定");
                return;
            }
            
            int processed = 0;
            foreach (AnimationClip clip in clips)
            {
                selectedClip = clip;
                AnalyzeAnimation();
                
                if (reductionPercent > 5f) // 只有能减少5%以上才处理
                {
                    ExtractAnimationFrames();
                    processed++;
                }
            }
            
            Debug.Log($"[动画优化] 批量处理完成，共处理 {processed} 个动画剪辑。");
        }
 
        private string CreateBackup(AnimationClip clip)
        {
            string assetPath = AssetDatabase.GetAssetPath(clip);
            string backupPath = Path.Combine(Path.GetDirectoryName(assetPath), 
                Path.GetFileNameWithoutExtension(assetPath) + "_backup.anim");
            
            AssetDatabase.CopyAsset(assetPath, backupPath);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
            
            return backupPath;
        }
 
        private void RestoreBackup(AnimationClip clip, string backupPath)
        {
            if (File.Exists(backupPath))
            {
                string assetPath = AssetDatabase.GetAssetPath(clip);
                AssetDatabase.DeleteAsset(assetPath);
                AssetDatabase.CopyAsset(backupPath, assetPath);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
        }
 
        private void CleanupBackup(string backupPath)
        {
            if (AssetDatabase.LoadAssetAtPath<AnimationClip>(backupPath) != null)
            {
                AssetDatabase.DeleteAsset(backupPath);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
        }
    }
 
    // 右键菜单扩展
    public class AnimationExtractorContextMenu
    {
        [MenuItem("Assets/提取动画关键帧 (Extract Frames)", true)]
        static bool ValidateExtractFrames()
        {
            return Selection.activeObject is AnimationClip;
        }
 
        [MenuItem("Assets/提取动画关键帧 (Extract Frames)")]
        static void ExtractFrames(MenuCommand command)
        {
            AnimationClip clip = Selection.activeObject as AnimationClip;
            if (clip != null)
            {
                AnimationFrameExtractor window = EditorWindow.GetWindow<AnimationFrameExtractor>("动画帧提取器");
                
                // 设置选中的 clip
                var field = typeof(AnimationFrameExtractor).GetField("selectedClip", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                if (field != null) field.SetValue(window, clip);
                
                // 执行分析和提取
                var analyzeMethod = typeof(AnimationFrameExtractor).GetMethod("AnalyzeAnimation", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                var extractMethod = typeof(AnimationFrameExtractor).GetMethod("ExtractAnimationFrames", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                
                if (analyzeMethod != null) analyzeMethod.Invoke(window, null);
                if (extractMethod != null) extractMethod.Invoke(window, null);
            }
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
namespace MyGameFramework.Tools {
    public class UnityDoTween : MonoBehaviour {
        
        // 存储所有运行中的协程，用于清理
        private static List<Coroutine> activeCoroutines = new List<Coroutine>();
        private static MonoBehaviour coroutineRunner;
        
        // 初始化方法（兼容 DOTween.Init 调用）
        public static void Init(bool recycleAllByDefault = false, bool useSafeMode = true) {
            // Unity 原生实现不需要特殊初始化
            activeCoroutines.Clear();
        }
        
        // 清理方法（兼容 DOTween.Clear 调用）
        public static void Clear(bool destroy = false) {
            // 停止所有记录的协程
            if (coroutineRunner != null) {
                foreach (var coroutine in activeCoroutines) {
                    if (coroutine != null) {
                        coroutineRunner.StopCoroutine(coroutine);
                    }
                }
            }
            activeCoroutines.Clear();
        }
        
        // 获取协程运行器
        private static MonoBehaviour GetCoroutineRunner() {
            if (coroutineRunner == null) {
                // 尝试找到一个 MonoBehaviour 来运行协程
                coroutineRunner = UnityEngine.Object.FindFirstObjectByType<MonoBehaviour>();
            }
            return coroutineRunner;
        }
        
        // 延迟调用方法（兼容 DOVirtual.DelayedCall）
        public static void DelayedCall(float delay, Action callback) {
            var runner = GetCoroutineRunner();
            if (runner != null) {
                var coroutine = runner.StartCoroutine(DODelay(delay, callback));
                activeCoroutines.Add(coroutine);
            }
        }
        // 缓动类型枚举
        public enum EaseType {
            Linear,
            InQuad,
            OutQuad,
            InOutQuad,
            InCubic,
            OutCubic,
            InOutCubic
        }
        
        // 获取缓动值
        private static float GetEaseValue(float t, EaseType easeType) {
            switch (easeType) {
                case EaseType.InQuad:
                    return t * t;
                case EaseType.OutQuad:
                    return t * (2 - t);
                case EaseType.InOutQuad:
                    return t < 0.5f ? 2 * t * t : -1 + (4 - 2 * t) * t;
                case EaseType.InCubic:
                    return t * t * t;
                case EaseType.OutCubic:
                    return (--t) * t * t + 1;
                case EaseType.InOutCubic:
                    return t < 0.5f ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
                case EaseType.Linear:
                default:
                    return t;
            }
        }
        
        // 移动动画
        public static IEnumerator DOMove(Transform target, Vector3 endValue, float duration ,float delay = 0f, bool from  = false,Action onComplete = null, EaseType easeType = EaseType.Linear) {
            if(delay >0)
                yield return new WaitForSeconds(delay);
            Vector3 startValue = target.position;
            float elapsedTime = 0f;
 
            if (from) {
                startValue = endValue;
                endValue = target.position;
            }
            while (elapsedTime < duration) {
                float t = GetEaseValue(elapsedTime / duration, easeType);
                target.position = Vector3.Lerp(startValue, endValue, t);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.position = endValue;
            onComplete?.Invoke();
        }
 
        // 本地移动动画
        public static IEnumerator DOLocalMove(Transform target, Vector3 endValue, float duration ,float delay = 0f, bool from = false,Action onComplete = null, EaseType easeType = EaseType.Linear) {
            if(delay >0)
                yield return new WaitForSeconds(delay);
            Vector3 startValue = target.localPosition;
            float elapsedTime = 0f;
 
            if (from) {
                startValue = endValue;
                endValue = target.localPosition;
            }
        
            while (elapsedTime < duration) {
                float t = GetEaseValue(elapsedTime / duration, easeType);
                target.localPosition = Vector3.Lerp(startValue, endValue, t);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.localPosition = endValue;
            onComplete?.Invoke();
        }
        
        // 本地Y轴移动动画
        public static IEnumerator DOLocalMoveY(Transform target, float endValue, float duration, float delay = 0f, Action onComplete = null, EaseType easeType = EaseType.Linear) {
            if(delay > 0)
                yield return new WaitForSeconds(delay);
            float startValue = target.localPosition.y;
            float elapsedTime = 0f;
        
            while (elapsedTime < duration) {
                float t = GetEaseValue(elapsedTime / duration, easeType);
                float currentY = Mathf.Lerp(startValue, endValue, t);
                target.localPosition = new Vector3(target.localPosition.x, currentY, target.localPosition.z);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.localPosition = new Vector3(target.localPosition.x, endValue, target.localPosition.z);
            onComplete?.Invoke();
        }
 
        // 旋转动画
        public static IEnumerator DORotate(Transform target, Vector3 endValue, float duration) {
            Quaternion startRotation = target.rotation;
            Quaternion endRotation = Quaternion.Euler(endValue);
            float elapsedTime = 0f;
 
            while (elapsedTime < duration) {
                target.rotation = Quaternion.Lerp(startRotation, endRotation, elapsedTime / duration);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.rotation = endRotation;
        }
    
        public static IEnumerator DORotate(Transform target, Quaternion endValue, float duration) {
            Quaternion startRotation = target.rotation;
            float elapsedTime = 0f;
 
            while (elapsedTime < duration) {
                target.rotation = Quaternion.Lerp(startRotation, endValue, elapsedTime / duration);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.rotation = endValue;
        }
    
        // 本地旋转动画
        public static IEnumerator DOLocalRotate(Transform target, Vector3 endValue, float duration) {
            Quaternion startRotation = target.localRotation;
            Quaternion endRotation = Quaternion.Euler(endValue);
            float elapsedTime = 0f;
 
            while (elapsedTime < duration) {
                target.localRotation = Quaternion.Lerp(startRotation, endRotation, elapsedTime / duration);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.localRotation = endRotation;
        }
 
        // 缩放动画
        public static IEnumerator DOScale(Transform target, Vector3 endValue, float duration,float delay = 0f, bool from = false,Action onComplete = null, EaseType easeType = EaseType.Linear) {
            if(delay >0)
                yield return new WaitForSeconds(delay);
            Vector3 startValue = target.localScale;
            float elapsedTime = 0f;
 
            if (from) {
                startValue = endValue;
                endValue = target.localScale;
            }
            while (elapsedTime < duration) {
                float t = GetEaseValue(elapsedTime / duration, easeType);
                target.localScale = Vector3.Lerp(startValue, endValue, t);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.localScale = endValue;
            onComplete?.Invoke();
        }
 
        // UI透明度动画
        public static IEnumerator DOFade(CanvasGroup canvasGroup, float endValue, float duration, float delay = 0f, bool from = false,Action onComplete = null) {
            if(delay >0)
                yield return new WaitForSeconds(delay);
            float startValue = canvasGroup.alpha;
            float elapsedTime = 0f;
            if (from) {
                startValue = endValue;
                endValue = canvasGroup.alpha;
            }
            while (elapsedTime < duration) {
                canvasGroup.alpha = Mathf.Lerp(startValue, endValue, elapsedTime / duration);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            canvasGroup.alpha = endValue;
        }
 
        // Image颜色动画
        public static IEnumerator DOColor(Image image, Color endValue, float duration) {
            Color startValue = image.color;
            float elapsedTime = 0f;
 
            while (elapsedTime < duration) {
                image.color = Color.Lerp(startValue, endValue, elapsedTime / duration);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
            image.color = endValue;
        }
 
        // 数值动画
        public static IEnumerator DOFloat(System.Action<float> onValueChanged, float startValue, float endValue,
            float duration) {
            float elapsedTime = 0f;
 
            while (elapsedTime < duration) {
                float currentValue = Mathf.Lerp(startValue, endValue, elapsedTime / duration);
                onValueChanged?.Invoke(currentValue);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            onValueChanged?.Invoke(endValue);
        }
 
        // 带缓动函数的移动
        public static IEnumerator DOMoveEase(Transform target, Vector3 endValue, float duration,
            AnimationCurve easeCurve = null) {
            Vector3 startValue = target.position;
            float elapsedTime = 0f;
 
            if (easeCurve == null) {
                easeCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
            }
 
            while (elapsedTime < duration) {
                float t = easeCurve.Evaluate(elapsedTime / duration);
                target.position = Vector3.Lerp(startValue, endValue, t);
                elapsedTime += Time.deltaTime;
                yield return null;
            }
 
            target.position = endValue;
        }
 
        public static IEnumerator DODelay(float delay, Action onComplete = null) {
            yield return new WaitForSeconds(delay);
            onComplete?.Invoke();
        }
    }
}