using UnityEngine;
using System.Collections.Generic;
using PuzzleS;
using UnityEngine.SceneManagement;

/// <summary>
/// Manages puzzle step registration, dependency management, and step completion for the puzzle system.
/// </summary>
public class PuzzleManager : MonoBehaviour
{
    private static PuzzleManager _instance;
    private static bool _isQuitting = false;

    /// <summary>
    /// Singleton instance of the PuzzleManager.
    /// </summary>
    public static PuzzleManager Instance
    {
        get
        {
            if (_instance == null && Application.isPlaying && !_isQuitting)
            {
                _instance = FindAnyObjectByType<PuzzleManager>();
                if (_instance == null)
                {
                    var go = new GameObject("PuzzleManager");
                    _instance = go.AddComponent<PuzzleManager>();
                    // DontDestroyOnLoad(go);
                }
            }
            return _instance;
        }
    }

    private HashSet<PuzzleStepSO> completedSteps = new HashSet<PuzzleStepSO>();
    private HashSet<PuzzleStepSO> unlockedSteps = new HashSet<PuzzleStepSO>();

    // Registration for ObjectiveStepBehaviour
    private Dictionary<PuzzleStepSO, ObjectiveStepBehaviour> stepBehaviours = new Dictionary<PuzzleStepSO, ObjectiveStepBehaviour>();

    // Runtime dependency graph
    private Dictionary<PuzzleStepSO, List<PuzzleStepSO>> runtimeDependencies = new Dictionary<PuzzleStepSO, List<PuzzleStepSO>>();

    void Awake()
    {
        _instance = this;
        // DontDestroyOnLoad(gameObject);
        SceneManager.sceneLoaded += OnSceneLoaded;
    }

    void OnDestroy()
    {
        SceneManager.sceneLoaded -= OnSceneLoaded;
    }

    private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
    {
        BuildRuntimeDependencies();
        UnlockInitialSteps();
    }

    /// <summary>
    /// Registers a step behaviour with the manager.
    /// </summary>
    /// <param name="behaviour">The step behaviour to register.</param>
    public void RegisterStepBehaviour(ObjectiveStepBehaviour behaviour)
    {
        if (behaviour?.stepData == null) return;
        if (!stepBehaviours.ContainsKey(behaviour.stepData))
        {
            stepBehaviours.Add(behaviour.stepData, behaviour);
            Debug.Log($"[Puzzles] Registered step: {behaviour.stepData.stepId} on {behaviour.gameObject.name}");
        }
    }

    /// <summary>
    /// Unregisters a step behaviour from the manager.
    /// </summary>
    /// <param name="behaviour">The step behaviour to unregister.</param>
    public void UnregisterStepBehaviour(ObjectiveStepBehaviour behaviour)
    {
        if (behaviour?.stepData == null) return;
        stepBehaviours.Remove(behaviour.stepData);
        Debug.Log($"[Puzzles] Unregistered step: {behaviour.stepData.stepId} on {behaviour.gameObject.name}");
    }

    /// <summary>
    /// Builds the runtime dependency graph for all registered steps.
    /// </summary>
    private void BuildRuntimeDependencies()
    {
        runtimeDependencies = PuzzleGraphUtility.BuildDependencyGraph(stepBehaviours.Keys);
        foreach (var step in runtimeDependencies.Keys)
        {
            foreach (var dep in runtimeDependencies[step])
            {
                Debug.Log($"[Puzzles] Step {step.stepId} depends on {dep.stepId}");
            }
        }
        Debug.Log($"[Puzzles] Runtime dependencies built. Total steps: {stepBehaviours.Count}");
    }

    /// <summary>
    /// Unlocks all initial steps (those with no dependencies).
    /// </summary>
    private void UnlockInitialSteps()
    {
        var initialSteps = PuzzleGraphUtility.FindInitialSteps(runtimeDependencies);
        foreach (var step in initialSteps)
        {
            Debug.Log($"[Puzzles] Initial step unlocked: {step.stepId}");
            UnlockStep(step);
        }
    }

    /// <summary>
    /// Called when a step is completed. Unlocks dependent steps if their dependencies are met.
    /// </summary>
    /// <param name="step">The completed step.</param>
    public void OnStepCompleted(PuzzleStepSO step)
    {
        if (completedSteps.Contains(step)) return;
        completedSteps.Add(step);
        Debug.Log($"[Puzzles] Step completed: {step.stepId}");
        foreach (var unlock in step.unlocks)
        {
            if (AreRuntimeDependenciesMet(unlock))
            {
                Debug.Log($"[Puzzles] Unlocking step {unlock.stepId} after completing {step.stepId}");
                UnlockStep(unlock);
            }
            else
            {
                Debug.Log($"[Puzzles] Step {unlock.stepId} not unlocked yet, waiting for other dependencies");
            }
        }
        CheckPuzzleCompletion();
    }

    /// <summary>
    /// Checks if all dependencies for a step are met.
    /// </summary>
    /// <param name="step">The step to check.</param>
    /// <returns>True if all dependencies are met, false otherwise.</returns>
    private bool AreRuntimeDependenciesMet(PuzzleStepSO step)
    {
        if (!runtimeDependencies.ContainsKey(step) || runtimeDependencies[step].Count == 0) return true;
        foreach (var dep in runtimeDependencies[step])
        {
            if (!completedSteps.Contains(dep)) return false;
        }
        return true;
    }

    /// <summary>
    /// Unlocks a specific step and notifies its behaviour.
    /// </summary>
    /// <param name="step">The step to unlock.</param>
    private void UnlockStep(PuzzleStepSO step)
    {
        if (unlockedSteps.Contains(step)) return;
        unlockedSteps.Add(step);
        if (stepBehaviours.TryGetValue(step, out var behaviour))
        {
            behaviour.UnlockStep();
        }
        Debug.Log($"[Puzzles] Step unlocked: {step.stepId}");
    }

    /// <summary>
    /// Checks if the puzzle is complete (all steps finished).
    /// </summary>
    private void CheckPuzzleCompletion()
    {
        if (completedSteps.Count == stepBehaviours.Count)
        {
            Debug.Log("[Puzzles] Puzzle complete! All steps finished.");
            // TODO: Fire puzzle complete event or trigger outcome logic
        }
    }

    /// <summary>
    /// Returns whether a step is already unlocked.
    /// </summary>
    public bool IsStepUnlocked(PuzzleStepSO step)
    {
        return unlockedSteps.Contains(step);
    }

    void OnApplicationQuit()
    {
        _isQuitting = true;
    }
}