using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using TracyProfiler;

namespace TracyProfiler.Examples
{
    /// <summary>
    /// Tracy 使用示例
    /// 展示如何在不同场景下使用 Tracy 性能分析
    /// </summary>
    public class TracyExamples : MonoBehaviour
    {
        [Header("测试参数")]
        [SerializeField] private int heavyComputationIterations = 10000;
        [SerializeField] private int objectPoolSize = 100;
        [SerializeField] private bool runContinuousTest = false;

        private List<GameObject> objectPool = new List<GameObject>();

        private void Start()
        {
            Tracy.Message("TracyExamples - 示例场景启动");
            InitializeObjectPool();
        }

        private void Update()
        {
            // 示例 1: 追踪整个 Update 方法
            using (Tracy.Zone("TracyExamples.Update"))
            {
                // 示例 2: 追踪输入处理
                HandleInput();

                // 示例 3: 追踪游戏逻辑
                if (runContinuousTest)
                {
                    UpdateGameLogic();
                }

                // 示例 4: 绘制自定义数据
                PlotCustomData();
            }
        }

        #region 示例 1: 基础 Zone 使用

        private void HandleInput()
        {
            using (Tracy.Zone("Handle Input"))
            {
                if (Input.GetKeyDown(KeyCode.Space))
                {
                    Tracy.Message("用户按下空格键");
                    PerformHeavyComputation();
                }

                if (Input.GetKeyDown(KeyCode.R))
                {
                    Tracy.Message("用户按下 R 键 - 重置对象池");
                    ResetObjectPool();
                }

                if (Input.GetKeyDown(KeyCode.T))
                {
                    Tracy.Message("用户按下 T 键 - 运行测试");
                    StartCoroutine(RunPerformanceTest());
                }
            }
        }

        #endregion

        #region 示例 2: 计算密集型操作追踪

        private void UpdateGameLogic()
        {
            using (Tracy.Zone("Update Game Logic"))
            {
                // 模拟一些游戏逻辑
                ProcessAI();
                UpdatePhysics();
                CheckCollisions();
            }
        }

        private void ProcessAI()
        {
            using (Tracy.Zone("Process AI"))
            {
                // 模拟 AI 计算
                float sum = 0;
                for (int i = 0; i < 1000; i++)
                {
                    sum += Mathf.Sin(i) * Mathf.Cos(i);
                }

                Tracy.Plot("AI Computation Result", sum);
            }
        }

        private void UpdatePhysics()
        {
            using (Tracy.Zone("Update Physics"))
            {
                // 模拟物理更新
                foreach (var obj in objectPool)
                {
                    if (obj.activeInHierarchy)
                    {
                        // 简单的物理模拟
                        obj.transform.position += Vector3.down * Time.deltaTime;
                    }
                }
            }
        }

        private void CheckCollisions()
        {
            using (Tracy.Zone("Check Collisions"))
            {
                // 模拟碰撞检测
                int activeObjects = 0;
                foreach (var obj in objectPool)
                {
                    if (obj.activeInHierarchy)
                    {
                        activeObjects++;
                    }
                }

                Tracy.Plot("Active Objects", activeObjects);
            }
        }

        #endregion

        #region 示例 3: 重度计算测试

        [ContextMenu("执行重度计算")]
        public void PerformHeavyComputation()
        {
            using (Tracy.Zone("Heavy Computation"))
            {
                Tracy.Message($"开始重度计算 ({heavyComputationIterations} 次迭代)");

                // 矩阵运算
                using (Tracy.Zone("Matrix Operations"))
                {
                    Matrix4x4 result = Matrix4x4.identity;
                    for (int i = 0; i < heavyComputationIterations; i++)
                    {
                        Matrix4x4 temp = Matrix4x4.TRS(
                            Random.insideUnitSphere,
                            Random.rotation,
                            Vector3.one
                        );
                        result = result * temp;
                    }
                }

                // 数学运算
                using (Tracy.Zone("Math Operations"))
                {
                    double sum = 0;
                    for (int i = 0; i < heavyComputationIterations; i++)
                    {
                        sum += System.Math.Sqrt(i) * System.Math.Sin(i) * System.Math.Cos(i);
                    }
                    Tracy.Plot("Math Result", sum);
                }

                Tracy.Message("重度计算完成");
            }
        }

        #endregion

        #region 示例 4: 对象池管理

        private void InitializeObjectPool()
        {
            using (Tracy.Zone("Initialize Object Pool"))
            {
                Tracy.Message($"初始化对象池 (大小: {objectPoolSize})");

                for (int i = 0; i < objectPoolSize; i++)
                {
                    GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Cube);
                    obj.name = $"PoolObject_{i}";
                    obj.transform.position = Random.insideUnitSphere * 10f;
                    obj.SetActive(false);
                    objectPool.Add(obj);
                }

                Tracy.Plot("Object Pool Size", objectPoolSize);
            }
        }

