Particle Effects

using System;
using System.Collections.Generic;
using UnityEngine;
using InfiniteRunner.Core;

namespace InfiniteRunner.VFX
{
    /// <summary>
    /// Manages all particle effects in the game.
    /// Pools particle system instances to avoid garbage collection spikes.
    /// Access via ParticleManager.Instance.
    /// </summary>
    public class ParticleManager : Singleton<ParticleManager>
    {
        // ─── Inspector Fields ──────────────────────────────────
        [Header("Particle Prefabs")]
        [Tooltip("Burst of gold sparkles when collecting a coin.")]
        [SerializeField] private ParticleSystem coinCollectPrefab;

        [Tooltip("Explosion of debris when the player crashes.")]
        [SerializeField] private ParticleSystem crashPrefab;

        [Tooltip("Stretched speed lines attached to the camera.")]
        [SerializeField] private ParticleSystem speedLinesPrefab;

        [Header("Pool Settings")]
        [Tooltip("How many of each effect to pre-create.")]
        [SerializeField] private int poolSizePerEffect = 5;

        // ─── Private Fields ────────────────────────────────────
        // Each effect type has its own pool (a queue of inactive instances)
        private Dictionary<string, Queue<ParticleSystem>> _pools;

        // Reference to the active speed lines instance (only one at a time)
        private ParticleSystem _activeSpeedLines;

        // Parent transform to keep the Hierarchy tidy
        private Transform _poolParent;

        // ─── Unity Lifecycle ────────────────────────────────────

        protected override void Awake()
        {
            base.Awake();
            InitializePools();
        }

        // ─── Pool Initialization ────────────────────────────────

        /// <summary>
        /// Creates pools for each particle prefab.
        /// Pre-instantiates instances so they are ready to use at runtime.
        /// </summary>
        private void InitializePools()
        {
            _pools = new Dictionary<string, Queue<ParticleSystem>>();

            // Create a parent object to keep pooled particles organized
            _poolParent = new GameObject("[ParticlePools]").transform;
            _poolParent.SetParent(transform);

            // Create pools for each effect type
            if (coinCollectPrefab != null)
            {
                CreatePool(coinCollectPrefab, poolSizePerEffect);
            }

            if (crashPrefab != null)
            {
                CreatePool(crashPrefab, poolSizePerEffect);
            }

            // Speed lines are a single persistent instance, not pooled
            if (speedLinesPrefab != null)
            {
                _activeSpeedLines = Instantiate(speedLinesPrefab, _poolParent);
                _activeSpeedLines.gameObject.SetActive(false);
            }
        }

        /// <summary>
        /// Creates a pool of inactive particle system instances for a given prefab.
        /// </summary>
        /// <param name="prefab">The particle system prefab to pool.</param>
        /// <param name="count">How many instances to pre-create.</param>
        private void CreatePool(ParticleSystem prefab, int count)
        {
            string key = prefab.name;
            _pools[key] = new Queue<ParticleSystem>();

            // Create a sub-parent for this effect type
            Transform subParent = new GameObject($"Pool_{key}").transform;
            subParent.SetParent(_poolParent);

            for (int i = 0; i < count; i++)
            {
                ParticleSystem instance = Instantiate(prefab, subParent);
                instance.gameObject.SetActive(false);
                _pools[key].Enqueue(instance);
            }
        }

        // ─── Pool Retrieval ─────────────────────────────────────

