AdControllerBaseEditor.cs

#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.SceneManagement;
 
namespace SCG.SpaceAdMobile
{
    [CustomEditor(typeof(AdControllerBase), true)]
    [CanEditMultipleObjects]
    internal sealed class AdControllerBaseEditor : UnityEditor.Editor
    {
        #region Constants
 
        private const string ScriptPropertyName = "m_Script";
        private const string IdPropertyName = "<" + nameof(AdControllerBase.Id) + ">k__BackingField";
        private const string GenerateButtonLabel = "Generate";
        private const float GenerateButtonWidth = 72f;
        private const float FieldSpacing = 2f;
 
        #endregion
 
        #region Unity API

        public override void OnInspectorGUI()
        {
            serializedObject.Update();
 
            DrawScriptProperty();
 
            var idProperty = serializedObject.FindProperty(IdPropertyName);
            if (idProperty == null)
            {
                EditorGUILayout.HelpBox($"Unable to locate serialized property '{IdPropertyName}'.", MessageType.Error);
                DrawRemainingProperties();
                serializedObject.ApplyModifiedProperties();
                return;
            }
 
            DrawIdProperty(idProperty);
            DrawStateWarnings();
            DrawRemainingProperties();
 
            serializedObject.ApplyModifiedProperties();
        }
 
        #endregion
 
        #region Inspector
 
        private void DrawScriptProperty()
        {
            var scriptProperty = serializedObject.FindProperty(ScriptPropertyName);
            if (scriptProperty == null)
                return;
 
            using var disabledScope = new EditorGUI.DisabledScope(true);
            EditorGUILayout.PropertyField(scriptProperty);
        }
 
        private void DrawIdProperty(SerializedProperty idProperty)
        {
            var controller = target as AdControllerBase;
            var isSceneInstance = IsSceneInstance(controller);
            var isInteractive = isSceneInstance && !serializedObject.isEditingMultipleObjects;
            var rect = EditorGUILayout.GetControlRect();
            var contentRect = EditorGUI.PrefixLabel(rect, new GUIContent(nameof(IdentifierUtility.Id)));
            var dropdownRect = new Rect(
                contentRect.x,
                contentRect.y,
                Mathf.Max(0f, contentRect.width - GenerateButtonWidth - FieldSpacing),
                contentRect.height);
            var buttonRect = new Rect(
                dropdownRect.xMax + FieldSpacing,
                contentRect.y,
                GenerateButtonWidth,
                contentRect.height);
 
            using (new EditorGUI.DisabledScope(!isInteractive))
            {
                if (EditorGUI.DropdownButton(
                        dropdownRect,
                        new GUIContent(GetDisplayedId(idProperty.stringValue)),
                        FocusType.Passive,
                        EditorStyles.popup))
                {
                    ShowDropdownMenu(controller, idProperty.stringValue, dropdownRect);
                }
 
                // ReSharper disable once InvertIf
                if (GUI.Button(buttonRect, GenerateButtonLabel))
                {
                    serializedObject.ApplyModifiedProperties();
                    AssignId(controller, Guid.NewGuid().ToString());
                    GUIUtility.ExitGUI();
                }
            }
        }
 
        private void DrawStateWarnings()
        {
            if (serializedObject.isEditingMultipleObjects)
            {
                EditorGUILayout.HelpBox("Id selection is disabled for multi-object editing.", MessageType.Info);
                return;
            }
 
            if (target is not AdControllerBase controller)
                return;
 
            if (!IsSceneInstance(controller))
            {
                EditorGUILayout.HelpBox("Id selection is available only for scene instances.", MessageType.Info);
                return;
            }
 
            if (controller.Ad == null)
            {
                EditorGUILayout.HelpBox(
                    "The linked AdUnit is missing. Id changes will be applied only to the controller.",
                    MessageType.Warning);
                return;
            }
 
            if (controller.Ad.TryGetComponent<UndestroyableUtility>(out _))
                return;
 
            EditorGUILayout.HelpBox(
                $"The linked AdUnit is missing {nameof(UndestroyableUtility)}. Id changes will be applied only to the controller, and runtime initialization may still fail.",
                MessageType.Warning);
        }
 
