using System;
using System.Collections;
using System.IO;
using Convention;
using Demo.Editor.UI;
using UnityEngine;
using UnityEngine.Events;

namespace Demo.Game
{
    namespace ConfigType
    {
        // IInteraction 配置（抽象基类Config，继承自TimelineScriptObject）
        public class IInteractionConfig : ScriptLoadableConfig
        {
            public Vector2 VisibleDuration;
            public Vector2 InteractiveDuration;
            public Vector2 InteractableScoreInterval;
            public Vector2 InteractableIntervalThatCanScoreBest;
            public IInteraction.JudgementLevel MyJudgementLevel;
            public IInteraction.UpdatePhase MyUpdatePhase;

            public override void Deserialize(BinaryReader reader)
            {
                VisibleDuration = BinarySerializeUtility.ReadVec2(reader);
                InteractiveDuration = BinarySerializeUtility.ReadVec2(reader);
                InteractableScoreInterval = BinarySerializeUtility.ReadVec2(reader);
                InteractableIntervalThatCanScoreBest = BinarySerializeUtility.ReadVec2(reader);
                MyJudgementLevel = (IInteraction.JudgementLevel)BinarySerializeUtility.ReadInt(reader);
                MyUpdatePhase = (IInteraction.UpdatePhase)BinarySerializeUtility.ReadInt(reader);
                base.Deserialize(reader);
            }

            public override void Serialize(BinaryWriter writer)
            {
                BinarySerializeUtility.WriteVec2(writer, VisibleDuration);
                BinarySerializeUtility.WriteVec2(writer, InteractiveDuration);
                BinarySerializeUtility.WriteVec2(writer, InteractableScoreInterval);
                BinarySerializeUtility.WriteVec2(writer, InteractableIntervalThatCanScoreBest);
                BinarySerializeUtility.WriteInt(writer, (int)MyJudgementLevel);
                BinarySerializeUtility.WriteInt(writer, (int)MyUpdatePhase);
                base.Serialize(writer);
            }
        }
    }

    public interface IHookInteraction
    {

    }

    public abstract class IInteraction : TimelineScriptObject
    {
        protected override void SetupTimelineItem(TimelineItem item)
        {
            item.SetupDuration(new(VisibleDuration.x, VisibleDuration.y), GetTimelineItemColor());
        }

        public const float IdentifiableJudgementTerminal = 0.16f;

        [Content, SerializeField, Header("Cache")]
        public float MyCacheUpdateTick = 0;

        [Header(nameof(VisibleDuration))]
        [Content, SerializeField] private Vector2 VisibleDuration;
        public static float DefaultVisibleLength = IdentifiableJudgementTerminal * 15;
        [Content, SerializeField] public UnityEvent VisibleDurationBeforeEvent = new(),
            VisibleDurationBeginEvent = new(), VisibleDurationEndEvent = new();

        [Header(nameof(InteractiveDuration))]
        [Content, SerializeField] private Vector2 InteractiveDuration;
        public static float DefaultInteractiveLength = IdentifiableJudgementTerminal * 9;
        [Content, SerializeField] public UnityEvent InteractiveDurationBeforeEvent = new(), 
            InteractiveDurationBeginEvent = new(), InteractiveDurationEndEvent = new();

        [Header(nameof(InteractableScoreInterval))]
        [Content, SerializeField] private Vector2 InteractableScoreInterval;
        public static float DefaultInteractableScoreIntervalLength = IdentifiableJudgementTerminal * 6;
        [Content, SerializeField] public UnityEvent InteractableScoreIntervalBeforeEvent = new(), 
            InteractableScoreIntervalBeginEvent = new(), InteractableScoreIntervalEndEvent = new();

        [Header(nameof(InteractableIntervalThatCanScoreBest))]
        [Content, SerializeField] private Vector2 InteractableIntervalThatCanScoreBest;
        public static float DefaultInteractableIntervalLengthThatCanScoreBest = IdentifiableJudgementTerminal * 3;
        [Content, SerializeField] public UnityEvent InteractableIntervalThatCanScoreBestBeforeEvent = new(), 
            InteractableIntervalThatCanScoreBestBeginEvent = new(), InteractableIntervalThatCanScoreBestEndEvent = new();

        [Flags,Serializable]
        public enum UpdatePhaseComponent
        {
            OutsideVisibleDuration = 0b00000000,
            //
            InsideVisibleDuration = 0b00000001,
            InsideInteractiveDuration = 0b00000010,
            InsideInteractableScoreInterval = 0b00000100,
            InsideInteractableIntervalThatCanScoreBest = 0b00001000,
            //
            EnterVisibleDuration = 0b00010000,
            EnterInteractiveDuration = 0b00100000,
            EnterInteractableScoreInterval = 0b01000000,
            EnterInteractableIntervalThatCanScoreBest = 0b10000000,
        }

