using System.Collections;
using TMPro;
using UnityEngine;

public class WaitCircle : MonoBehaviour
{
    private static WaitCircle _instance;
    private const string HIDDEN_LAYER = "HiddenUI";
    private static Camera _hiddenUICam;

    public static void Setting(bool isSpining, string message, float duration = 0f)
    {
        GameObject spinner = Get.o2("HIDER", "LoadingCircle");
        spinner.SetActive(isSpining);
        spinner.transform.Find("Message").GetComponent<TMP_Text>().text = message;

        if (isSpining && duration != 0f)
            Instance.StartCoroutine(HideSpinnerAfterDuration(spinner, duration));

        // ❌ Plus de SetLayerRecursive ici — layer normal conservé
        COLORSET.On();
        ColorSet.Do();
    }

    // public static void SetHiddenForCapture(bool hidden)
    // {
    //     int layer = hidden
    //         ? LayerMask.NameToLayer("HiddenUI")
    //         : LayerMask.NameToLayer("UI");          // ← votre layer normal du spinner

    //     if (layer < 0) { Debug.LogError($"Layer introuvable"); return; }

    //     GameObject spinner = Get.o2("HIDER", "LoadingCircle");
    //     if (spinner == null) return;
    //     SetLayerRecursive(spinner, layer);
    // }

    /// <summary>
    /// Crée (une seule fois) une caméra qui rend UNIQUEMENT le layer HiddenUI,
    /// par-dessus tout, sans jamais être utilisée pour les captures.
    /// </summary>
    // private static void EnsureHiddenUICam()
    // {
    //     if (_hiddenUICam != null) return;

    //     GameObject go = new GameObject("HiddenUICamera");
    //     Object.DontDestroyOnLoad(go);

    //     _hiddenUICam = go.AddComponent<Camera>();
    //     _hiddenUICam.cullingMask    = 1 << LayerMask.NameToLayer(HIDDEN_LAYER);
    //     _hiddenUICam.clearFlags     = CameraClearFlags.Depth; // ne pas effacer le fond
    //     _hiddenUICam.depth          = 99;   // rend en dernier → toujours au-dessus
    //     _hiddenUICam.orthographic   = true;
    //     _hiddenUICam.targetDisplay  = 0;
    // }

    /// <summary>
    /// Capture propre via RenderTexture — le layer HiddenUI est exclu.
    /// Remplace ScreenCapture.CaptureScreenshotAsTexture()
    /// </summary>
    public static Texture2D CaptureWithoutHiddenUI(Camera sourceCam = null)
    {
        if (sourceCam == null) sourceCam = Camera.main;

        // S'assurer que la caméra principale n'a JAMAIS le layer HiddenUI
        sourceCam.cullingMask &= ~(1 << LayerMask.NameToLayer(HIDDEN_LAYER));

        RenderTexture rt = new RenderTexture(Screen.width, Screen.height, 24);
        sourceCam.targetTexture = rt;
        sourceCam.Render();                 // render manuel dans la RenderTexture

        RenderTexture.active = rt;
        Texture2D screenshot = new Texture2D(Screen.width, Screen.height, TextureFormat.RGB24, false);
        screenshot.ReadPixels(new Rect(0, 0, Screen.width, Screen.height), 0, 0);
        screenshot.Apply();

        // Nettoyage
        sourceCam.targetTexture = null;
        RenderTexture.active    = null;
        Object.Destroy(rt);

        return screenshot;
    }

    // --- Privé ---

    public static WaitCircle Instance
    {
        get
        {
            if (_instance == null)
            {
                GameObject go = new GameObject("SpinnerController");
                _instance = go.AddComponent<WaitCircle>();
                DontDestroyOnLoad(go);
            }
            return _instance;
        }
    }

    private static IEnumerator HideSpinnerAfterDuration(GameObject spinner, float delay)
    {
        yield return new WaitForSeconds(delay);
        spinner.SetActive(false);
    }

    private static void SetLayerRecursive(GameObject obj, int layer)
    {
        if (layer < 0 || layer > 31)
        {
            Debug.LogError("WaitCircle: Layer 'HiddenUI' introuvable — créez-le dans Edit > Project Settings > Tags and Layers");
            return;
        }
        obj.layer = layer;
        foreach (Transform child in obj.transform)
            SetLayerRecursive(child.gameObject, layer);
    }
}