using System.Collections.Generic;
using UnityEngine;

namespace MS_Outline
{
    /// <summary>
    /// Marks an object for highlighting with the FullOutline system.
    /// Add this component to any object that should be highlightable.
    /// </summary>
    [DisallowMultipleComponent]
    public class GlowOutlineTarget : MonoBehaviour
    {
        private static HashSet<GlowOutlineTarget> activeTargets = new HashSet<GlowOutlineTarget>();

        [Header("Glow Settings")]
        [Tooltip("The color of the glow effect")]
        [SerializeField] private Color glowColor = Color.yellow;

        [Tooltip("Intensity multiplier for the glow. Values > 1 create HDR emission that blooms.")]
        [Range(0f, 20f)]
        [SerializeField] private float glowIntensity = 1.5f;

        [Header("State")]
        [Tooltip("Whether the glow is currently active")]
        [SerializeField] private bool isGlowing = true;

        [Header("Exclusions")]
        [Tooltip("Child GameObjects to exclude from the outline (e.g., particle systems, VFX)")]
        [SerializeField] private List<GameObject> excludedObjects = new List<GameObject>();

        private Renderer[] renderers;

        /// <summary>
        /// Get all currently glowing targets
        /// </summary>
        public static IReadOnlyCollection<GlowOutlineTarget> ActiveTargets => activeTargets;

        /// <summary>
        /// The color of the glow effect
        /// </summary>
        public Color GlowColor
        {
            get => glowColor;
            set => glowColor = value;
        }

        /// <summary>
        /// Intensity multiplier for the glow. Values > 1 create HDR emission.
        /// </summary>
        public float GlowIntensity
        {
            get => glowIntensity;
            set => glowIntensity = Mathf.Clamp(value, 0f, 20f);
        }

        /// <summary>
        /// Whether this object is currently glowing
        /// </summary>
        public bool IsGlowing => isGlowing;

        /// <summary>
        /// Get all renderers on this object
        /// </summary>
        public Renderer[] Renderers => renderers;

        private void Awake()
        {
            CacheRenderers();
        }

        /// <summary>
        /// Cache renderers, filtering out any excluded objects
        /// </summary>
        private void CacheRenderers()
        {
            var allRenderers = GetComponentsInChildren<Renderer>();

            if (excludedObjects == null || excludedObjects.Count == 0)
            {
                renderers = allRenderers;
                return;
            }

            var filteredList = new List<Renderer>();

            foreach (var renderer in allRenderers)
            {
                bool isExcluded = false;

                foreach (var excluded in excludedObjects)
                {
                    if (excluded != null &&
                        (renderer.gameObject == excluded || renderer.transform.IsChildOf(excluded.transform)))
                    {
                        isExcluded = true;
                        break;
                    }
                }

                if (!isExcluded)
                    filteredList.Add(renderer);
            }

            renderers = filteredList.ToArray();
        }

        private void OnEnable()
        {
            // If we were glowing before being disabled, re-register
            if (isGlowing)
            {
                activeTargets.Add(this);
            }
        }

        private void OnDisable()
        {
            // Always remove from active targets when disabled
            activeTargets.Remove(this);
        }

        private void OnDestroy()
        {
            activeTargets.Remove(this);
        }

        #if UNITY_EDITOR
        private void OnValidate()
        {
            // Handle inspector changes during play mode
            if (Application.isPlaying && isActiveAndEnabled)
            {
                // Re-cache renderers in case exclusions changed
                CacheRenderers();

                if (isGlowing)
                    activeTargets.Add(this);
                else
                    activeTargets.Remove(this);
            }
        }
        #endif

        /// <summary>
        /// Enable the glow effect on this object
        /// </summary>
        public void EnableGlow()
        {
            if (!isGlowing)
            {
                isGlowing = true;
                activeTargets.Add(this);
                #if UNITY_EDITOR
                Debug.Log($"[FullOutline] EnableGlow on {gameObject.name}. Active targets: {activeTargets.Count}");
                #endif
            }
        }

        /// <summary>
        /// Enable the glow effect with a specific color
        /// </summary>
        public void EnableGlow(Color color)
        {
            glowColor = color;
            EnableGlow();
        }

        /// <summary>
        /// Enable the glow effect with a specific color and intensity
        /// </summary>
        public void EnableGlow(Color color, float intensity)
        {
            glowColor = color;
            glowIntensity = Mathf.Clamp(intensity, 0f, 20f);
            EnableGlow();
        }

        /// <summary>
        /// Disable the glow effect on this object
        /// </summary>
        public void DisableGlow()
        {
            if (isGlowing)
            {
                isGlowing = false;
                activeTargets.Remove(this);
            }
        }

        /// <summary>
        /// Toggle the glow effect
        /// </summary>
        public void ToggleGlow()
        {
            if (isGlowing)
                DisableGlow();
            else
                EnableGlow();
        }
    }
}