        /// <summary>
        /// Gets an inactive particle system from the pool.
        /// If the pool is empty, creates a new instance (grows the pool).
        /// </summary>
        /// <param name="prefab">The prefab to get an instance of.</param>
        /// <returns>A ready-to-use ParticleSystem instance.</returns>
        private ParticleSystem GetFromPool(ParticleSystem prefab)
        {
            string key = prefab.name;

            // If the pool does not exist yet, create it
            if (!_pools.ContainsKey(key))
            {
                CreatePool(prefab, poolSizePerEffect);
            }

            Queue<ParticleSystem> pool = _pools[key];

            // Try to find an inactive instance in the pool
            // If all are in use, create a new one (pool growth)
            ParticleSystem instance;

            if (pool.Count > 0)
            {
                instance = pool.Dequeue();
            }
            else
            {
                // Pool is exhausted — grow it by creating a new instance
                Debug.LogWarning(
                    $"[ParticleManager] Pool for '{key}' exhausted. " +
                    "Creating new instance. Consider increasing pool size.");
                instance = Instantiate(prefab, _poolParent);
            }

            return instance;
        }

        /// <summary>
        /// Returns a particle system instance to its pool after it finishes playing.
        /// Called automatically by our coroutine.
        /// </summary>
        /// <param name="prefab">The original prefab (used as pool key).</param>
        /// <param name="instance">The instance to return.</param>
        private void ReturnToPool(ParticleSystem prefab, ParticleSystem instance)
        {
            string key = prefab.name;

            instance.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
            instance.gameObject.SetActive(false);

            if (_pools.ContainsKey(key))
            {
                _pools[key].Enqueue(instance);
            }
        }

        // ─── Play Methods (call these from gameplay scripts) ────

        /// <summary>
        /// Plays the coin collect effect at the specified world position.
        /// Call this from your coin/collectible script when collected.
        /// </summary>
        /// <param name="position">World position where the coin was collected.</param>
        public void PlayCoinCollect(Vector3 position)
        {
            if (coinCollectPrefab == null)
            {
                Debug.LogWarning("[ParticleManager] Coin collect prefab not assigned!");
                return;
            }

            PlayEffectAtPosition(coinCollectPrefab, position);
        }

        /// <summary>
        /// Plays the crash/death effect at the specified world position.
        /// Call this when the player hits an obstacle.
        /// </summary>
        /// <param name="position">World position where the crash occurred.</param>
        public void PlayCrash(Vector3 position)
        {
            if (crashPrefab == null)
            {
                Debug.LogWarning("[ParticleManager] Crash prefab not assigned!");
                return;
            }

            PlayEffectAtPosition(crashPrefab, position);
        }

        /// <summary>
        /// Starts or updates the speed lines effect.
        /// Call this with the current player speed to modulate intensity.
        /// Pass 0 or call StopSpeedLines() to turn them off.
        /// </summary>
        /// <param name="normalizedSpeed">
        /// Speed value from 0 (stopped) to 1 (max speed).
        /// Controls emission rate and particle speed.
        /// </param>
        public void UpdateSpeedLines(float normalizedSpeed)
        {
            if (_activeSpeedLines == null) return;

            if (normalizedSpeed <= 0.1f)
            {
                // Speed too low — turn off speed lines
                if (_activeSpeedLines.gameObject.activeSelf)
                {
                    _activeSpeedLines.Stop();
                    _activeSpeedLines.gameObject.SetActive(false);
                }
                return;
            }

            // Activate if not already active
            if (!_activeSpeedLines.gameObject.activeSelf)
            {
                _activeSpeedLines.gameObject.SetActive(true);
                _activeSpeedLines.Play();
            }

            // Modulate emission rate based on speed
            // At normalizedSpeed = 0.5 we get ~15 particles/sec
            // At normalizedSpeed = 1.0 we get ~50 particles/sec
            var emission = _activeSpeedLines.emission;
            emission.rateOverTime = Mathf.Lerp(10f, 50f, normalizedSpeed);

            // Modulate particle speed
            var main = _activeSpeedLines.main;
            main.startSpeed = Mathf.Lerp(15f, 50f, normalizedSpeed);
        }

        /// <summary>
        /// Immediately stops the speed lines effect.
        /// </summary>
        public void StopSpeedLines()
        {
            UpdateSpeedLines(0f);
        }

        // ─── Internal Helpers ───────────────────────────────────