        [ContextMenu("重置对象池")]
        public void ResetObjectPool()
        {
            using (Tracy.Zone("Reset Object Pool"))
            {
                foreach (var obj in objectPool)
                {
                    obj.transform.position = Random.insideUnitSphere * 10f;
                    obj.SetActive(Random.value > 0.5f);
                }

                Tracy.Message("对象池已重置");
            }
        }

        #endregion

        #region 示例 5: 协程性能追踪

        [ContextMenu("运行性能测试")]
        public void StartPerformanceTest()
        {
            StartCoroutine(RunPerformanceTest());
        }

        private IEnumerator RunPerformanceTest()
        {
            Tracy.Message("=== 性能测试开始 ===");

            // 测试 1: 快速操作
            using (Tracy.Zone("Test: Fast Operations"))
            {
                for (int i = 0; i < 100; i++)
                {
                    float temp = Mathf.Sin(i);
                }
            }

            yield return null;

            // 测试 2: 中等操作
            using (Tracy.Zone("Test: Medium Operations"))
            {
                for (int i = 0; i < 1000; i++)
                {
                    Vector3 temp = Random.insideUnitSphere;
                }
            }

            yield return new WaitForSeconds(0.1f);

            // 测试 3: 慢速操作
            using (Tracy.Zone("Test: Slow Operations"))
            {
                for (int i = 0; i < objectPoolSize; i++)
                {
                    objectPool[i].SetActive(true);
                    objectPool[i].transform.position = Random.insideUnitSphere * 20f;
                }
            }

            yield return null;

            Tracy.Message("=== 性能测试完成 ===");
        }

        #endregion

        #region 示例 6: 自定义数据绘制

        private void PlotCustomData()
        {
            using (Tracy.Zone("Plot Custom Data"))
            {
                // 绘制内存使用
                long memoryUsed = System.GC.GetTotalMemory(false);
                Tracy.Plot("Custom Memory (MB)", memoryUsed / (1024.0 * 1024.0));

                // 绘制对象计数
                int activeCount = 0;
                foreach (var obj in objectPool)
                {
                    if (obj.activeInHierarchy) activeCount++;
                }
                Tracy.Plot("Active Pool Objects", activeCount);

                // 绘制帧时间
                Tracy.Plot("Custom Frame Time (ms)", Time.deltaTime * 1000f);

                // 绘制时间戳
                Tracy.Plot("Time Since Startup", Time.realtimeSinceStartup);
            }
        }

        #endregion

        #region 示例 7: 条件性能追踪

        /// <summary>
        /// 演示如何使用条件编译来控制 Tracy 的开销
        /// </summary>
        private void ConditionalProfiling()
        {
#if TRACY_ENABLE
            // 只有在定义了 TRACY_ENABLE 时才执行的代码
            using (Tracy.Zone("Conditional Profiling"))
            {
                // 详细的性能追踪
                DetailedPerformanceTracking();
            }
#endif
        }

        private void DetailedPerformanceTracking()
        {
            // 非常细粒度的性能追踪
            for (int i = 0; i < 10; i++)
            {
                using (Tracy.Zone($"Iteration {i}"))
                {
                    // 每次迭代的详细追踪
                    System.Threading.Thread.Sleep(1);
                }
            }
        }

        #endregion

        private void OnDestroy()
        {
            // 清理对象池
            using (Tracy.Zone("Cleanup Object Pool"))
            {
                foreach (var obj in objectPool)
                {
                    if (obj != null)
                    {
                        Destroy(obj);
                    }
                }
                objectPool.Clear();

                Tracy.Message("TracyExamples - 场景清理完成");
            }
        }

#if UNITY_EDITOR
        [ContextMenu("切换连续测试")]
        private void ToggleContinuousTest()
        {
            runContinuousTest = !runContinuousTest;
            Tracy.Message($"连续测试: {(runContinuousTest ? "启用" : "禁用")}");
        }
#endif
    }

    /// <summary>
    /// 演示如何在自定义类中使用 Tracy
    /// </summary>
    public class CustomSystem
    {
        private string systemName;

        public CustomSystem(string name)
        {
            systemName = name;
            Tracy.Message($"{systemName} - 系统创建");
        }

        public void Update()
        {
            using (Tracy.Zone($"{systemName}.Update"))
            {
                // 系统更新逻辑
                ProcessData();
                UpdateState();
            }
        }

        private void ProcessData()
        {
            using (Tracy.Zone($"{systemName}.ProcessData"))
            {
                // 数据处理
            }
        }

        private void UpdateState()
        {
            using (Tracy.Zone($"{systemName}.UpdateState"))
            {
                // 状态更新
            }
        }
    }
}