        private void DrawRemainingProperties()
        {
            var iterator = serializedObject.GetIterator();
            var enterChildren = true;
 
            while (iterator.NextVisible(enterChildren))
            {
                enterChildren = false;
                if (iterator.propertyPath is ScriptPropertyName or IdPropertyName)
                    continue;
 
                EditorGUILayout.PropertyField(iterator, true);
            }
        }
 
        #endregion
 
        #region Id Changes
 
        private static void ShowDropdownMenu(AdControllerBase controller, string currentId, Rect dropdownRect)
        {
            if (controller == null)
                return;
 
            var menu = new GenericMenu();
            var candidates = AdControllerIdSceneIndex.GetCandidates(controller);
 
            if (candidates.Count == 0)
            {
                menu.AddDisabledItem(new GUIContent("No matching Ids found in other scenes."));
            }
            else
            {
                foreach (var candidate in candidates)
                {
                    var candidateId = candidate.Id;
                    menu.AddItem(
                        new GUIContent(candidate.DisplayLabel),
                        string.Equals(currentId, candidateId, StringComparison.Ordinal),
                        () => AssignId(controller, candidateId));
                }
            }
 
            GenericMenuPopupHost.Show(menu, GUIUtility.GUIToScreenRect(dropdownRect));
        }
 
        private static void AssignId(AdControllerBase controller, string id)
        {
            if (controller == null || string.IsNullOrWhiteSpace(id))
                return;
 
            var objectsToRecord = new List<UnityEngine.Object> { controller };
            var scenesToMark = new HashSet<Scene>(SceneEqualityComparer.Instance) { controller.gameObject.scene };
 
            UndestroyableUtility undestroyable = null;
            if (controller.Ad != null && controller.Ad.TryGetComponent(out undestroyable))
            {
                objectsToRecord.Add(undestroyable);
                scenesToMark.Add(undestroyable.gameObject.scene);
            }
 
            Undo.RecordObjects(objectsToRecord.ToArray(), $"Change {nameof(IdentifierUtility.Id)}");
 
            SetIdValue(controller, id);
            if (undestroyable != null)
                SetIdValue(undestroyable, id);
 
            foreach (var scene in scenesToMark.Where(scene => scene.IsValid()))
                EditorSceneManager.MarkSceneDirty(scene);
        }
 
        private static void SetIdValue(IdentifierUtility targetUtility, string id)
        {
            var serializedObject = new SerializedObject(targetUtility);
            var property = serializedObject.FindProperty(IdPropertyName);
            if (property == null)
                return;
 
            serializedObject.Update();
            property.stringValue = id;
            serializedObject.ApplyModifiedPropertiesWithoutUndo();
        }
 
        private static string GetDisplayedId(string id) =>
            string.IsNullOrWhiteSpace(id) ? "<Empty>" : id;
 
        private static bool IsSceneInstance(AdControllerBase controller) =>
            controller != null &&
            controller.gameObject.scene.IsValid() &&
            !string.IsNullOrWhiteSpace(controller.gameObject.scene.path) &&
            controller.gameObject.scene.path.EndsWith(".unity", StringComparison.OrdinalIgnoreCase);
 
        #endregion
    }

    internal static class AdControllerIdSceneIndex
    {
        #region Constants
 
        private const string IdPropertyName = "<" + nameof(AdControllerBase.Id) + ">k__BackingField";
        private const string GameObjectDocumentType = "1";
        private const string TransformDocumentType = "4";
        private const string MonoBehaviourDocumentType = "114";
        private const string RectTransformDocumentType = "224";
        private static readonly Regex documentHeaderRegex = new(@"^--- !u!(\d+) &(-?\d+)", RegexOptions.Compiled);
        private static readonly Regex fileIdRegex = new(@"\{fileID:\s*(-?\d+)", RegexOptions.Compiled);
        private static readonly Regex scriptGuidRegex = new(@"\{fileID:\s*11500000,\s*guid:\s*([0-9a-fA-F]+),\s*type:\s*3\s*\}", RegexOptions.Compiled);
 