        /// <summary>
        /// Gets an instance from the pool, positions it, plays it,
        /// and schedules it to be returned to the pool when done.
        /// </summary>
        private void PlayEffectAtPosition(ParticleSystem prefab, Vector3 position)
        {
            ParticleSystem instance = GetFromPool(prefab);

            // Position the particle system at the target location
            instance.transform.position = position;
            instance.gameObject.SetActive(true);

            // Clear any leftover particles from a previous play
            instance.Clear();

            // Play the effect
            instance.Play();

            // Schedule return to pool after the effect finishes.
            // We use the main module's duration + startLifetime as our delay.
            float returnDelay = instance.main.duration + instance.main.startLifetime.constantMax;
            StartCoroutine(ReturnToPoolAfterDelay(prefab, instance, returnDelay));
        }

        /// <summary>
        /// Waits for the particle effect to finish, then returns it to the pool.
        /// </summary>
        private System.Collections.IEnumerator ReturnToPoolAfterDelay(
            ParticleSystem prefab,
            ParticleSystem instance,
            float delay)
        {
            yield return new WaitForSeconds(delay);
            ReturnToPool(prefab, instance);
        }

        // ─── Cleanup ────────────────────────────────────────────

        /// <summary>
        /// Stops all active particle effects. Call this on game over or scene reset.
        /// </summary>
        public void StopAllEffects()
        {
            StopAllCoroutines();
            StopSpeedLines();

            // Stop and return all active particles to their pools
            foreach (var kvp in _pools)
            {
                foreach (var ps in kvp.Value)
                {
                    if (ps != null && ps.gameObject.activeSelf)
                    {
                        ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
                        ps.gameObject.SetActive(false);
                    }
                }
            }
        }
    }
}

using UnityEngine;
using InfiniteRunner.Core;
using InfiniteRunner.VFX;

namespace InfiniteRunner.VFX
{
    /// <summary>
    /// Listens for game events and triggers appropriate particle effects.
    /// Attach this to the [ParticleManager] GameObject.
    /// </summary>
    public class ParticleEventListener : MonoBehaviour
    {
        private void OnEnable()
        {
            // Subscribe to game events
            // (Assumes your event system uses static events or
            //  ScriptableObject channels from Chapter 7)
            GameEvents.OnCoinCollected += HandleCoinCollected;
            GameEvents.OnPlayerDied += HandlePlayerDied;
            GameEvents.OnSpeedChanged += HandleSpeedChanged;
            GameManager.Instance.OnGameStateChanged += HandleStateChanged;
        }

        private void OnDisable()
        {
            // Always unsubscribe to prevent memory leaks
            GameEvents.OnCoinCollected -= HandleCoinCollected;
            GameEvents.OnPlayerDied -= HandlePlayerDied;
            GameEvents.OnSpeedChanged -= HandleSpeedChanged;

            if (GameManager.Instance != null)
            {
                GameManager.Instance.OnGameStateChanged -= HandleStateChanged;
            }
        }

        /// <summary>
        /// When a coin is collected, play the gold burst at its position.
        /// </summary>
        private void HandleCoinCollected(Vector3 coinPosition)
        {
            ParticleManager.Instance.PlayCoinCollect(coinPosition);
        }

        /// <summary>
        /// When the player dies, play the crash explosion at their position.
        /// </summary>
        private void HandlePlayerDied(Vector3 playerPosition)
        {
            ParticleManager.Instance.PlayCrash(playerPosition);
            ParticleManager.Instance.StopSpeedLines();
        }

        /// <summary>
        /// When the player's speed changes, update speed lines intensity.
        /// </summary>
        private void HandleSpeedChanged(float normalizedSpeed)
        {
            ParticleManager.Instance.UpdateSpeedLines(normalizedSpeed);
        }

        /// <summary>
        /// When the game state changes, stop all effects if not playing.
        /// </summary>
        private void HandleStateChanged(GameState newState)
        {
            if (newState != GameState.Playing)
            {
                ParticleManager.Instance.StopAllEffects();
            }
        }
    }
}