using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Dreamteck.Splines;
using Sirenix.OdinInspector;
using TMPro;
using UniRx;
using UnityEngine;
using UnityEngine.Serialization;

namespace Ichni.RhythmGame
{
    public abstract partial class NoteBase : GameElement, IHaveTimeDurationSubmodule, IComparable<NoteBase>
    {
        [Title("Basic Info")]
        public float exactJudgeTime;
        public NoteJudgeIntervals judgeIntervals;

        [Title("Track Info")]
        public bool isOnTrack;
        public Track track;
        public SplinePositioner trackPositioner;
        
        [Title("Audio")]
        public AudioContainer audioContainer;

        [Title("NoteVisual")]
        public NoteVisualBase noteVisual;

        [Title("Submodules")]
        public TimeDurationSubmodule timeDurationSubmodule { get; set; }
        public NoteJudgeSubmodule noteJudgeSubmodule { get; set; }
        public NoteAudioSubmodule noteAudioSubmodule { get; set; }

        [Title("In-Game Info")] 
        public bool isDuringJudging;
        public Vector2 noteScreenPosition; 
        public bool isFirstJudged;
        public bool isFinalJudged;
        public override int HierarchyPriority => -10;

        [Title("Debug")] public TMP_Text judgeRankHint;

        /// <summary>
        /// 在MovableTrack上更新Note的位置，注意HoldNote需要重写这个方法
        /// </summary>
        public virtual void UpdateNoteInMovableTrack()
        {
            TrackTimeSubmoduleMovable trackTimeSubmoduleMovable = track.trackTimeSubmodule as TrackTimeSubmoduleMovable;
            trackPositioner.SetPercent(trackTimeSubmoduleMovable.GetTrackPercent(exactJudgeTime));
        }

        /// <summary>
        /// 在StaticTrack上更新Note的位置，注意HoldNote需要重写这个方法
        /// </summary>
        public virtual void UpdateNoteInStaticTrack()
        {
            float songTime = GameManager.instance.songTime;
            TrackTimeSubmoduleStatic trackTimeSubmoduleStatic = track.trackTimeSubmodule as TrackTimeSubmoduleStatic;

            float startMove = exactJudgeTime - trackTimeSubmoduleStatic.trackTotalTime;
            float percent = AnimationCurveEvaluator.Evaluate(trackTimeSubmoduleStatic.animationCurveType, (songTime - startMove) / trackTimeSubmoduleStatic.trackTotalTime);

            percent = Mathf.Max(percent, 0);
            percent = Mathf.Min(percent, 1);

            trackPositioner.SetPercent(1 - percent);
        }

        public override void SetDefaultSubmodules()
        {
            timeDurationSubmodule = new TimeDurationSubmodule(this);
            noteJudgeSubmodule = new NoteJudgeSubmodule(this);
        }

        public override void AfterInitialize()
        {
            float beyondTime = 0f;
            
            foreach (NoteGenerateEffect ge in noteVisual.effectSubmodule.effectCollection["Generate"].Cast<NoteGenerateEffect>())
            {
                ge.Recover();
                beyondTime = Mathf.Max(beyondTime, ge.generateTime);
            }
            
            if (exactJudgeTime - beyondTime - 0.5f > -GameManager.instance.songInformation.delay)
            {
                gameObject.SetActive(false);
                GameManager.instance.noteManager.RegisterNote(this, exactJudgeTime - beyondTime - 0.5f);
            }
            
            //judgeRankHint = Instantiate(GameManager.instance.basePrefabs.judgeRankHint, noteVisual.transform).GetComponent<TMP_Text>();
        }