        #endregion
 
        #region Public API

        public static IReadOnlyList<AdControllerIdCandidate> GetCandidates(AdControllerBase controller)
        {
            if (controller == null)
                return Array.Empty<AdControllerIdCandidate>();
 
            var scriptGuid = GetScriptGuid(controller);
            if (string.IsNullOrWhiteSpace(scriptGuid))
                return Array.Empty<AdControllerIdCandidate>();
 
            var scenePaths = GetSourceScenePaths(controller.gameObject.scene.path);
            if (scenePaths.Count == 0)
                return Array.Empty<AdControllerIdCandidate>();
 
            var seenIds = new HashSet<string>(StringComparer.Ordinal);
 
            return (from scenePath in scenePaths
                    from candidate in ParseScene(scenePath, scriptGuid)
                    where seenIds.Add(candidate.Id)
                    select candidate).ToList();
        }
 
        #endregion
 
        #region Scene Discovery
 
        private static List<string> GetSourceScenePaths(string currentScenePath)
        {
            var buildScenes = EditorBuildSettings.scenes
                .Select(scene => scene.path)
                .Where(IsValidSceneAssetPath)
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .Where(path => !string.Equals(path, currentScenePath, StringComparison.OrdinalIgnoreCase))
                .ToList();
 
            if (buildScenes.Count > 0)
                return buildScenes;
 
            return AssetDatabase.FindAssets("t:Scene", new[] { "Assets" })
                .Select(AssetDatabase.GUIDToAssetPath)
                .Where(IsValidSceneAssetPath)
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .Where(path => !string.Equals(path, currentScenePath, StringComparison.OrdinalIgnoreCase))
                .OrderBy(path => path, StringComparer.OrdinalIgnoreCase)
                .ToList();
        }
 
        private static bool IsValidSceneAssetPath(string scenePath) =>
            !string.IsNullOrWhiteSpace(scenePath) &&
            scenePath.EndsWith(".unity", StringComparison.OrdinalIgnoreCase) &&
            File.Exists(Path.GetFullPath(scenePath));
 
        private static string GetScriptGuid(MonoBehaviour behaviour)
        {
            if (behaviour == null)
                return null;
 
            var script = MonoScript.FromMonoBehaviour(behaviour);
            if (script == null)
                return null;
 
            var assetPath = AssetDatabase.GetAssetPath(script);
            return string.IsNullOrWhiteSpace(assetPath) ? null : AssetDatabase.AssetPathToGUID(assetPath);
        }
 
        #endregion
 
        #region YAML Parsing
 
        private static IEnumerable<AdControllerIdCandidate> ParseScene(string scenePath, string scriptGuid)
        {
            var sceneData = ParseSceneData(scenePath, scriptGuid);
            if (sceneData == null)
                yield break;
 
            var sceneName = Path.GetFileNameWithoutExtension(scenePath);
            foreach (var component in sceneData.Components)
            {
                var objectPath = sceneData.GetGameObjectPath(component.GameObjectFileId);
                if (string.IsNullOrWhiteSpace(objectPath))
                    objectPath = "<Unknown>";
 
                yield return new AdControllerIdCandidate(
                    component.Id,
                    scenePath,
                    objectPath,
                    $"{sceneName} / {objectPath} [{component.Id}]");
            }
        }
 
