using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Ichni.RhythmGame;
using Sirenix.OdinInspector;
using UnityEngine;

namespace Ichni
{
    public partial class NoteJudgeManager : SerializedMonoBehaviour
    {
        public List<Tap> checkingTapList;
        public List<Stay> checkingStayList;
        public List<Hold> checkingHoldList;
        public List<Flick> checkingFlickList;
        
        public List<InputUnitTap> inputUnitTapList;
        public List<InputUnitTouch> inputUnitTouchList;
        public List<InputUnitSwipe> inputUnitSwipeList;

        private void Start()
        {
            checkingTapList = new List<Tap>();
            checkingStayList = new List<Stay>();
            checkingHoldList = new List<Hold>();
            checkingFlickList = new List<Flick>();
            inputUnitTapList = new List<InputUnitTap>();
            inputUnitTouchList = new List<InputUnitTouch>();
            inputUnitSwipeList = new List<InputUnitSwipe>();
        }

        public void Update()
        {
            if (!GameManager.instance.audioManager.isPlaying)
            {
                return;
            }
            
            foreach (InputUnitTap inputUnitTap in inputUnitTapList)
            {
                List<Tap> availableTaps = new List<Tap>();
                foreach (Tap tap in checkingTapList)
                {
                    if (tap.CheckJudgeAvailability(inputUnitTap))
                    {
                        availableTaps.Add(tap);
                    }
                }
                
                List<Hold> availableHolds = new List<Hold>();
                foreach (Hold hold in checkingHoldList)
                {
                    if (hold.CheckJudgeAvailability(inputUnitTap))
                    {
                        availableHolds.Add(hold);
                    }
                }
                
                bool haveTap = availableTaps.Count > 0;
                bool haveHold = availableHolds.Count > 0;
                
                if (haveHold && haveTap)
                {
                    List<Hold> minHolds = GetAllMinHolds(availableHolds);
                    List<Tap> minTaps = GetAllMinTaps(availableTaps);
                    Hold closestHold = minHolds[0];
                    Tap closestTap = minTaps[0];
                    if (closestHold.exactJudgeTime < closestTap.exactJudgeTime)
                    {
                        if (minHolds.Count == 1)
                        {
                            minHolds[0].ExecuteStartJudge();
                        }
                        else
                        {
                            GetNearestHold(minHolds, inputUnitTap.inputPosition).ExecuteStartJudge();
                        }
                    }
                    else
                    {
                        if (minTaps.Count == 1)
                        {
                            minTaps[0].ExecuteStartJudge();
                        }
                        else
                        {
                            GetNearestTap(minTaps, inputUnitTap.inputPosition).ExecuteStartJudge();
                        }
                    }
                }
                else if (haveHold)
                {
                    List<Hold> minHolds = GetAllMinHolds(availableHolds);
                    if (minHolds.Count == 1)
                    {
                        minHolds[0].ExecuteStartJudge();
                    }
                    else
                    {
                        GetNearestHold(minHolds, inputUnitTap.inputPosition).ExecuteStartJudge();
                    }
                }
                else if (haveTap)
                {
                    List<Tap> minTaps = GetAllMinTaps(availableTaps);
                    if (minTaps.Count == 1)
                    {
                        minTaps[0].ExecuteStartJudge();
                    }
                    else
                    {
                        GetNearestTap(minTaps, inputUnitTap.inputPosition).ExecuteStartJudge();
                    }
                }
            }

            foreach (InputUnitSwipe inputUnitSwipe in inputUnitSwipeList)
            {
                List<Flick> availableFlicks = new List<Flick>();

                foreach (Flick flick in checkingFlickList)
                {
                    if (flick.CheckJudgeAvailability(inputUnitSwipe))
                    {
                        availableFlicks.Add(flick);
                    }
                }

                if (availableFlicks.Count > 0)
                {
                    availableFlicks.Sort();
                    Flick closestFlick = availableFlicks[0];
                    closestFlick.ExecuteStartJudge();
                }
            }

            foreach (InputUnitTouch inputUnitTouch in inputUnitTouchList)
            {
                List<Stay> availableStays = new List<Stay>();
                foreach (Stay stay in checkingStayList)
                {
                    if (stay.CheckJudgeAvailability(inputUnitTouch))
                    {
                        availableStays.Add(stay);
                    }
                }
                
                List<Hold> availableHolds = new List<Hold>();
                foreach (Hold hold in checkingHoldList)
                {
                    if (hold.CheckJudgeAvailability(inputUnitTouch))
                    {
                        availableHolds.Add(hold);
                    }
                }

                foreach (Stay stay in availableStays)
                {
                    stay.ExecuteStartJudge();
                }
                
                foreach (Hold hold in availableHolds)
                {
                    hold.ExecuteProcessJudge();
                }
            }
            
            inputUnitTapList.Clear();
            inputUnitTouchList.Clear();
            inputUnitSwipeList.Clear();
        }
        