        protected virtual void Update()
        {
            if (!GameManager.instance.audioManager.isUpdating || isFinalJudged)
            {
                return;
            }
            
            if (isOnTrack)
            {
                if (track.trackTimeSubmodule is TrackTimeSubmoduleStatic)
                {
                    UpdateNoteInStaticTrack();
                }
            }

            if (isDuringJudging)
            {
                noteScreenPosition = GameManager.instance.cameraManager.gameCamera.gameCamera.WorldToScreenPoint(noteVisual.transform.position);
            }

            SetJudgeArea();

            //SetJudgeRankText();

            foreach (EffectBase e in noteVisual.effectSubmodule.effectCollection["Generate"])
            {
                e.UpdateEffect(exactJudgeTime);
            }

            if (!isFirstJudged && GameManager.instance.songTime > exactJudgeTime + judgeIntervals.afterMiss)
            {
                Miss(exactJudgeTime + judgeIntervals.afterMiss);
                isFirstJudged = true;
                isFinalJudged = true;
                RemoveFromCheckingList();
            }
        }

        protected virtual NoteJudgeType GetStartJudgeType(float timeDifference)
        {
            return judgeIntervals.GetNoteJudgeType(timeDifference);
        }

        protected virtual void RemoveFromCheckingList()
        {
            throw new NotImplementedException();
        }

        public virtual void ExecuteStartJudge()
        {
            float triggerTime = GameManager.instance.songTime;
            float timeDifference = triggerTime - exactJudgeTime;
            
            NoteJudgeType startJudgeType = GetStartJudgeType(timeDifference);
            if (startJudgeType == NoteJudgeType.Perfect)
            {
                Perfect(triggerTime);
            }
            else if (startJudgeType == NoteJudgeType.Good)
            {
                Good(triggerTime);
            }
            else if (startJudgeType == NoteJudgeType.Bad)
            {
                Bad(triggerTime);
            }
            else if (startJudgeType == NoteJudgeType.Miss)
            {
                Miss(triggerTime);
            }
            
            if (startJudgeType != NoteJudgeType.Miss)
            {
                noteAudioSubmodule.PlayGeneralJudgeAudios();
            }
            
            isFirstJudged = true;
        }

        public void UpdateNoteInTrack()
        {
            if (isOnTrack && track.trackTimeSubmodule != null)
            {
                if (track.trackTimeSubmodule is TrackTimeSubmoduleMovable)
                {
                    UpdateNoteInMovableTrack();
                }
                else if (track.trackTimeSubmodule is TrackTimeSubmoduleStatic)
                {
                    UpdateNoteInStaticTrack();
                }
            }
        }

        public virtual void Perfect(float triggerTime)
        {
            isDuringJudging = false;
            GameManager.instance.playingRecorder.AddPerfect();
            noteAudioSubmodule.PlayNoteJudgeAudios(NoteJudgeType.Perfect);
            Observable.EveryUpdate().Subscribe(_ =>
            {
                noteVisual.effectSubmodule.effectCollection["GeneralJudge"].ForEach(e => e.UpdateEffect(triggerTime));
                noteVisual.effectSubmodule.effectCollection["Perfect"].ForEach(e => e.UpdateEffect(triggerTime));
                noteVisual.effectSubmodule.effectCollection["AfterJudge"].ForEach(e => e.UpdateEffect(exactJudgeTime));
            }).AddTo(gameObject);

            if (isOnTrack) track.childElementList.Remove(this);
            
            foreach (NoteJudgeUnit unit in noteJudgeSubmodule.judgeUnitList.Where(unit => unit.isShowingJudge))
            {
                unit.SetShowingJudge(false);
            }
            
            Destroy(gameObject, 1.2f); //注意所有特效时间不得超过1.2秒
        }