        private static ParsedSceneData ParseSceneData(string scenePath, string scriptGuid)
        {
            var parsed = new ParsedSceneData();
            var fullPath = Path.GetFullPath(scenePath);
            if (!File.Exists(fullPath))
                return null;
 
            string documentType = null;
            string documentFileId = null;
            string gameObjectFileId = null;
            string parentTransformFileId = null;
            string gameObjectName = null;
            string componentId = null;
            string componentScriptGuid = null;
 
            foreach (var rawLine in File.ReadLines(fullPath))
            {
                var line = rawLine.TrimStart();
                var headerMatch = documentHeaderRegex.Match(line);
                if (headerMatch.Success)
                {
                    FlushCurrentDocument();
 
                    documentType = headerMatch.Groups[1].Value;
                    documentFileId = headerMatch.Groups[2].Value;
                    gameObjectFileId = null;
                    parentTransformFileId = null;
                    gameObjectName = null;
                    componentId = null;
                    componentScriptGuid = null;
                    continue;
                }
 
                switch (documentType)
                {
                    case GameObjectDocumentType:
                        if (line.StartsWith("m_Name:", StringComparison.Ordinal))
                            gameObjectName = line["m_Name:".Length..].Trim();
                        break;
 
                    case TransformDocumentType:
                    case RectTransformDocumentType:
                        if (line.StartsWith("m_GameObject:", StringComparison.Ordinal))
                            gameObjectFileId = ExtractFileId(line);
                        else if (line.StartsWith("m_Father:", StringComparison.Ordinal))
                            parentTransformFileId = ExtractFileId(line);
                        break;
 
                    case MonoBehaviourDocumentType:
                        if (line.StartsWith("m_GameObject:", StringComparison.Ordinal))
                            gameObjectFileId = ExtractFileId(line);
                        else if (line.StartsWith("m_Script:", StringComparison.Ordinal))
                            componentScriptGuid = ExtractScriptGuid(line);
                        else if (line.StartsWith($"{IdPropertyName}:", StringComparison.Ordinal))
                            componentId = line[$"{IdPropertyName}:".Length..].Trim();
                        break;
                }
            }
 
            FlushCurrentDocument();
            return parsed;
 
            void FlushCurrentDocument()
            {
                if (string.IsNullOrWhiteSpace(documentType) || string.IsNullOrWhiteSpace(documentFileId))
                    return;
 
                switch (documentType)
                {
                    case GameObjectDocumentType:
                        parsed.GameObjectNames[documentFileId] = string.IsNullOrWhiteSpace(gameObjectName)
                            ? "<Unnamed>"
                            : UnquoteYamlValue(gameObjectName);
                        break;
 
                    case TransformDocumentType:
                    case RectTransformDocumentType:
                        if (!string.IsNullOrWhiteSpace(gameObjectFileId))
                        {
                            parsed.Transforms[documentFileId] = new AdControllerSceneTransformInfo(
                                gameObjectFileId,
                                NormalizeFileId(parentTransformFileId));
                        }
                        break;
 
                    case MonoBehaviourDocumentType:
                        if (string.Equals(componentScriptGuid, scriptGuid, StringComparison.OrdinalIgnoreCase) &&
                            !string.IsNullOrWhiteSpace(gameObjectFileId) &&
                            !string.IsNullOrWhiteSpace(componentId))
                        {
                            parsed.Components.Add(new AdControllerSceneComponentInfo(gameObjectFileId, componentId));
                        }
                        break;
                }
            }
        }
 
        private static string ExtractFileId(string line)
        {
            var match = fileIdRegex.Match(line);
            return match.Success ? match.Groups[1].Value : null;
        }
 
        private static string ExtractScriptGuid(string line)
        {
            var match = scriptGuidRegex.Match(line);
            return match.Success ? match.Groups[1].Value : null;
        }
 
        private static string NormalizeFileId(string fileId) =>
            string.IsNullOrWhiteSpace(fileId) || fileId == "0" ? null : fileId;
 
        private static string UnquoteYamlValue(string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return value;
 
            if (value.Length >= 2 && value[0] == '\'' && value[^1] == '\'')
                return value[1..^1].Replace("''", "'");
 
            return value;
        }
 
        #endregion
    }

    internal sealed class ParsedSceneData
    {
        #region Fields
 
        private readonly Dictionary<string, string> gameObjectPathCache = new(StringComparer.Ordinal);
        private Dictionary<string, AdControllerSceneTransformInfo> transformsByGameObject;
 
        #endregion
 
        #region Properties

        public Dictionary<string, string> GameObjectNames { get; } = new(StringComparer.Ordinal);

        public Dictionary<string, AdControllerSceneTransformInfo> Transforms { get; } = new(StringComparer.Ordinal);