        [Flags, Serializable]
        public enum UpdatePhase
        {
            // 进入可视区间之前
            BeforeVisibleDuration
                = UpdatePhaseComponent.OutsideVisibleDuration,
            // 进入不可判定但可视的3级判定区间
            EnterVisibleDuration
                = UpdatePhaseComponent.InsideVisibleDuration | UpdatePhaseComponent.EnterVisibleDuration,
            // 进入可判定为失误的2级判定区间
            EnterInteractiveDuration
                = UpdatePhaseComponent.InsideInteractiveDuration | UpdatePhaseComponent.EnterInteractiveDuration | UpdatePhase.EnterVisibleDuration,
            // 进入可得分的1级判定区间
            EnterInteractableScoreInterval
                = UpdatePhaseComponent.InsideInteractableScoreInterval | UpdatePhaseComponent.EnterInteractableScoreInterval | UpdatePhase.EnterInteractiveDuration,
            // 进入可得满分的0级判定区间
            EnterInteractableIntervalThatCanScoreBest 
                = UpdatePhaseComponent.InsideInteractableIntervalThatCanScoreBest| UpdatePhaseComponent.EnterInteractableIntervalThatCanScoreBest
                | UpdatePhase.EnterInteractableScoreInterval,
            // 退出0级判定区间
            AfterInteractableIntervalThatCanScoreBest
                = UpdatePhase.EnterInteractableIntervalThatCanScoreBest&(~UpdatePhaseComponent.InsideInteractableIntervalThatCanScoreBest),
            // 退出1级判定区间
            AfterInteractableScoreInterval
                = UpdatePhase.AfterInteractableIntervalThatCanScoreBest & (~UpdatePhaseComponent.InsideInteractableScoreInterval),
            // 退出2级判断区间
            AfterInteractiveDuration
                = UpdatePhase.AfterInteractableScoreInterval & (~UpdatePhaseComponent.InsideInteractiveDuration),
            // 退出3级判断区间, 已不可视
            AfterVisibleDuration
                = UpdatePhase.AfterInteractiveDuration & (~UpdatePhaseComponent.InsideVisibleDuration)
        }

        public enum JudgementLevel
        {
            None = -2,//No Judge
            Default = -1,
            BestLevel = 0,//Level0
            ScoreLevel = 1,//Level1
            Bad = 128,
        }

        [Header("Judgement")]
        [Content, SerializeField] private JudgementLevel MyJudgementLevel = JudgementLevel.None;
        [Content, SerializeField] private UpdatePhase MyUpdatePhase = default;
        [Content, SerializeField] private float BestJudgementTimePoint = -1;
        [Content, SerializeField] public UnityEvent<JudgementLevel> JudgementEvent = new();

        public float GetBestJudgementTimePoint()
        {
            return BestJudgementTimePoint;
        }

        public bool IsInInteractiveDuration(float time)
        {
            return time > InteractiveDuration.x && time < InteractiveDuration.y;
        }
        public bool IsInInteractiveDuration()
        {
            return IsInInteractiveDuration(MyCacheUpdateTick);
        }

        public const int JudgementLevelCount = 3;

        public override IEnumerator UnloadScript()
        {
            yield return base.UnloadScript();
            VisibleDurationBeginEvent = new();
            VisibleDurationEndEvent = new();
            InteractiveDurationBeginEvent = new();
            InteractiveDurationEndEvent = new();
            InteractableScoreIntervalBeginEvent = new();
            InteractableScoreIntervalEndEvent = new();
            InteractableIntervalThatCanScoreBestBeginEvent = new();
            InteractableIntervalThatCanScoreBestEndEvent = new();
            BestJudgementTimePoint = -1;
        }

        public void InvokeJudgement(JudgementLevel level)
        {
            if (level == JudgementLevel.None)
                return;
            // 进入已判定状态
            MyJudgementLevel = level;
            JudgementEvent.Invoke(level);
            // 触发还未触发的退出事件
            {
                if (((int)MyUpdatePhase & (int)UpdatePhaseComponent.EnterInteractableIntervalThatCanScoreBest) != 0)
                {
                    InteractableIntervalThatCanScoreBestEndEvent.Invoke();
                }
                if (((int)MyUpdatePhase & (int)UpdatePhaseComponent.EnterInteractableScoreInterval) != 0)
                {
                    InteractableScoreIntervalEndEvent.Invoke();
                }
                if (((int)MyUpdatePhase & (int)UpdatePhaseComponent.EnterInteractiveDuration) != 0)
                {
                    InteractiveDurationEndEvent.Invoke();
                }
                if (((int)MyUpdatePhase & (int)UpdatePhaseComponent.EnterVisibleDuration) != 0)
                {
                    VisibleDurationEndEvent.Invoke();
                }
            }
        }