        public virtual void Good(float triggerTime)
        {
            isDuringJudging = false;
            GameManager.instance.playingRecorder.AddGood();
            noteAudioSubmodule.PlayNoteJudgeAudios(NoteJudgeType.Good);
            Observable.EveryUpdate().Subscribe(_ =>
            {
                noteVisual.effectSubmodule.effectCollection["GeneralJudge"].ForEach(e => e.UpdateEffect(triggerTime));
                noteVisual.effectSubmodule.effectCollection["Good"].ForEach(e => e.UpdateEffect(triggerTime));
                noteVisual.effectSubmodule.effectCollection["AfterJudge"].ForEach(e => e.UpdateEffect(exactJudgeTime));
            }).AddTo(gameObject);
            
            if (isOnTrack) track.childElementList.Remove(this);
            
            foreach (NoteJudgeUnit unit in noteJudgeSubmodule.judgeUnitList.Where(unit => unit.isShowingJudge))
            {
                unit.SetShowingJudge(false);
            }
            
            Destroy(gameObject, 1.2f);
        }
        public virtual void Bad(float triggerTime){
        {
            isDuringJudging = false;
            GameManager.instance.playingRecorder.AddBad();
            noteAudioSubmodule.PlayNoteJudgeAudios(NoteJudgeType.Bad);
            Observable.EveryUpdate().Subscribe(_ =>
            {
                noteVisual.effectSubmodule.effectCollection["GeneralJudge"].ForEach(e => e.UpdateEffect(triggerTime));
                noteVisual.effectSubmodule.effectCollection["Bad"].ForEach(e => e.UpdateEffect(triggerTime));
                noteVisual.effectSubmodule.effectCollection["AfterJudge"].ForEach(e => e.UpdateEffect(exactJudgeTime));
            }).AddTo(gameObject);
            
            if (isOnTrack) track.childElementList.Remove(this);
            
            foreach (NoteJudgeUnit unit in noteJudgeSubmodule.judgeUnitList.Where(unit => unit.isShowingJudge))
            {
                unit.SetShowingJudge(false);
            }
            
            Destroy(gameObject, 1.2f);
        }}

        public virtual void Miss(float triggerTime)
        {
            isDuringJudging = false;
            GameManager.instance.playingRecorder.AddMiss();
            noteAudioSubmodule.PlayNoteJudgeAudios(NoteJudgeType.Miss);
            Observable.EveryUpdate().Subscribe(_ =>
            {
                noteVisual.effectSubmodule.effectCollection["Miss"].ForEach(e => e.UpdateEffect(triggerTime));
                noteVisual.effectSubmodule.effectCollection["AfterJudge"].ForEach(e => e.UpdateEffect(exactJudgeTime));
            }).AddTo(gameObject);
            
            if (isOnTrack) track.childElementList.Remove(this);
            
            foreach (NoteJudgeUnit unit in noteJudgeSubmodule.judgeUnitList.Where(unit => unit.isShowingJudge))
            {
                unit.SetShowingJudge(false);
            }
            
            Destroy(gameObject, 1.2f);
        }
    }

    public abstract partial class NoteBase
    {
        protected virtual void SetJudgeArea()
        {
            if (noteJudgeSubmodule != null)
            {
                if (GameManager.instance.songTime > exactJudgeTime - 0.1f && !isFirstJudged)
                {
                    foreach (NoteJudgeUnit unit in noteJudgeSubmodule.judgeUnitList.Where(unit => !unit.isShowingJudge))
                    {
                        unit.SetShowingJudge(true);
                    }
                }

                foreach (NoteJudgeUnit unit in noteJudgeSubmodule.judgeUnitList.Where(unit => unit.isShowingJudge))
                {
                    unit.UpdateJudge();
                }

                if (GameManager.instance.songTime > exactJudgeTime + 0.1f)
                {
                    foreach (NoteJudgeUnit unit in noteJudgeSubmodule.judgeUnitList.Where(unit => unit.isShowingJudge))
                    {
                        unit.SetShowingJudge(false);
                    }
                }
            }
        }
        
        public int CompareTo(NoteBase other)
        {
            return exactJudgeTime.CompareTo(other.exactJudgeTime);
        }

        private void SetJudgeRankText()
        {
            float triggerTime = GameManager.instance.songTime;
            float timeDifference = triggerTime - exactJudgeTime;
            
            NoteJudgeType startJudgeType = GetStartJudgeType(timeDifference);
            if (startJudgeType == NoteJudgeType.Perfect)
            {
                judgeRankHint.text = "PERFECT";
                judgeRankHint.color = Color.cyan;
            }
            else if (startJudgeType == NoteJudgeType.Good)
            {
                judgeRankHint.text = "GOOD";
                judgeRankHint.color = Color.green;
            }
            else if (startJudgeType == NoteJudgeType.Bad)
            {
                judgeRankHint.text = "BAD";
                judgeRankHint.color = Color.magenta;
            }
            else if (startJudgeType == NoteJudgeType.Miss)
            {
                judgeRankHint.text = "MISS";
                judgeRankHint.color = Color.white;
            }
        }
    }

