using System.Collections.Generic;
using UnityEngine;

public class LayerManager : MonoBehaviour
{
    [Header("Layer Settings")]
    [SerializeField] private GameObject[] layer0_Objects; // GameObjects for base layer
    [SerializeField] private GameObject[] layer1_Objects;
    [SerializeField] private GameObject[] layer2_Objects;
    // Add more layers as needed

    [SerializeField] private uint currentLayerIndex = 0;

    [Header("References")]
    [SerializeField] private UIController uiController;

    private Dictionary<uint, List<MeshRenderer>> layerDictionary = new Dictionary<uint, List<MeshRenderer>>();

    void Awake()
    {
        // Initialize layers and collect all MeshRenderers
        InitializeLayer(0, layer0_Objects);
        InitializeLayer(1, layer1_Objects);
        InitializeLayer(2, layer2_Objects);
        // Add more layers here if needed

        // Disable all layers except the first one
        foreach (var layer in layerDictionary)
        {
            SetLayerVisibility(layer.Key, layer.Key == 0);
        }
    }

    private void InitializeLayer(uint layerIndex, GameObject[] parentObjects)
    {
        List<MeshRenderer> renderers = new List<MeshRenderer>();

        if (parentObjects != null)
        {
            foreach (GameObject parent in parentObjects)
            {
                if (parent != null)
                {
                    // Get all MeshRenderers in this object and its children
                    MeshRenderer[] childRenderers = parent.GetComponentsInChildren<MeshRenderer>(true);
                    renderers.AddRange(childRenderers);
                }
            }
        }

        layerDictionary.Add(layerIndex, renderers);
    }

    void Start()
    {
        if (uiController != null)
        {
            uiController.onLayerChange += HandleLayerChange;
        }
        else
        {
            Debug.LogError("UIController reference is missing!");
        }
    }

    void OnDestroy()
    {
        if (uiController != null)
        {
            uiController.onLayerChange -= HandleLayerChange;
        }
    }

    private void HandleLayerChange(LayerLevelAction action)
    {
        uint newLayerIndex = currentLayerIndex;


        switch (action)
        {
            case LayerLevelAction.Increment:
                if (currentLayerIndex < layerDictionary.Count - 1)
                    newLayerIndex++;
                break;

            case LayerLevelAction.Decrement:
                if (currentLayerIndex > 0)
                    newLayerIndex--;
                break;
        }

        if (newLayerIndex != currentLayerIndex)
        {
            // Disable current layer
            SetLayerVisibility(currentLayerIndex, false);

            // Enable new layer
            SetLayerVisibility(newLayerIndex, true);

            currentLayerIndex = newLayerIndex;
        }

    }

    private void SetLayerVisibility(uint layerIndex, bool isVisible)
    {
        if (layerDictionary.TryGetValue(layerIndex, out List<MeshRenderer> renderers))
        {
            foreach (MeshRenderer renderer in renderers)
            {
                if (renderer != null)
                {
                    renderer.enabled = isVisible;
                }
            }
        }
    }

    // Editor-only method to refresh layer contents
#if UNITY_EDITOR
    public void RefreshLayerContents()
    {
        layerDictionary.Clear();
        InitializeLayer(0, layer0_Objects);
        InitializeLayer(1, layer1_Objects);
        InitializeLayer(2, layer2_Objects);
    }
#endif
}
public enum LayerLevelAction
{
    Increment,
    Decrement,
}