        public void SetNewInputUnitTap(int fingerId, Vector2 inputPosition)
        {
            InputUnitTap inputUnitTap = new InputUnitTap(fingerId, inputPosition);
            if(!inputUnitTapList.Exists(x => x.fingerId == fingerId))
            {
                inputUnitTapList.Add(inputUnitTap);
            }
        }
        
        public void SetNewInputUnitTouch(int fingerId, Vector2 inputPosition)
        {
            InputUnitTouch inputUnitTouch = new InputUnitTouch(fingerId, inputPosition);
            if(!inputUnitTouchList.Exists(x => x.fingerId == fingerId))
            {
                inputUnitTouchList.Add(inputUnitTouch);
            }
        }
        
        public void SetNewInputUnitSwipe(int fingerId, Vector2 inputPosition, bool isGeneric, bool isFirst, Vector2 delta)
        {
            InputUnitSwipe inputUnitSwipe = new InputUnitSwipe(fingerId, inputPosition, isGeneric, isFirst, delta);
            if(!inputUnitSwipeList.Exists(x => x.fingerId == fingerId))
            {
                inputUnitSwipeList.Add(inputUnitSwipe);
            }
        }
    }

    public partial class NoteJudgeManager
    {
        private List<Tap> GetAllMinTaps(List<Tap> availableTaps)
        {
            List<Tap> minTaps = new List<Tap>();
            float minTime = float.MaxValue;
            foreach (Tap tap in availableTaps)
            {
                if (tap.exactJudgeTime < minTime)
                {
                    minTime = tap.exactJudgeTime;
                    minTaps.Clear();
                    minTaps.Add(tap);
                }
                else if (Mathf.Approximately(tap.exactJudgeTime, minTime))
                {
                    minTaps.Add(tap);
                }
            }
            
            return minTaps;
        }
        
        private List<Hold> GetAllMinHolds(List<Hold> availableHolds)
        {
            List<Hold> minHolds = new List<Hold>();
            float minTime = float.MaxValue;
            foreach (Hold hold in availableHolds)
            {
                if (hold.exactJudgeTime < minTime)
                {
                    minTime = hold.exactJudgeTime;
                    minHolds.Clear();
                    minHolds.Add(hold);
                }
                else if (Mathf.Approximately(hold.exactJudgeTime, minTime))
                {
                    minHolds.Add(hold);
                }
            }
            return minHolds;
        }

        private Tap GetNearestTap(List<Tap> notes, Vector2 inputPosition)
        {
            float minDistance = float.MaxValue;
            Tap closestNote = null;
            foreach (Tap note in notes)
            {
                float distance = Vector2.Distance(inputPosition, note.noteScreenPosition);
                if (distance < minDistance)
                {
                    minDistance = distance;
                    closestNote = note;
                }
            }

            return closestNote;
        }
        
        private Hold GetNearestHold(List<Hold> notes, Vector2 inputPosition)
        {
            float minDistance = float.MaxValue;
            Hold closestNote = null;
            foreach (Hold note in notes)
            {
                float distance = Vector2.Distance(inputPosition, note.noteScreenPosition);
                if (distance < minDistance)
                {
                    minDistance = distance;
                    closestNote = note;
                }
            }

            return closestNote;
        }
    }
    
    public class InputUnit
    {
        public int fingerId;
        public Vector2 inputPosition;
    }
    
    public class InputUnitTap : InputUnit
    {
        public InputUnitTap(int fingerId, Vector2 inputPosition)
        {
            this.fingerId = fingerId;
            this.inputPosition = inputPosition;
        }
    }
    
    public class InputUnitTouch : InputUnit
    {
        public InputUnitTouch(int fingerId, Vector2 inputPosition)
        {
            this.fingerId = fingerId;
            this.inputPosition = inputPosition;
        }
    }
    
    public class InputUnitSwipe : InputUnit
    {
        public Vector2 swipeDirection;
        public bool isGeneric;
        public bool isFirst;
        public InputUnitSwipe(int fingerId, Vector2 inputPosition, bool isGeneric, bool isFirst, Vector2 swipeDirection)
        {
            this.fingerId = fingerId;
            this.inputPosition = inputPosition;
            this.isGeneric = isGeneric;
            this.isFirst = isFirst;
            this.swipeDirection = swipeDirection.normalized;
        }
    }
}