    public abstract partial class NoteBase
    {
        public enum NoteJudgeType
        {
            Perfect = 0,
            Good = 1,
            Bad = 2,
            Miss = 3,
            NotJudged = -999
        }

        public static NoteJudgeType GetLowerType(NoteJudgeType typeA, NoteJudgeType typeB)
        {
            if (typeA == NoteJudgeType.NotJudged) return typeB;
            if (typeB == NoteJudgeType.NotJudged) return typeA;

            return typeA > typeB ? typeA : typeB;
        }
        
        
        public class NoteJudgeIntervals
        {
            public TimeInterval beforeMiss;
            public TimeInterval beforeBad;
            public TimeInterval beforeGood;
            public TimeInterval perfect;
            public TimeInterval afterGood;
            public TimeInterval afterBad;
            public float afterMiss;
            
            public NoteJudgeIntervals(TimeInterval beforeMiss, TimeInterval beforeBad, TimeInterval beforeGood, 
                TimeInterval perfect, TimeInterval afterGood, TimeInterval afterBad, float afterMiss)
            {
                this.beforeMiss = beforeMiss;
                this.beforeBad = beforeBad;
                this.beforeGood = beforeGood;
                this.perfect = perfect;
                this.afterGood = afterGood;
                this.afterBad = afterBad;
                this.afterMiss = afterMiss;
            }

            public NoteJudgeType GetNoteJudgeType(float timeDifference)
            {
                if (beforeMiss.IsInInterval(timeDifference))
                {
                    return NoteJudgeType.Miss;
                }
                else if (beforeBad.IsInInterval(timeDifference))
                {
                    return NoteJudgeType.Bad;
                }
                else if (beforeGood.IsInInterval(timeDifference))
                {
                    return NoteJudgeType.Good;
                }
                else if (perfect.IsInInterval(timeDifference))
                {
                    return NoteJudgeType.Perfect;
                }
                else if (afterGood.IsInInterval(timeDifference))
                {
                    return NoteJudgeType.Good;
                }
                else if (afterBad.IsInInterval(timeDifference))
                {
                    return NoteJudgeType.Bad;
                }
                
                return NoteJudgeType.Miss; // Default to Miss if no other condition is met
            }
        }
        
        public class TimeInterval
        {
            public float intervalStart;
            public float intervalEnd;
            
            public TimeInterval(float start, float end)
            {
                intervalStart = start;
                intervalEnd = end;
            }
            
            public bool IsInInterval(float time)
            {
                if (Mathf.Approximately(intervalStart, intervalEnd)) return false;
                
                return time >= intervalStart && time <= intervalEnd;
            }
        }

        public static string GetNoteTypeName(NoteBase note)
        {
            return note switch
            {
                Tap => "Tap",
                Stay => "Stay",
                Hold => "Hold",
                Flick => "Flick",
                _ => throw new NotImplementedException("Note type not recognized")
            };
        }

    }

    namespace Beatmap
    {
        public abstract class NoteBase_BM : GameElement_BM
        {
            public float exactJudgeTime;

            public NoteBase_BM()
            {

            }

            public NoteBase_BM(string elementName, Guid elementGuid, List<string> tags, GameElement_BM attachedElement, float exactJudgeTime)
                : base(elementName, elementGuid, tags, attachedElement)
            {
                this.exactJudgeTime = exactJudgeTime;
            }

            public override void ExecuteBM()
            {
                throw new NotImplementedException();
            }

            public override GameElement DuplicateBM(GameElement parent)
            {
                throw new NotImplementedException();
            }
        }
    }
}