using System;
using System.Collections;
using System.Collections.Generic;
using Ichni.RhythmGame.Beatmap;
using Lean.Pool;
using UnityEngine;

namespace Ichni.RhythmGame
{
    public partial class Swirl : AnimationBase
    {
        #region [暴露属性字段与关联] Exposed Fields & References
        private TransformSubmodule targetTransformSubmodule;
        public FlexibleFloat eulerAngleX, eulerAngleY, eulerAngleZ;
        
        public static HashSet<Swirl> ActiveSwirls = new HashSet<Swirl>();
        #endregion

        protected void OnEnable() { ActiveSwirls.Add(this); }
        protected void OnDisable() { ActiveSwirls.Remove(this); }

        #region [生命周期与工厂] Lifecycle & Factory
        public static Swirl GenerateElement(string elementName, Guid id,
            List<string> tags, bool isFirstGenerated, GameElement animatedObject,
            FlexibleFloat eulerAngleX, FlexibleFloat eulerAngleY, FlexibleFloat eulerAngleZ)
        {
            Swirl swirl = Instantiate(GameManager.Instance.basePrefabs.emptyObject).AddComponent<Swirl>();

            swirl.Initialize(elementName, id, tags, isFirstGenerated, animatedObject);

            swirl.animatedObject = animatedObject;

            swirl.eulerAngleX = eulerAngleX;
            swirl.eulerAngleY = eulerAngleY;
            swirl.eulerAngleZ = eulerAngleZ;
            swirl.animationReturnType = FlexibleReturnType.Before;

            swirl.targetTransformSubmodule = (animatedObject as IHaveTransformSubmodule).transformSubmodule;
            
            return swirl;
        }
        #endregion
        
        #region [核心动画逻辑] Core Animation Logic
        protected override void UpdateAnimation(float songTime, bool forceUpdate)
        {
            eulerAngleX.UpdateFlexibleFloat(songTime);
            eulerAngleY.UpdateFlexibleFloat(songTime);
            eulerAngleZ.UpdateFlexibleFloat(songTime);

            bool isMiddleExecuting = eulerAngleX.returnType is FlexibleReturnType.MiddleExecuting ||
                                     eulerAngleY.returnType is FlexibleReturnType.MiddleExecuting ||
                                     eulerAngleZ.returnType is FlexibleReturnType.MiddleExecuting;

            bool isSwitching = eulerAngleX.isSwitchingReturnType || eulerAngleY.isSwitchingReturnType || eulerAngleZ.isSwitchingReturnType;

            if (forceUpdate || isMiddleExecuting)
            {
                if(!forceUpdate) animationReturnType = FlexibleReturnType.MiddleExecuting;
                
                // 首帧合并退让保护
                bool shouldSkipFirstFrame = false;
                if (!forceUpdate && isSwitching)
                {
                    foreach (var s in ActiveSwirls)
                    {
                        if (s != this && s.targetTransformSubmodule == this.targetTransformSubmodule)
                        {
                            if (s.eulerAngleX.isSwitchingReturnType || s.eulerAngleY.isSwitchingReturnType || s.eulerAngleZ.isSwitchingReturnType)
                            {
                                shouldSkipFirstFrame = true;
                                break;
                            }
                        }
                    }
                }

                if (!shouldSkipFirstFrame)
                {
                    Vector3 currentEulerAngles = new Vector3(eulerAngleX.value, eulerAngleY.value, eulerAngleZ.value);
                    targetTransformSubmodule.eulerAnglesOffset += currentEulerAngles;
                    targetTransformSubmodule.eulerAnglesDirtyMark = true;
                }
            }
            else if (isSwitching)
            {
                // 最终帧补偿机制
                bool isAnyOtherExecuting = false;
                foreach (var s in ActiveSwirls)
                {
                    if (s != this && s.targetTransformSubmodule == this.targetTransformSubmodule)
                    {
                        if (s.eulerAngleX.returnType is FlexibleReturnType.MiddleExecuting ||
                            s.eulerAngleY.returnType is FlexibleReturnType.MiddleExecuting ||
                            s.eulerAngleZ.returnType is FlexibleReturnType.MiddleExecuting)
                        {
                            isAnyOtherExecuting = true;
                            break;
                        }
                    }
                }

                if (!isAnyOtherExecuting)
                {
                    animationReturnType = FlexibleReturnType.MiddleExecuting;
                    Vector3 currentEulerAngles = new Vector3(eulerAngleX.value, eulerAngleY.value, eulerAngleZ.value);
                    targetTransformSubmodule.eulerAnglesOffset += currentEulerAngles;
                    targetTransformSubmodule.eulerAnglesDirtyMark = true;
                }
            }
            else
            {
                animationReturnType = FlexibleReturnType.MiddleInterval;
            }
        }

        public override void ApplyTimeOffset(float offset)
        {
            base.ApplyTimeOffset(offset);
            eulerAngleX.animations.ForEach(anim => anim.ApplyTimeOffset(offset));
            eulerAngleY.animations.ForEach(anim => anim.ApplyTimeOffset(offset));
            eulerAngleZ.animations.ForEach(anim => anim.ApplyTimeOffset(offset));
        }
        #endregion
    }

}