        public abstract JudgementLevel JudgementBehaviour(float timePoint);

        #region Update Judgement Stats

        private void DoUpdateJudgementStats(float currentTime)
        {
            // 重置
            if (MyCacheUpdateTick > currentTime)
            {
                MyUpdatePhase = UpdatePhase.BeforeVisibleDuration;
                VisibleDurationBeforeEvent.Invoke();
                InteractiveDurationBeforeEvent.Invoke();
                InteractableScoreIntervalBeforeEvent.Invoke();
                InteractableIntervalThatCanScoreBestBeforeEvent.Invoke();
                MyJudgementLevel = JudgementLevel.None;
            }
            // 状态更新
            {
                // 在当前区间进行判断, 当前时间落入下一个区间时, 就进入下一个区间
                switch (MyUpdatePhase)
                {
                    case UpdatePhase.BeforeVisibleDuration:
                        if (currentTime > VisibleDuration.x)
                        {
                            MyUpdatePhase = UpdatePhase.EnterVisibleDuration;
                            VisibleDurationBeginEvent.Invoke();
                        }
                        break;
                    case UpdatePhase.EnterVisibleDuration:
                        if (currentTime > InteractiveDuration.x)
                        {
                            MyUpdatePhase = UpdatePhase.EnterInteractiveDuration;
                            InteractiveDurationBeginEvent.Invoke();
                        }
                        break;
                    case UpdatePhase.EnterInteractiveDuration:
                        if (currentTime > InteractableScoreInterval.x)
                        {
                            MyUpdatePhase = UpdatePhase.EnterInteractableScoreInterval;
                            InteractableScoreIntervalBeginEvent.Invoke();
                        }
                        break;
                    case UpdatePhase.EnterInteractableScoreInterval:
                        if (currentTime > InteractableIntervalThatCanScoreBest.x)
                        {
                            MyUpdatePhase = UpdatePhase.EnterInteractableIntervalThatCanScoreBest;
                            InteractableIntervalThatCanScoreBestBeginEvent.Invoke();
                        }
                        break;
                    // ---------------------------------------------------------
                    case UpdatePhase.EnterInteractableIntervalThatCanScoreBest:
                        if (currentTime > InteractableIntervalThatCanScoreBest.y)
                        {
                            MyUpdatePhase = UpdatePhase.AfterInteractableIntervalThatCanScoreBest;
                            InteractableIntervalThatCanScoreBestEndEvent.Invoke();
                        }
                        break;
                    case UpdatePhase.AfterInteractableIntervalThatCanScoreBest:
                        if (currentTime > InteractableScoreInterval.y)
                        {
                            MyUpdatePhase = UpdatePhase.AfterInteractableScoreInterval;
                            InteractableScoreIntervalEndEvent.Invoke();
                        }
                        break;
                    case UpdatePhase.AfterInteractableScoreInterval:
                        if (currentTime > InteractiveDuration.y)
                        {
                            MyUpdatePhase = UpdatePhase.AfterInteractiveDuration;
                            InteractiveDurationEndEvent.Invoke();
                        }
                        break;
                    case UpdatePhase.AfterInteractiveDuration:
                        if (currentTime > VisibleDuration.y)
                        {
                            MyUpdatePhase = UpdatePhase.AfterVisibleDuration;
                            VisibleDurationEndEvent.Invoke();
                        }
                        break;
                    default:
                        break;
                }
            }
            // 记录
            MyCacheUpdateTick = currentTime;
        }

        #endregion

        protected override void UpdateTicks(float currentTime, float deltaTime, TickType tickType)
        {
            base.UpdateTicks(currentTime, deltaTime, tickType);
            // 检定
            if (MyJudgementLevel == JudgementLevel.None)
            {
                InvokeJudgement(JudgementBehaviour(currentTime));
            }
            // 更新状态
            DoUpdateJudgementStats(currentTime);
        }

        public void DoSetupJudgementLevels(
            float bestJudgementTimePoint,
            float interactableIntervalThatCanScoreBest,
            float interactableScoreInterval,
            float interactiveDuration,
            float visibleDuration)
        {
            this.BestJudgementTimePoint = bestJudgementTimePoint;
            var bestJudgementTimePointValue = bestJudgementTimePoint;
            // InteractableIntervalThatCanScoreBest
            var interactableIntervalThatCanScoreBestValue = interactableIntervalThatCanScoreBest * 0.5f;
            InteractableIntervalThatCanScoreBest = new(bestJudgementTimePointValue - interactableIntervalThatCanScoreBestValue,
                bestJudgementTimePointValue + interactableIntervalThatCanScoreBestValue);

            // InteractableScoreInterval
            var interactableScoreIntervalValue = interactableScoreInterval * 0.5f;
            InteractableScoreInterval = new(bestJudgementTimePointValue - interactableScoreIntervalValue,
                bestJudgementTimePointValue + interactableScoreIntervalValue);

            // InteractiveDuration
            var interactiveDurationValue = interactiveDuration * 0.5f;
            InteractiveDuration = new(bestJudgementTimePointValue - interactiveDurationValue,
                bestJudgementTimePointValue + interactiveDurationValue);

            // InteractableScoreInterval
            var visibleDurationValue = visibleDuration * 0.5f;
            VisibleDuration = new(bestJudgementTimePointValue - visibleDurationValue,
                bestJudgementTimePointValue + visibleDurationValue);
        }

