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

public class JudgeManager : MonoBehaviour
{
    [Header("settlement go")]
    public GameObject settlement_go;
    public settlementController sc;
    public NoteSpawner ns;

    [Header("Settlement Delay")]
    [SerializeField] private float settlementEnterDelaySeconds = 1.5f;

    private bool _cachedIsDebugEnabled;
    private void UpdateDebugCache()
    {
        _cachedIsDebugEnabled = (_enableDebugLogs || GameConfig.verboseLogs);
    }

    [Header("Debug Settings")]
    [SerializeField] private bool _enableDebugLogs = false;
    public bool EnableDebugLogs => _enableDebugLogs;
    public static bool IsDebugEnabled => (Instance != null && Instance._cachedIsDebugEnabled);

    [Header("Global Note Settings")]
    [Tooltip("Global material applied to hold notes when they are judged.")]
    public Material globalJudgedMaterial;
    [Tooltip("Whether to enable material switching after a hold note is judged.")]
    public bool enableJudgedMaterial = false;

    public static JudgeManager Instance { get; private set; }

    // total/remaining notes tracking for end-of-song detection
    private int totalNotes = 0;
    private int remainingNotes = 0;
    private bool settlementTriggeredThisChart = false;

    // Documentation text normalized.
    private Dictionary<KeyCode, Queue<Note>> judgeQueues = new Dictionary<KeyCode, Queue<Note>>();
    private Dictionary<string, bool> startJudgedNotes = new Dictionary<string, bool>();
    private Dictionary<string, bool> releasedNotes = new Dictionary<string, bool>();
    private Dictionary<string, float> noteEndTimes = new Dictionary<string, float>();
    private Dictionary<string, int> middlePassedCounts = new Dictionary<string, int>();

    // Documentation text normalized.
    private class HoldJudgeState
    {
        public bool startResolved;   // Documentation text normalized.
        public bool endResolved;     // Documentation text normalized.
        public bool skillTriggered;  // Documentation text normalized.
    }

    private Dictionary<string, HoldJudgeState> holdStates = new Dictionary<string, HoldJudgeState>();

    private HoldJudgeState GetHoldState(string noteID)
    {
        if (!holdStates.TryGetValue(noteID, out var state))
        {
            state = new HoldJudgeState();
            holdStates[noteID] = state;
        }
        return state;
    }

    // Public event and hook invoked when the entire beatmap's last note has been judged.
    // The method is intentionally empty so you can override or call it via the singleton.
    public event Action AllNotesJudged;

    /// <summary>
    /// Public empty hook called when all notes have been judged. Implement your end-of-song logic here
    /// or subscribe to the AllNotesJudged event. This method is intentionally left empty.
    /// </summary>
    public void OnAllNotesJudged()
    {
        if (settlementTriggeredThisChart)
        {
            if (IsDebugEnabled) Debug.Log("[JudgeManager] OnAllNotesJudged ignored: settlement already triggered for this chart.");
            return;
        }
        settlementTriggeredThisChart = true;

        if (settlement_go == null)
        {
            if (IsDebugEnabled) Debug.LogError("结算页面不存在！");
            return;
        }

        // Enter settlement after a real-time delay to leave a short idle window after chart end.
        StartCoroutine(InvokeSettlementUpdateNextFrame());
    }

    private IEnumerator InvokeSettlementUpdateNextFrame()
    {
        // Keep settlement lead-in fixed at 1.5s for consistent pacing.
        float delay = 1.5f;
        if (delay > 0f)
        {
            yield return new WaitForSecondsRealtime(delay);
        }

        // Activate settlement UI so components run their lifecycle.
        try
        {
            settlement_go.SetActive(true);
        }
        catch (Exception ex)
        {
            if (IsDebugEnabled) Debug.LogWarning($"[JudgeManager] Failed to activate settlement_go: {ex}");
        }

        // Try to resolve settlementController reference if missing.
        if (sc == null && settlement_go != null)
        {
            sc = settlement_go.GetComponent<settlementController>() ?? settlement_go.GetComponentInChildren<settlementController>(true);
        }

        // Wait one frame to allow Awake/Start/OnEnable.
        yield return null;

        if (sc != null)
        {
            try
            {
                sc.startSettlement_uiUpdate();
            }
            catch (Exception ex)
            {
                if (IsDebugEnabled) Debug.LogWarning($"[JudgeManager] Exception calling startSettlement_uiUpdate: {ex}");
            }
        }
        else
        {
            if (IsDebugEnabled) Debug.LogWarning("[JudgeManager] settlementController (sc) not found on settlement_go; cannot call startSettlement_uiUpdate().");
        }
    }

