AdAggregatorSelector.cs

using System;
using System.IO;
using System.Linq;
using UnityEditor;
#if UNITY_2021_2_OR_NEWER
using UnityEditor.Build;
#endif
using UnityEditor.Compilation;
using UnityEngine;
using Object = UnityEngine.Object;
 
namespace SCG.SpaceAdMobile
{
    public partial class AdAggregatorSelector : EditorWindow
    {
        private const string StoreFreeVersionUrl = "https://assetstore.unity.com/packages/tools/integration/spacebanneradmobile-free-278681";
        private const string StoreUrl = "https://assetstore.unity.com/packages/tools/integration/spaceadmobile-204424";
        private const string DocsUrl = "https://space-cat.games/SpaceAdMobile/index.html";
        private const int WindowMenuPriority = 2100;
 
        private static bool firstRun;
        private static AdAggregatorSelector window;
        private static AdAggregatorResource adAggregatorResource;
 
        private static AdMigrationWindow adMigrationWindow;
 
        private static byte selectedAggregator;
        private static Aggregator currentAggregator;
 
        private Rect? lastPosition;
        private bool suppressReopenOnDisable;
        private bool isYandexUpdaterLaunching;
 
        private const float InstalledInstallButtonExtraWidth = 8f;
        private const float MinWidth = 520f;
        private const float MinHeight = 400f;
        private static readonly Vector2 s_minSize = new(MinWidth, MinHeight);
        private static readonly Vector2 s_maxSize = new(MinWidth * 2f, MinHeight * 2f);
 
        private static readonly GUIContent s_deleteOtherFoldersContent = new(
            "Delete other ad folders",
            "Remove folders belonging to other ad aggregators that are not currently selected.");
 
        private static readonly GUIContent s_deleteDemosContent = new(
            "Delete demos",
            "Remove demo scenes and example scripts bundled with the selected aggregator SDK.");
 
        private static readonly GUIContent s_deleteDocumentationContent = new(
            "Delete documentation",
            "Remove documentation files (PDF, TXT) shipped with the selected aggregator SDK.");
 
        private static readonly GUIContent s_enhancedYandexDummiesContent = new(
            "Enhanced Yandex editor dummies",
            "Replace stock silent Yandex dummies with enhanced ones that fire ad-lifecycle events in the Editor.");
 
        private static readonly GUIContent s_suppressYandexCs0414WarningsContent = new(
            "Suppress CS0414",
            "Add or remove warning code 414 in the selected Yandex SDK files that suppress warning 67.");
 
        private static readonly GUIContent s_installContent = new("Install");
        private static GUIContent UpdateContent { get; } = new(
            "Update",
            "Update the installed SDK to a newer version using .unitypackage files in your Downloads folder.");
        private static GUIContent UpdateUnavailableContent { get; } = new(
            "Update",
            $"Python {YandexSdkUpdaterLauncher.MinimumPythonVersion} or newer was not found. Add python, python3, or the Windows Python Launcher to PATH.");
        private static GUIContent UpdateCheckingContent { get; } = new(
            "Update",
            $"Checking for Python {YandexSdkUpdaterLauncher.MinimumPythonVersion} or newer.");
        private static GUIContent UpdateStartingContent { get; } = new(
            "Update",
            "Waiting for the terminal and updater controller to start.");

        [InitializeOnLoadMethod]
        protected static void InitOnLoad() => EditorApplication.delayCall += OnLoad;

        protected static void OnLoad()
        {
            EditorApplication.delayCall -= OnLoad;
 
            if (Application.isPlaying) return;
 
            adAggregatorResource = adAggregatorResource != null ? adAggregatorResource : AdAggregatorResource.Instance;
            if (adAggregatorResource == null)
            {
                throw new UnityException($"The resource file '{nameof(AdAggregatorResource)}' is missing. Please reinstall the package.");
            }
 
            adAggregatorResource.DeleteOtherFolders = EditorPrefs.GetBool(AdAggregatorResource.KeyDeleteOtherFolders);
            adAggregatorResource.DeleteDemo = EditorPrefs.GetBool(AdAggregatorResource.KeyDeleteDemo);
            adAggregatorResource.DeleteDocumentation = EditorPrefs.GetBool(AdAggregatorResource.KeyDeleteDocumentation);
            adAggregatorResource.UseEnhancedYandexEditorDummies =
                EditorPrefs.GetBool(AdAggregatorResource.KeyUseEnhancedYandexEditorDummies, false);
 
            if (!IsAggregatorSelected())
            {
                ShowWindow();
            }
        }