        public List<AdControllerSceneComponentInfo> Components { get; } = new();
 
        #endregion
 
        #region Public API

        public string GetGameObjectPath(string gameObjectFileId) =>
            string.IsNullOrWhiteSpace(gameObjectFileId)
                ? null
                : gameObjectPathCache.TryGetValue(gameObjectFileId, out var cachedPath)
                    ? cachedPath
                    : gameObjectPathCache[gameObjectFileId] = BuildGameObjectPath(gameObjectFileId,
                        new HashSet<string>(StringComparer.Ordinal));
 
        #endregion
 
        #region Helpers
 
        private string BuildGameObjectPath(string gameObjectFileId, HashSet<string> visitedGameObjects)
        {
            if (!visitedGameObjects.Add(gameObjectFileId))
                return TryGetGameObjectName(gameObjectFileId);
 
            var name = TryGetGameObjectName(gameObjectFileId);
            var byGameObject = GetTransformsByGameObject();
 
            if (!byGameObject.TryGetValue(gameObjectFileId, out var transform) ||
                string.IsNullOrWhiteSpace(transform.ParentTransformFileId) ||
                !Transforms.TryGetValue(transform.ParentTransformFileId, out var parentTransform))
                return name;
 
            var parentPath = BuildGameObjectPath(parentTransform.GameObjectFileId, visitedGameObjects);
            return string.IsNullOrWhiteSpace(parentPath) ? name : $"{parentPath}/{name}";
        }
 
        private Dictionary<string, AdControllerSceneTransformInfo> GetTransformsByGameObject()
        {
            if (transformsByGameObject != null)
                return transformsByGameObject;
 
            transformsByGameObject = new Dictionary<string, AdControllerSceneTransformInfo>(
                Transforms.Count, StringComparer.Ordinal);
 
            foreach (var transform in Transforms.Values)
                transformsByGameObject.TryAdd(transform.GameObjectFileId, transform);
 
            return transformsByGameObject;
        }
 
        private string TryGetGameObjectName(string gameObjectFileId) =>
            GameObjectNames.GetValueOrDefault(gameObjectFileId, "<Unknown>");
 
        #endregion
    }

    internal sealed class SceneEqualityComparer : IEqualityComparer<Scene>
    {
        #region Static

        public static SceneEqualityComparer Instance { get; } = new();
 
        #endregion
 
        #region Equality

        public bool Equals(Scene x, Scene y) =>
            x == y &&
            string.Equals(x.path, y.path, StringComparison.OrdinalIgnoreCase);

        public int GetHashCode(Scene obj) =>
            HashCode.Combine(
                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.path ?? string.Empty),
                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.name ?? string.Empty),
                obj.buildIndex);
 
        #endregion
    }

    internal sealed class AdControllerSceneTransformInfo
    {
        #region Construction

        public AdControllerSceneTransformInfo(string gameObjectFileId, string parentTransformFileId)
        {
            GameObjectFileId = gameObjectFileId;
            ParentTransformFileId = parentTransformFileId;
        }
 
        #endregion
 
        #region Properties

        public string GameObjectFileId { get; }

        public string ParentTransformFileId { get; }
 
        #endregion
    }

    internal sealed class AdControllerSceneComponentInfo
    {
        #region Construction

        public AdControllerSceneComponentInfo(string gameObjectFileId, string id)
        {
            GameObjectFileId = gameObjectFileId;
            Id = id;
        }
 
        #endregion
 
        #region Properties

        public string GameObjectFileId { get; }

        public string Id { get; }
 
        #endregion
    }

    internal sealed class AdControllerIdCandidate
    {
        #region Construction

        public AdControllerIdCandidate(string id, string scenePath, string objectPath, string displayLabel)
        {
            Id = id;
            ScenePath = scenePath;
            ObjectPath = objectPath;
            DisplayLabel = displayLabel;
        }
 
        #endregion
 
        #region Properties

        public string Id { get; }

        public string ScenePath { get; }

        public string ObjectPath { get; }

        public string DisplayLabel { get; }
 
        #endregion
    }
}
#endif