    /// <summary>
    /// Helper to invoke the AllNotesJudged event and call the public hook.
    /// Call this when you detect the last note was judged.
    /// </summary>
    public void TriggerAllNotesJudged()
    {
        try
        {
            AllNotesJudged?.Invoke();
        }
        catch (Exception ex)
        {
            if (IsDebugEnabled) Debug.LogWarning($"[JudgeManager] Exception while invoking AllNotesJudged event: {ex}");
        }
        try
        {
            OnAllNotesJudged();
        }
        catch (Exception ex)
        {
            if (IsDebugEnabled) Debug.LogWarning($"[JudgeManager] Exception in OnAllNotesJudged hook: {ex}");
        }
    }

    private void Awake()
    {
        if (Instance == null) Instance = this;
        else Destroy(gameObject);

        UpdateDebugCache();
        if (settlement_go != null) settlement_go.SetActive(false);
    }

    /// <summary>
    /// Set the total number of notes in the current beatmap. Remaining notes will be initialized
    /// to this value. Call before playback/spawning starts.
    /// </summary>
    public void SetTotalNotes(int total)
    {
        totalNotes = Mathf.Max(0, total);
        remainingNotes = totalNotes;
        settlementTriggeredThisChart = false;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] SetTotalNotes: total={totalNotes}");
    }

    /// <summary>
    /// Notify that one note has been finally judged (hit or miss). When remaining reaches zero,
    /// TriggerAllNotesJudged will be invoked.
    /// </summary>
    public void NotifyNoteJudged()
    {
        if (remainingNotes <= 0) return;
        remainingNotes = Mathf.Max(0, remainingNotes - 1);
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] NotifyNoteJudged: remaining={remainingNotes}");
        if (remainingNotes == 0)
        {
            if (IsDebugEnabled) Debug.Log("[JudgeManager] All notes judged -> Triggering AllNotesJudged");
            TriggerAllNotesJudged();
        }
    }

    // Documentation text normalized.
    public bool TryResolveStart(string noteID)
    {
        var s = GetHoldState(noteID);
        if (s.startResolved)
        {
            if (IsDebugEnabled) Debug.LogWarning($"[JudgeManager] TryResolveStart: already resolved start for {noteID}");
            return false;
        }
        s.startResolved = true;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] TryResolveStart: start resolved for {noteID} at time={GameplayClock.NowSongTime:F3}");
        return true;
    }

    public bool TryResolveEnd(string noteID)
    {
        var s = GetHoldState(noteID);
        if (s.endResolved)
        {
            if (IsDebugEnabled) Debug.LogWarning($"[JudgeManager] TryResolveEnd: already resolved end for {noteID}");
            return false;
        }
        s.endResolved = true;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] TryResolveEnd: end resolved for {noteID} at time={GameplayClock.NowSongTime:F3}");
        return true;
    }

    public bool TryTriggerSkill(string noteID)
    {
        var s = GetHoldState(noteID);
        if (s.skillTriggered)
        {
            if (IsDebugEnabled) Debug.LogWarning($"[JudgeManager] TryTriggerSkill: already triggered for {noteID}");
            return false;
        }
        s.skillTriggered = true;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] TryTriggerSkill: skill triggered for {noteID} at time={GameplayClock.NowSongTime:F3}");
        return true;
    }

    public void ClearHoldState(string noteID)
    {
        if (holdStates.ContainsKey(noteID))
        {
            holdStates.Remove(noteID);
            if (IsDebugEnabled) Debug.Log($"[JudgeManager] ClearHoldState: cleared state for {noteID}");
        }
    }

    // Documentation text normalized.

    public void RegisterScheduledEndTime(string noteID, float endTime)
    {
        noteEndTimes[noteID] = endTime;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] RegisterScheduledEndTime: {noteID} -> {endTime:F3}");
    }

    public float GetScheduledEndTime(string noteID)
    {
        return noteEndTimes.TryGetValue(noteID, out var endTime) ? endTime : 0f;
    }

    public void RegisterStartJudged(string noteID, bool state)
    {
        startJudgedNotes[noteID] = state;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] RegisterStartJudged: {noteID} = {state} at time={GameplayClock.NowSongTime:F3}");
    }

    public bool IsStartJudged(string noteID)
    {
        return startJudgedNotes.TryGetValue(noteID, out var state) && state;
    }

    public void RegisterNoteReleased(string noteID, bool state)
    {
        releasedNotes[noteID] = state;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] RegisterNoteReleased: {noteID} = {state}");
    }

    public bool HasNoteReleased(string noteID)
    {
        return releasedNotes.TryGetValue(noteID, out var state) && state;
    }

    public void RegisterNote(KeyCode key, Note note)
    {
        if (!judgeQueues.ContainsKey(key))
            judgeQueues[key] = new Queue<Note>();

        if (!judgeQueues[key].Contains(note))
            judgeQueues[key].Enqueue(note);
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] RegisterNote: key={key} note={note.name} time={GameplayClock.NowSongTime:F3} queueSize={judgeQueues[key].Count}");
    }

    public void UnregisterNote(KeyCode key, Note note)
    {
        if (!judgeQueues.ContainsKey(key)) return;

        Queue<Note> newQueue = new Queue<Note>();
        while (judgeQueues[key].Count > 0)
        {
            Note n = judgeQueues[key].Dequeue();
            if (n != note)
                newQueue.Enqueue(n);
            else if (!n.IsJudged())
                n.JudgeMiss();
        }
        judgeQueues[key] = newQueue;
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] UnregisterNote: key={key} removed {note.name}, newQueueSize={judgeQueues[key].Count}");
    }

    public void JudgeEarliestNote(KeyCode key)
    {
        if (judgeQueues.ContainsKey(key) && judgeQueues[key].Count > 0)
        {
            Note note = judgeQueues[key].Dequeue();
            if (note != null && !note.IsJudged())
            {
                if (IsDebugEnabled) Debug.Log($"[JudgeManager] JudgeEarliestNote: judging {note.name} for key={key} at time={GameplayClock.NowSongTime:F3}");
                note.Judge();
            }
        }
    }

    public void RegisterMiddlePassed(string noteID)
    {
        if (middlePassedCounts.TryGetValue(noteID, out int count))
        {
            middlePassedCounts[noteID] = count + 1;
        }
        else
        {
            middlePassedCounts[noteID] = 1;
        }
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] Middle passed for {noteID}, total={middlePassedCounts[noteID]}");
    }

    // Event for syncing alpha across segments of a hold note
    public event Action<string, float> OnHoldAlphaSync;

    public void SyncHoldAlpha(string noteID, float alpha)
    {
        OnHoldAlphaSync?.Invoke(noteID, alpha);
    }

    public int GetMiddlePassedCount(string noteID)
    {
        return middlePassedCounts.TryGetValue(noteID, out var count) ? count : 0;
    }

    public void ClearNoteRecord(string noteID)
    {
        startJudgedNotes.Remove(noteID);
        releasedNotes.Remove(noteID);
        noteEndTimes.Remove(noteID);
        middlePassedCounts.Remove(noteID);
        ClearHoldState(noteID);
        if (IsDebugEnabled) Debug.Log($"[JudgeManager] ClearNoteRecord: cleared records for {noteID}");
    }
}