using Eflatun.SceneReference;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace MyCollections.SceneManagement
{
    public class SceneLoader : MonoBehaviour
    {
        public SceneGroup[] sceneGroups;
        private static SceneLoader instance;
        [SerializeField] private GameObject loadingScreen;
        [SerializeField] private SceneReference loading;
        //Singleton
        public static SceneLoader Instance => instance;
        private void Awake()
        {
            if (instance == null)
            {
                instance = this;
                DontDestroyOnLoad(gameObject);
            }
            else
            {
                Destroy(gameObject);
            }
        }
        private void Start()
        {
        }
        private SceneGroup FindSceneGroupByName(string name) =>
            Array.Find(sceneGroups, group => group.groupName == name);
        public void LoadScenes(string groupName, LoadType type)
        {
            SceneGroup sceneGroup = FindSceneGroupByName(groupName);
            switch (type)
            {
                case LoadType.Loading:
                    StartCoroutine(LoadWithLoadingScreenAsync(sceneGroup));
                break;
                case LoadType.Trigger:
                    LoadSceneGroup(groupName);
                break;
            }
        }
        public void LoadSceneTrigger(SceneReference sceneReference)
        {
            int count = SceneManager.sceneCount;
            for (int i = 0; i < count; i++)
            {
                Scene scene = SceneManager.GetSceneAt(i);
                if (scene.name == sceneReference.Name) return;
            }
            Debug.LogWarning("LoadingScene:  " + sceneReference.Name);
            SceneManager.LoadSceneAsync(sceneReference.Name, LoadSceneMode.Additive);
        }
        public void UnloadSceneTrigger(SceneReference unloadScene, SceneReference newActiveScene)
        {
            int count = SceneManager.sceneCount;
            bool isSceneLoaded = false;
            for (int i = 0; i < count; i++)
            {
                Scene scene = SceneManager.GetSceneAt(i);
                if (scene.name == unloadScene.Name)
                {
                    isSceneLoaded = true;
                    break;
                }
            }
            if (!isSceneLoaded)
            {
                Debug.LogWarning("Scene to unload not loaded: " + unloadScene.Name);
                return;
            }
            SceneManager.UnloadSceneAsync(unloadScene.Name);
            SetActiveScene(newActiveScene);
        }
        private void SetActiveScene(SceneReference sceneReference)
        {
            int count = SceneManager.sceneCount;
            for (int i = 0; i < count; i++)
            {
                Scene scene = SceneManager.GetSceneAt(i);
                if (scene.name == sceneReference.Name)
                {
                    SceneManager.SetActiveScene(scene);
                    return;
                }
            }
        }
        public void LoadSceneWithLoading(SceneReference sceneToLoad, SceneReference sceneToUnload) =>
            StartCoroutine(LoadSceneWithLoadingScreen(sceneToLoad, sceneToUnload));
        public void LoadSceneGroup(string groupName)
        {
            SceneGroup group = FindSceneGroupByName(groupName);
            Debug.Log($"Group Found: {group.groupName}");
            if (group == null)
                return;
            List<string> scenesToLoad = new List<string>();
            int count = SceneManager.sceneCount;
            Debug.Log($"Scene Count: {count}");
            for (int i = 0; i < group.scenes.Count; i++)
            {
                bool isSceneLoaded = false;
                for (int j = 0; j < count; j++)
                {
                    Scene loadedScene = SceneManager.GetSceneAt(j);
                    if (loadedScene.name == group.scenes[i].Name)
                    {
                        isSceneLoaded = true;
                        break;
                    }
                }
                if (!isSceneLoaded)
                {
                    Debug.Log($"Scene to Load Added: {group.scenes[i].Name}");
                    scenesToLoad.Add(group.scenes[i].Name);
                }
            }
            StartCoroutine(LoadAndSetActiveScene(scenesToLoad, group));
        }
        private IEnumerator LoadSceneWithLoadingScreen(SceneReference sceneToLoad, SceneReference sceneToUnload)
        {
            string sceneName = loading.Name;
            //Load the Loading Scene
            AsyncOperation op = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
            //Wait until the Loading Scene is loaded
            yield return new WaitUntil(() => op.isDone);
            // Update scene count dynamically
            int s = SceneManager.sceneCount;
            //Get the loading screen
            GameObject loadingCanvas = GameObject.FindGameObjectWithTag("LoadingCanvas");
            loadingScreen = loadingCanvas.transform.GetChild(0).gameObject;
            if (loadingScreen == null)
            {
                Debug.LogError("Loading Screen is Null");
                yield break;
            }
            //Enables the login screen
            loadingScreen.SetActive(true); //Automatically will trigger the fadeout animation
            Animator animator;
            //Try to get the animator from the loading screen
            if (!loadingScreen.TryGetComponent(out animator))
            {
                Debug.LogError("Animator is Null");
                yield break;
            }
            AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0);
            float duration = stateInfo.length;
            //Wait for the rest of the loading screen animation to finish
            yield return new WaitForSeconds(duration);
            //Unloads the current activeScene
            SceneManager.UnloadSceneAsync(sceneToUnload.Name);
            //Loads the scene
            AsyncOperation loadSceneOp = SceneManager.LoadSceneAsync(sceneToLoad.Name, LoadSceneMode.Additive);
            //Wait until the operation is done
            yield return new WaitUntil(() => loadSceneOp.isDone);
            //We invoke the fadeout animation of the loading screen
            animator.SetTrigger("FadeOut");
            //Get the current state info
            stateInfo = animator.GetCurrentAnimatorStateInfo(0);
            duration = stateInfo.length; //get the state lenght
            //Wait for the animation to finish
            yield return new WaitForSeconds(duration);
            //After the animation is finished
            //we unload the Loading screen
            AsyncOperation unloadOp = SceneManager.UnloadSceneAsync(sceneName);
            yield return new WaitUntil(() => unloadOp.isDone);
        }
        private IEnumerator LoadWithLoadingScreenAsync(SceneGroup group)
        {
            List<string> scenesToLoad = new List<string>();
            string sceneName = loading.Name; //Get the scene name
            //Load the Loading Scene
            AsyncOperation op = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
            //Wait until the Loading Scene is loaded
            yield return new WaitUntil(() => op.isDone);
            // Update scene count dynamically
            int s = SceneManager.sceneCount;
            //Get the loading screen
            GameObject loadingCanvas = GameObject.FindGameObjectWithTag("LoadingCanvas");
            loadingScreen = loadingCanvas.transform.GetChild(0).gameObject;
            if (loadingScreen == null)
            {
                Debug.LogError("Loading Screen is Null");
                yield break;
            }
            //Enables the login screen
            loadingScreen.SetActive(true); //Automatically will trigger the fadeout animation
            Animator animator;
            //Try to get the animator from the loading screen
            if (!loadingScreen.TryGetComponent(out animator))
            {
                Debug.LogError("Animator is Null");
                yield break;
            }
            AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0);
            float duration = stateInfo.length;
            //Wait for the rest of the loading screen animation to finish
            yield return new WaitForSeconds(duration);
            //Get the all the scenes to Load
            for (int i = 0; i < group.scenes.Count; i++)
            {
                bool isSceneLoaded = false;
                // Update scene count dynamically
                int currentSceneCount = SceneManager.sceneCount;
                Debug.Log($"Current Scene Count: {currentSceneCount}");
                for (int j = 0; j < currentSceneCount; j++)
                {
                    //Get the Scene at index in the SceneManager's list of loaded Scenes
                    Scene loadedScene = SceneManager.GetSceneAt(j);
                    Debug.Log($"LoadedScene: {loadedScene.name}");
                    // Skip checking if it's the "Loading" scene, which should only be loaded once
                    if (loadedScene.name == sceneName)
                    {
                        continue; // Skip the loading scene
                    }
                    //Compare the names of the SceneManager's list with the group of scenes
                    if (loadedScene.name == group.scenes[i].Name)
                    {
                        //if the scene is loaded flags to true
                        Debug.Log($"The Scene is Loaded: {loadedScene.name}");
                        isSceneLoaded = true;
                        break;
                    }
                }
                //Adds the scenes to load list
                if (!isSceneLoaded)
                {
                    Debug.Log($"Scene to Load Added: {group.scenes[i].Name}");
                    scenesToLoad.Add(group.scenes[i].Name);
                }
            }
            //Unload scenes
            UnloadScene(group);
            //load the all the scenes
            for (int i = 0; i < scenesToLoad.Count; i++)
            {
                AsyncOperation loadSceneOp = SceneManager.LoadSceneAsync(scenesToLoad[i], LoadSceneMode.Additive);
                //Wait until the operation is done
                yield return new WaitUntil(() => loadSceneOp.isDone);
                //Set active the scene
                SceneManager.SetActiveScene(SceneManager.GetSceneByName(scenesToLoad[i]));
            }
            //We invoke the fadeout animation of the loading screen
            animator.SetTrigger("FadeOut");
            //Get the current state info
            stateInfo = animator.GetCurrentAnimatorStateInfo(0);
            duration = stateInfo.length; //get the state lenght
            //Wait for the animation to finish
            yield return new WaitForSeconds(duration);
            //After the animation is finished
            //we unload the Loading screen
            AsyncOperation unloadOp = SceneManager.UnloadSceneAsync(sceneName);
            yield return new WaitUntil(() => unloadOp.isDone);
        }
        private IEnumerator LoadAndSetActiveScene(List<string> scenesToLoad, SceneGroup group)
        {
            for (int i = 0; i < scenesToLoad.Count; i++)
            {
                AsyncOperation op = SceneManager.LoadSceneAsync(scenesToLoad[i], LoadSceneMode.Additive);
                Debug.Log($"Loading Scene: {scenesToLoad[i]}");
                // Wait for the scene to fully load
                yield return new WaitUntil(() => op.isDone);
                // After the scene has loaded, set it as active
                SceneManager.SetActiveScene(SceneManager.GetSceneByName(scenesToLoad[i]));
                Debug.Log($"Scene {scenesToLoad[i]} set as active.");
            }
            // Once all scenes are loaded, unload the required scenes
            UnloadScene(group);
        }
        private void UnloadScene(SceneGroup group)
        {
            List<Scene> scenesToUnload = group.FindSceneRefByType(SceneType.DisableScene);
            Debug.Log($"Scenes Found To Unload: {scenesToUnload.Count}");
            List<string> unloadScenes = new List<string>();
            if (scenesToUnload.Count == 0)
                return;
            for (int i = 0; i < scenesToUnload.Count; i++)
            {
                Scene sceneToUnload = scenesToUnload[i];
                if (sceneToUnload.isLoaded)
                {
                    Debug.Log($"Scene to Unload: {sceneToUnload.name}");
                    unloadScenes.Add(sceneToUnload.name);
                }
            }
            if (unloadScenes.Count > 0)
            {
                for (int i = 0; i < unloadScenes.Count; i++)
                {
                    SceneManager.UnloadSceneAsync(unloadScenes[i]);
                    Debug.Log($"Unloading Scene: {unloadScenes[i]}");
                }
            }
        }
    }
    [Serializable]
    public struct SceneDataSaver
    {
        //Position where the player should be after changing scene
        public Vector3 position;
        public string groupName;
    }
    //The trigger loadtype doesn't affect the player gameplay
    //The Loading loadtype triggers a loading screen
    public enum LoadType
    {
        Trigger,
        Loading
    }
    public enum SceneAction
    {
        LoadScene,
        UnloadScene
    }
}