using UnityEngine;
using UnityEngine.SceneManagement;
using System.Collections;
using System;

public class AsyncLoader : MonoBehaviour
{   
    public static IEnumerator LoadMainAndAdditiveScenesAsync(string mainSceneName, string[] additionalScenes)
    {
        // Load the main scene asynchronously
        AsyncOperation mainSceneLoading = SceneManager.LoadSceneAsync(mainSceneName);

        // Load additional scenes additively asynchronously
        foreach (string sceneName in additionalScenes)
        {
            AsyncOperation additionalSceneLoading = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);

            // Wait until the additional scene is fully loaded
            yield return WaitForAsyncOperationAdditive(additionalSceneLoading);
        }

        // Wait until the main scene is fully loaded
        yield return WaitForAsyncOperation(mainSceneLoading);

        Debug.Log("All scenes are loaded!");
    }

    private static IEnumerator WaitForAsyncOperation(AsyncOperation operation)
    {
        while (!operation.isDone)
        {
            float progress = Mathf.Clamp01(operation.progress / 0.9f);
            Debug.Log("Loading scene progress: " + (progress * 100) + "%");
            yield return null;
        }
    }

    private static IEnumerator WaitForAsyncOperationAdditive(AsyncOperation operation)
    {
        while (!operation.isDone)
        {
            float progress = Mathf.Clamp01(operation.progress / 0.9f);
            Debug.Log("Loading scene progress: " + (progress * 100) + "%");
            yield return null;
        }
    }
    // Load a scene asynchronously
    public static IEnumerator LoadSceneAsync(string sceneName, Action<float> progressCallback, Action onComplete)
    {
        AsyncOperation operation = SceneManager.LoadSceneAsync(sceneName);

        while (!operation.isDone)
        {
            float progress = Mathf.Clamp01(operation.progress / 0.9f); // Progress ranges from 0 to 1
            progressCallback?.Invoke(progress);
            yield return null;
        }

        onComplete?.Invoke();
    }

    // Load an asset bundle asynchronously
    public static IEnumerator LoadAssetBundleAsync(string bundlePath, string assetName, Action<UnityEngine.Object> onAssetLoaded)
    {
        AssetBundleCreateRequest bundleLoadRequest = AssetBundle.LoadFromFileAsync(bundlePath);

        yield return bundleLoadRequest;

        if (bundleLoadRequest.isDone)
        {
            AssetBundle assetBundle = bundleLoadRequest.assetBundle;

            if (assetBundle != null)
            {
                AssetBundleRequest assetLoadRequest = assetBundle.LoadAssetAsync(assetName);

                yield return assetLoadRequest;

                if (assetLoadRequest.isDone)
                {
                    onAssetLoaded?.Invoke(assetLoadRequest.asset);
                }

                assetBundle.Unload(false);
            }
        }
    }
}