AppleHillsProduction/Assets/Scripts/PuzzleS/PuzzleManager.cs

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

namespace PuzzleS
{
    /// <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;

        /// <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;
            }
        }

        // Events to notify about step lifecycle
        public event Action<PuzzleStepSO> OnStepCompleted;
        public event Action<PuzzleStepSO> OnStepUnlocked;

        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 MarkPuzzleStepCompleted(PuzzleStepSO step)
        {
            if (_completedSteps.Contains(step)) return;
            _completedSteps.Add(step);
            Debug.Log($"[Puzzles] Step completed: {step.stepId}");

            // Broadcast completion
            OnStepCompleted?.Invoke(step);

            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}");

            // Broadcast unlock
            OnStepUnlocked?.Invoke(step);
        }

        /// <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)
        {
            BuildRuntimeDependencies();
            UnlockInitialSteps();
            return _unlockedSteps.Contains(step);
        }

        /// <summary>
        /// Checks if a puzzle step with the specified ID has been completed
        /// </summary>
        /// <param name="stepId">The ID of the puzzle step to check</param>
        /// <returns>True if the step has been completed, false otherwise</returns>
        public bool IsPuzzleStepCompleted(string stepId)
        {
            return _completedSteps.Any(step => step.stepId == stepId);
        }

        void OnApplicationQuit()
        {
            _isQuitting = true;
        }
    }
}