        protected static bool IsAggregatorSelected()
        {
            if (AssetDatabase.IsAssetImportWorkerProcess()) return true;
            if (EditorApplication.isCompiling) return true;
            if (adAggregatorResource == null) return false;
 
#if UNITY_6000_3_OR_NEWER
            var named = NamedBuildTarget.FromBuildTargetGroup(
                BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
            PlayerSettings.GetScriptingDefineSymbols(named, out var defines);
#elif UNITY_2021_2_OR_NEWER
            var named = NamedBuildTarget.FromBuildTargetGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
            PlayerSettings.GetScriptingDefineSymbols(named, out var defines);
#else
            var definesLegacy = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
            var defines = definesLegacy.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
#endif
            if (adMigrationWindow == null) // Change aggregator only if window not active
                currentAggregator = adAggregatorResource.Aggregators
                    .FirstOrDefault(e => defines.Contains(e.Define, StringComparer.Ordinal));
 
            var result = currentAggregator != null;
            if (!result)
            {
                firstRun = true;
                return false;
            }
 
            //firstRun = true; // Debug first run
            firstRun = false;
            selectedAggregator = (byte)Mathf.Max(0, Array.FindIndex(adAggregatorResource.Aggregators, e => defines.Contains(e.Define)));
            return true;
        }

        [MenuItem("Window/" + nameof(SCG) + "/" + nameof(SpaceAdMobile) + ": Select Aggregator &S", priority = WindowMenuPriority)]
        public static void ShowWindow()
        {
            EditorApplication.delayCall -= ShowWindow;
 
            adAggregatorResource = adAggregatorResource != null ? adAggregatorResource : AdAggregatorResource.Instance;
            YandexAssemblyUpdater.Validate0414WarningSuppressionPreference();
 
            if (window == null)
            {
                window = GetWindow<AdAggregatorSelector>(true, "Select Ad Aggregator", true);
                window.minSize = s_minSize;
                window.maxSize = s_maxSize;
            }
            else
            {
                window.Focus();
            }
 
            YandexSdkUpdaterLauncher.RefreshPythonAvailability(() =>
            {
                if (window != null) window.Repaint();
            });
        }

        protected virtual void OnEnable()
        {
            YandexAssemblyUpdater.Validate0414WarningSuppressionPreference();
            YandexSdkUpdaterLauncher.RefreshPythonAvailability(Repaint);
        }

        protected virtual void OnGUI()
        {
            if (adAggregatorResource == null)
                return;
 
            if (firstRun)
            {
                EditorGUILayout.HelpBox(adAggregatorResource.WelcomeText, MessageType.Info);
            }
 
            using (new EditorGUI.DisabledScope(adMigrationWindow != null))
            {
                if (adMigrationWindow == null && lastPosition != null)
                {
                    EditorApplication.delayCall += () =>
                    {
                        if (adMigrationWindow == null && lastPosition != null) ApplyLastPosition();
                    };
                }
 
                GUILayout.BeginHorizontal();
                GUILayout.Label("Select an Ad Aggregator", EditorStyles.boldLabel);
 
                if (adAggregatorResource.IsFreeVersion)
                {
                    if (GUILayout.Button("Asset Store (Free)", GUILayout.MaxWidth(110)))
                    {
                        Application.OpenURL(StoreFreeVersionUrl);
                    }
                }
 
                if (GUILayout.Button("Asset Store", GUILayout.MaxWidth(200)))
                {
                    Application.OpenURL(StoreUrl);
                }
 
                if (GUILayout.Button("Open Docs", GUILayout.MaxWidth(150)))
                {
                    Application.OpenURL(DocsUrl);
                }
                GUILayout.EndHorizontal();
 
                const int elementsInRow = 3;
                var buttonWidth = EditorGUIUtility.currentViewWidth / elementsInRow - GUI.skin.button.padding.right + 2f;
 
                for (byte aggrIndex = 0; aggrIndex < adAggregatorResource.Aggregators.Length; aggrIndex++)
                {
                    var aggregatorObject = adAggregatorResource.Aggregators[aggrIndex];
                    if (aggregatorObject.Folder == null)
                        continue;
 
                    if (aggrIndex % elementsInRow == 0)
                        GUILayout.BeginHorizontal();
 
                    var buttonSkin = new GUIStyle(GUI.skin.button)
                    {
                        imagePosition = ImagePosition.ImageAbove
                    };
 
                    if (selectedAggregator == aggrIndex)
                    {
                        buttonSkin.active.textColor = Color.green;
                        buttonSkin.hover.textColor = Color.green;
                        buttonSkin.normal.textColor = Color.green;
                    }
 
                    var buttonContent = new GUIContent(aggregatorObject.Name, aggregatorObject.Texture);
 
                    if (GUILayout.Button(buttonContent, buttonSkin, GUILayout.Width(buttonWidth), GUILayout.Height(buttonWidth)))
                    {
                        selectedAggregator = aggrIndex;
                    }
 
                    if (aggrIndex % elementsInRow == elementsInRow - 1 || aggrIndex == adAggregatorResource.Aggregators.Length - 1)
                    {
                        GUILayout.EndHorizontal();
                    }
                }
 
                using (new EditorGUILayout.VerticalScope())
                {
                    GUILayout.FlexibleSpace();
 
                    var toAggregator = GetSelectedAggregator();
                    var isYandexAggregator = IsYandexAggregator(toAggregator);
                    var shouldShowYandex0414Suppression = IsYandexAggregator(currentAggregator) && isYandexAggregator;
                    var shouldShowYandexFixButton = EditorUtility.scriptCompilationFailed && isYandexAggregator;
 
#if !LEGACY_YANDEX_MOBILE_ADS
                    if (isYandexAggregator || shouldShowYandex0414Suppression)
#else
                    if (shouldShowYandex0414Suppression)
#endif
                    {
                        using (new EditorGUILayout.HorizontalScope())
                        {
#if !LEGACY_YANDEX_MOBILE_ADS
                            if (isYandexAggregator)
                            {
                                adAggregatorResource.UseEnhancedYandexEditorDummies = GUILayout.Toggle(
                                    adAggregatorResource.UseEnhancedYandexEditorDummies,
                                    s_enhancedYandexDummiesContent);
                            }
#endif
 
                            if (shouldShowYandex0414Suppression)
                            {
                                GUILayout.FlexibleSpace();
                                GUILayout.Label(s_suppressYandexCs0414WarningsContent, GUILayout.ExpandWidth(false));
                                var suppressYandexCs0414Warnings = YandexAssemblyUpdater.SuppressYandex0414Warnings;
                                var updatedSuppressYandexCs0414Warnings = GUILayout.Toggle(
                                    suppressYandexCs0414Warnings,
                                    GUIContent.none,
                                    GUILayout.Width(EditorGUIUtility.singleLineHeight));
                                if (updatedSuppressYandexCs0414Warnings != suppressYandexCs0414Warnings)
                                    YandexAssemblyUpdater.SuppressYandex0414Warnings = updatedSuppressYandexCs0414Warnings;
                            }
                        }
                    }
 
                    using (new EditorGUILayout.HorizontalScope())
                    {
                        adAggregatorResource.DeleteOtherFolders = GUILayout.Toggle(
                            adAggregatorResource.DeleteOtherFolders,
                            s_deleteOtherFoldersContent,
                            GUILayout.ExpandWidth(false));
 
                        GUILayout.FlexibleSpace();
                        GUILayout.Label(s_deleteDemosContent, GUILayout.ExpandWidth(false));
                        var deleteDemo = adAggregatorResource.DeleteDemo = GUILayout.Toggle(
                            adAggregatorResource.DeleteDemo,
                            GUIContent.none,
                            GUILayout.Width(EditorGUIUtility.singleLineHeight));
                        adAggregatorResource.DeleteDocumentation =
                            deleteDemo && EditorGUILayout.Toggle(s_deleteDocumentationContent, adAggregatorResource.DeleteDocumentation);
                    }
 
                    var isAggregatorSelectable = toAggregator != null &&
                                                 (currentAggregator == null ||
                                                  !string.Equals(currentAggregator.Name, toAggregator.Name, StringComparison.Ordinal));
                    var isAggregatorInstalled = toAggregator != null && IsAggregatorInstalled(toAggregator);
                    var shouldShowInstallOnly = isAggregatorSelectable && !isAggregatorInstalled;
                    var shouldShowInstall = shouldShowInstallOnly || isAggregatorInstalled;
                    var isInstallActionConfigured = !shouldShowInstall || IsInstallActionConfigured(toAggregator);
 
                    if (shouldShowInstallOnly && !isInstallActionConfigured)
                    {
                        EditorGUILayout.HelpBox(
                            $"Install action is not configured for '{toAggregator.Name ?? "Unknown"}'.",
                            MessageType.Warning);
                    }
 
                    using (new EditorGUILayout.HorizontalScope())
                    {
#if UNITY_2022_3_OR_NEWER
                        var heigth = GUI.skin.button.lineHeight * 1.5f;
#else
                        var heigth = GUI.skin.button.lineHeight * 2f;
#endif
 
                        if (shouldShowInstallOnly)
                        {
                            using (new EditorGUI.DisabledScope(!isInstallActionConfigured))
                            {
                                if (GUILayout.Button(s_installContent, GUILayout.Height(heigth)))
                                {
                                    OpenInstall(toAggregator);
                                }
                            }
                        }
                        else
                        {
                            if (shouldShowInstall)
                            {
                                using (new EditorGUI.DisabledScope(!isInstallActionConfigured))
                                {
                                    var installWidth = GUI.skin.button.CalcSize(s_installContent).x + InstalledInstallButtonExtraWidth;
                                    if (GUILayout.Button(s_installContent, GUILayout.Width(installWidth), GUILayout.Height(heigth)))
                                    {
                                        OpenInstall(toAggregator);
                                    }
                                }
                            }
 
                            if (GUILayout.Button("OK", GUILayout.Height(heigth)))
                            {
                                if (currentAggregator != null && toAggregator != null &&
                                    currentAggregator.Name != toAggregator.Name)
                                {
                                    lastPosition = window.position;
 
                                    window.maxSize = window.minSize;
                                    window.position = new Rect(Vector2.zero, minSize);
 
                                    EditorApplication.delayCall += () =>
                                    {
                                        adMigrationWindow = AdMigrationWindow.Open(adAggregatorResource,
                                            currentAggregator,
                                            toAggregator,
                                            () => ApplyChanges(toAggregator),
                                            dryRun: false,
                                            modal: false);
                                    };
                                }
                                else if (toAggregator != null)
                                {
                                    ApplyChanges(toAggregator);
                                }
                            }
                        }
 
                        // ReSharper disable once InvertIf
                        if (shouldShowYandexFixButton && GUILayout.Button("Fix Yandex Assembly", GUILayout.Height(heigth)))
                        {
                            RunYandexUpdaterIfNeeded(toAggregator);
                        }
 
                        if (!IsYandexAggregator(currentAggregator) || !IsYandexAggregator(toAggregator)) return;
                        var pythonAvailabilityChecked = YandexSdkUpdaterLauncher.IsPythonAvailabilityChecked;
                        var updateAvailable = pythonAvailabilityChecked && YandexSdkUpdaterLauncher.IsPythonAvailable;
                        var updateContent = isYandexUpdaterLaunching
                            ? UpdateStartingContent
                            : !pythonAvailabilityChecked
                            ? UpdateCheckingContent
                            : updateAvailable ? UpdateContent : UpdateUnavailableContent;
                        var updateButtonWidth = GUI.skin.button.CalcSize(s_installContent).x + InstalledInstallButtonExtraWidth;
                        using (new EditorGUI.DisabledScope(!updateAvailable || isYandexUpdaterLaunching))
                        {
                            // ReSharper disable once InvertIf
                            if (GUILayout.Button(
                                    updateContent,
                                    GUILayout.Width(updateButtonWidth),
                                    GUILayout.Height(heigth)))
                            {
                                isYandexUpdaterLaunching = true;
                                // ReSharper disable once InvertIf
                                if (!YandexSdkUpdaterLauncher.TryLaunch(HandleYandexUpdaterLaunchCompleted, out var error))
                                {
                                    isYandexUpdaterLaunching = false;
                                    EditorUtility.DisplayDialog("SDK Updater", error, "OK");
                                }
                            }
                        }
                    }
                }
            }
        }
 
        private void HandleYandexUpdaterLaunchCompleted(bool started, string error)
        {
            if (this == null || !isYandexUpdaterLaunching)
                return;
 
            isYandexUpdaterLaunching = false;
            if (!started)
            {
                EditorUtility.DisplayDialog("SDK Updater", error ?? "The updater terminal could not be started.", "OK");
                Repaint();
                return;
            }
 
            suppressReopenOnDisable = true;
            Close();
        }

        protected virtual void OnDisable()
        {
#if UNITY_EDITOR_OSX
            if (isYandexUpdaterLaunching)
            {
                YandexSdkUpdaterLauncher.CancelPendingLaunch();
                isYandexUpdaterLaunching = false;
            }
#endif
 
            SaveEditorPreferences();
 
            if (suppressReopenOnDisable || IsAggregatorSelected())
            {
                adAggregatorResource = null;
                return;
            }
 
            Debug.LogWarning("Please select one of the ad aggregators.");
            EditorApplication.delayCall += ShowWindow;
        }
 
        private void ApplyLastPosition()
        {
            if (lastPosition == null) return;
            window.maxSize = s_maxSize;
            window.position = lastPosition.Value;
            lastPosition = null;
        }
 
        private void ApplyChanges(Aggregator aggregator)
        {
            if (aggregator == null)
                return;
 
            ApplyLastPosition();
            ChangeDefine(aggregator.Define);
            DeleteOtherAdFolders(!adAggregatorResource.DeleteDemo);
            DeleteDemo(true);
            RunYandexUpdaterIfNeeded(aggregator);
            Close();
            EditorApplication.delayCall += () =>
            {
                if (adMigrationWindow != null) adMigrationWindow.Close();
                CompilationPipeline.RequestScriptCompilation();
            };
        }
 
        private static bool IsYandexAggregator(Aggregator aggregator) =>
            aggregator != null &&
            string.Equals(aggregator.Define, DefineSymbolsManager.YandexMobileAds, StringComparison.Ordinal);
 
        private static void RunYandexUpdaterIfNeeded(Aggregator aggregator)
        {
            if (!IsYandexAggregator(aggregator))
                return;
 
            SaveEditorPreferences();
            YandexAssemblyUpdater.Update();
        }
 
        private static void SaveEditorPreferences()
        {
            if (adAggregatorResource == null)
                return;
 
            EditorPrefs.SetBool(AdAggregatorResource.KeyDeleteOtherFolders, adAggregatorResource.DeleteOtherFolders);
            EditorPrefs.SetBool(AdAggregatorResource.KeyDeleteDemo, adAggregatorResource.DeleteDemo);
            EditorPrefs.SetBool(AdAggregatorResource.KeyDeleteDocumentation, adAggregatorResource.DeleteDocumentation);
            EditorPrefs.SetBool(AdAggregatorResource.KeyUseEnhancedYandexEditorDummies, adAggregatorResource.UseEnhancedYandexEditorDummies);
        }
 
        private static void ChangeDefine(string define)
        {
            for (byte aggrIndex = 0; aggrIndex < adAggregatorResource.Aggregators.Length; aggrIndex++)
            {
                if (aggrIndex == selectedAggregator)
                    DefineSymbolsManager.AddDefineSymbol(define);
                else
                    DefineSymbolsManager.RemoveDefineSymbol(adAggregatorResource.Aggregators[aggrIndex].Define);
            }
        }
 
        private static void DeleteOtherAdFolders(bool refresh)
        {
            if (!adAggregatorResource.DeleteOtherFolders) return;
 
            for (byte aggrIndex = 0; aggrIndex < adAggregatorResource.Aggregators.Length; aggrIndex++)
            {
                if (aggrIndex == selectedAggregator)
                    continue;
 
                var folderPath = GetAssetPath(adAggregatorResource.Aggregators[aggrIndex].Folder);
                if (!IsProjectAssetsPath(folderPath) || !Directory.Exists(folderPath)) continue;
 
                TryDeleteEntireFolder(folderPath);
            }
 
            if (refresh)
                AssetDatabase.Refresh();
        }
 
        private static void DeleteDemo(bool refresh)
        {
            if (!adAggregatorResource.DeleteDemo) return;
            var deleteDocumentation = adAggregatorResource.DeleteDocumentation;
 
            const string pdf = ".pdf";
            const string txt = ".txt";
 
            var baseFolder = TryGetPackageRootPath(out var rootPath) ? rootPath : string.Empty;
            var packageVersion = TryReadPackageVersion(baseFolder);
 
            for (byte aggrIndex = 0; aggrIndex < adAggregatorResource.Aggregators.Length; aggrIndex++)
            {
                var folderPath = SampleLocator.GetDemoFolder(
                    baseFolder,
                    adAggregatorResource.Aggregators[aggrIndex].DemoFolderName,
                    packageVersion
                    );
                if (!IsProjectAssetsPath(folderPath) || !Directory.Exists(folderPath)) continue;
 
                var hasPdf = Directory.EnumerateFiles(folderPath, "*" + pdf, SearchOption.AllDirectories).Any();
 
                if (deleteDocumentation || !hasPdf)
                {
                    TryDeleteEntireFolder(folderPath);
                }
                else
                {
                    DeleteFolderContentsExceptDocs(folderPath, pdf, txt);
                }
 
                if (!deleteDocumentation) continue;
                folderPath = SampleLocator.GetDocsFolder(
                    baseFolder,
                    adAggregatorResource.Aggregators[aggrIndex].DemoFolderName,
                    packageVersion
                );
                if (!IsProjectAssetsPath(folderPath) || !Directory.Exists(folderPath)) continue;
 
                TryDeleteEntireFolder(folderPath);
            }
 
            if (refresh)
                AssetDatabase.Refresh();
        }
 
        private static bool TryGetPackageRootPath(out string rootPath)
        {
            rootPath = string.Empty;
 
            if (adAggregatorResource == null)
                return false;
 
            var resourcePath = AssetDatabase.GetAssetPath(adAggregatorResource);
            if (string.IsNullOrEmpty(resourcePath))
                return false;
 
            var current = Path.GetDirectoryName(resourcePath)?.Replace('\\', '/');
            while (!string.IsNullOrEmpty(current))
            {
                var packageJsonPath = $"{current}/package.json";
                if (AssetDatabase.LoadAssetAtPath<TextAsset>(packageJsonPath) != null)
                {
                    rootPath = current;
                    return true;
                }
 
                var parent = Path.GetDirectoryName(current)?.Replace('\\', '/');
                if (string.IsNullOrEmpty(parent) || parent == current)
                    break;
 
                current = parent;
            }
 
            return false;
        }
 
        private static string TryReadPackageVersion(string baseFolder)
        {
            if (string.IsNullOrEmpty(baseFolder))
                return string.Empty;
 
            var packageJsonPath = $"{baseFolder}/package.json";
            var packageAsset = AssetDatabase.LoadAssetAtPath<TextAsset>(packageJsonPath);
            if (packageAsset == null)
                return string.Empty;
 
            return ExtractPackageVersion(packageAsset.text);
        }
 
        private static string ExtractPackageVersion(string packageJson)
        {
            if (string.IsNullOrEmpty(packageJson))
                return string.Empty;
 
            const string key = "\"version\"";
            var index = packageJson.IndexOf(key, StringComparison.Ordinal);
            if (index < 0)
                return string.Empty;
 
            index = packageJson.IndexOf(':', index);
            if (index < 0)
                return string.Empty;
 
            index++;
            while (index < packageJson.Length && char.IsWhiteSpace(packageJson[index]))
                index++;
 
            if (index >= packageJson.Length || packageJson[index] != '"')
                return string.Empty;
 
            index++;
            var end = packageJson.IndexOf('"', index);
            return end < 0 ? string.Empty : packageJson[index..end].Trim();
        }
 
        private static string GetAssetPath(Object asset)
        {
            if (asset == null)
                return string.Empty;
 
            var unityPath = AssetDatabase.GetAssetPath(asset);
            if (string.IsNullOrEmpty(unityPath))
                return string.Empty;
 
            var normalized = unityPath.Replace('\\', '/');
 
            const string assetsPrefix = "Assets/";
            if (normalized.StartsWith(assetsPrefix, StringComparison.Ordinal))
                return Path.Combine(Application.dataPath, normalized[assetsPrefix.Length..]).Replace('\\', '/');
 
            const string packagesPrefix = "Packages/";
            if (normalized.StartsWith(packagesPrefix, StringComparison.Ordinal))
            {
                var projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
                return Path.Combine(projectRoot, normalized).Replace('\\', '/');
            }
 
            return normalized;
        }

        private static bool IsProjectAssetsPath(string absoluteOrUnityPath)
        {
            if (string.IsNullOrEmpty(absoluteOrUnityPath))
                return false;
 
            var normalized = absoluteOrUnityPath.Replace('\\', '/');
 
            if (normalized.StartsWith("Packages/", StringComparison.Ordinal))
                return false;
 
            if (normalized.StartsWith("Assets/", StringComparison.Ordinal) ||
                string.Equals(normalized, "Assets", StringComparison.Ordinal))
                return true;
 
            var dataPath = Application.dataPath.Replace('\\', '/');
            return normalized.StartsWith(dataPath, StringComparison.OrdinalIgnoreCase);
        }
 
        #region Delete Folder Helpers
        private static void TryDeleteEntireFolder(string folderPath)
        {
            try
            {
                if (Directory.Exists(folderPath))
                {
                    Directory.Delete(folderPath, true);
                }
            }
            catch { /* ignore */ }
 
            try
            {
                var metaPath = folderPath.TrimEnd('/', '\\') + ".meta";
                if (File.Exists(metaPath))
                {
                    File.Delete(metaPath);
                }
            }
            catch { /* ignore */ }
        }

        private static void DeleteFolderContentsExceptDocs(string rootFolder, params string[] extensions)
        {
            // Delete files except docs.
            foreach (var file in Directory.EnumerateFiles(rootFolder, "*", SearchOption.AllDirectories))
            {
                var ext = Path.GetExtension(file);
                var extensionEqual = extensions.Any(e => string.Equals(ext, e, StringComparison.OrdinalIgnoreCase));
                if (extensionEqual) continue;
 
                try
                {
                    if (File.Exists(file))
                    {
                        File.Delete(file);
                    }
 
                    var metaPath = file + ".meta";
                    if (File.Exists(metaPath))
                    {
                        File.Delete(metaPath);
                    }
                }
                catch { /* ignore */ }
            }
 
            // Prune empty subdirectories (deepest first). Keep the root.
            var allDirs = Directory.EnumerateDirectories(rootFolder, "*", SearchOption.AllDirectories)
                .OrderByDescending(d => d.Length);
 
            foreach (var dir in allDirs)
            {
                try
                {
                    // If directory contains any entries, skip.
                    if (Directory.EnumerateFileSystemEntries(dir).Any()) continue;
 
                    Directory.Delete(dir, false);
 
                    var folderMeta = dir.TrimEnd('/', '\\') + ".meta";
                    if (File.Exists(folderMeta))
                    {
                        File.Delete(folderMeta);
                    }
                }
                catch { /* ignore */ }
            }
        }
        #endregion
    }
}