        public void DoSetupJudgement(float bestJudgementTimePoint)
        {
            DoSetupJudgementLevels(
                bestJudgementTimePoint,
                DefaultInteractableIntervalLengthThatCanScoreBest,
                DefaultInteractableScoreIntervalLength,
                DefaultInteractiveLength,
                DefaultVisibleLength);
        }

        /// <summary>
        /// 使用配置中的区间长度设置以最佳判定点为中心的各级区间
        /// </summary>
        /// <param name="bestJudgementTimePoint">最佳判定点</param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetupJudgement(float bestJudgementTimePoint)
        {
            DoSetupJudgement(bestJudgementTimePoint);
        }

        /// <summary>
        /// 通过传递对称区间进行初始化
        /// </summary>
        /// <param name="bestJudgementTimePoint">最佳判定点</param>
        /// <param name="interactableIntervalThatCanScoreBest">区间时长，最终结果为
        /// (bestJudgementTimePoint-interactableIntervalThatCanScoreBest/2,bestJudgementTimePoint+interactableIntervalThatCanScoreBest/2)</param>
        /// <param name="interactableScoreInterval">区间时长，最终结果为
        /// (bestJudgementTimePoint-interactableScoreInterval/2,bestJudgementTimePoint+interactableScoreInterval/2)</param>
        /// <param name="interactiveDuration">区间时长，最终结果为
        /// (bestJudgementTimePoint-interactiveDuration/2,bestJudgementTimePoint+interactiveDuration/2)</param>
        /// <param name="visibleDuration">区间时长，最终结果为
        /// (bestJudgementTimePoint-visibleDuration/2,bestJudgementTimePoint+visibleDuration/2)</param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetupJudgementLevels(
            float bestJudgementTimePoint,
            float interactableIntervalThatCanScoreBest,
            float interactableScoreInterval,
            float interactiveDuration,
            float visibleDuration)
        {
            DoSetupJudgementLevels(
                bestJudgementTimePoint,
                interactableIntervalThatCanScoreBest,
                interactableScoreInterval,
                interactiveDuration,
                visibleDuration);
        }

        /// <summary>
        /// 设置可见区间（显现但不可判定，3级判定区间）开始时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVisibleDurationBegin(float value)
        {
            VisibleDuration.x = value;
        }
        /// <summary>
        /// 设置可见区间（显现但不可判定，3级判定区间）结束时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVisibleDurationEnd(float value)
        {
            VisibleDuration.y = value;
        }

        /// <summary>
        /// 设置2级判定区间（可判定但错误的）开始时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetInteractiveDurationBegin(float value)
        {
            InteractiveDuration.x = value;
        }
        /// <summary>
        /// 设置2级判定区间（可判定但错误的）结束时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetInteractiveDurationEnd(float value)
        {
            InteractiveDuration.y = value;
        }

        /// <summary>
        /// 设置1级判定区间（可判定的）开始时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetInteractableScoreIntervalBegin(float value)
        {
            InteractableScoreInterval.x = value;
        }
        /// <summary>
        /// 设置1级判定区间（可判定的）结束时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetInteractableScoreIntervalEnd(float value)
        {
            InteractableScoreInterval.y = value;
        }

        /// <summary>
        /// 设置0级判定区间（最佳判定）开始时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetInteractableIntervalThatCanScoreBestBegin(float value)
        {
            InteractableIntervalThatCanScoreBest.x = value;
            if (BestJudgementTimePoint < 0)
            {
                BestJudgementTimePoint = Mathf.Lerp(InteractableIntervalThatCanScoreBest.x, InteractableIntervalThatCanScoreBest.y, 0.5f);
            }
        }
        /// <summary>
        /// 设置0级判定区间（最佳判定）结束时间
        /// </summary>
        /// <param name="value"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetInteractableIntervalThatCanScoreBestEnd(float value)
        {
            InteractableIntervalThatCanScoreBest.y = value;
            if (BestJudgementTimePoint < 0)
            {
                BestJudgementTimePoint = Mathf.Lerp(InteractableIntervalThatCanScoreBest.x, InteractableIntervalThatCanScoreBest.y, 0.5f);
            }
        }
    }
}