YandexEditorDummyUpdater.cs

using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using UnityEngine;
 
namespace SCG.SpaceAdMobile
{
    internal static class YandexEditorDummyUpdater
    {
        #region Constants

        private const string AssetsFolder = "Assets";

        private const string FactoryFileName = "YandexMobileAdsClientFactory.cs";

        private const string GeneratedFolderName = "SCG.EditorDummies";

        private const string FactoryPatchMarker = "SCG_ENHANCED_EDITOR_FACTORY_PATCH";
 
        #endregion
 
        #region Fields

        private static readonly Encoding s_utf8Encoding = new UTF8Encoding(false);

        private static readonly string[] s_generatedFileNames =
        {
            "SCGEditorRewardedAdDummy.cs",
            "SCGEditorInterstitialAdDummy.cs",
            "SCGEditorAppOpenAdDummy.cs",
            "SCGEditorBannerClient.cs"
        };

        private static (string FileName, string Content)[] GetGeneratedFiles(YandexData yandexData) => new[]
        {
            (s_generatedFileNames[0], yandexData.RewardedDummyTemplate),
            (s_generatedFileNames[1], yandexData.InterstitialDummyTemplate),
            (s_generatedFileNames[2], yandexData.AppOpenDummyTemplate),
            (s_generatedFileNames[3], yandexData.BannerDummyTemplate)
        };

        private static readonly (string MethodName, string StockReturnLine, string PatchedReturnLine)[] s_factoryPatches =
        {
            CreateFactoryPatch("BuildBannerClient", "DummyBannerClient", "SCGEditorBannerClient"),
            CreateFactoryPatch("BuildInterstitialAdLoaderClient", "DummyInterstitialAdLoaderClient", "SCGEditorInterstitialAdLoaderClient"),
            CreateFactoryPatch("BuildRewardedAdLoaderClient", "DummyRewardedAdLoaderClient", "SCGEditorRewardedAdLoaderClient"),
            CreateFactoryPatch("BuildAppOpenAdLoaderClient", "DummyAppOpenAdLoaderClient", "SCGEditorAppOpenAdLoaderClient")
        };

        private static (string MethodName, string StockReturnLine, string PatchedReturnLine) CreateFactoryPatch(
            string methodName, string stockTypeName, string enhancedTypeName) =>
            (methodName, $"return new {stockTypeName}();", $"return new {enhancedTypeName}(); // {FactoryPatchMarker}");
 
        #endregion

        internal static bool ApplyOrRestore(YandexData yandexData, bool useEnhancedEditorDummies)
        {
            if (UnityEditor.AssetDatabase.IsAssetImportWorkerProcess())
                return false;
 
            if (yandexData == null)
                throw new ArgumentNullException(nameof(yandexData));
 
            if (useEnhancedEditorDummies)
            {
                var generatedChanged = EnsureGeneratedFiles(yandexData);
                var factoryChanged = TryUpdateFactory(yandexData, true, out var appliedFactoryPatch);
                return generatedChanged || (factoryChanged && appliedFactoryPatch);
            }
 
            if (!TryUpdateFactory(yandexData, false, out var restoredFactoryPatch))
                return false;
 
            var deletedFiles = DeleteGeneratedFiles(yandexData);
            return restoredFactoryPatch || deletedFiles;
        }
 
        #region Generated files

        private static bool EnsureGeneratedFiles(YandexData yandexData)
        {
            var folderPath = GetGeneratedFolderPath(yandexData);
            var absoluteFolderPath = ToAbsolutePath(folderPath);
            Directory.CreateDirectory(absoluteFolderPath);
            var changed = false;
 
            foreach (var (fileName, content) in GetGeneratedFiles(yandexData))
            {
                if (string.IsNullOrWhiteSpace(content))
                {
                    Debug.LogWarning($"[{nameof(YandexEditorDummyUpdater)}]: {fileName} template is empty in {nameof(AdAggregatorResource)}.");
                    continue;
                }
 
                var assetsRelativePath = $"{folderPath}/{fileName}";
                var absolutePath = ToAbsolutePath(assetsRelativePath);
                var currentContent = File.Exists(absolutePath) ? File.ReadAllText(absolutePath) : null;
 
                if (string.Equals(currentContent, content, StringComparison.Ordinal))
                    continue;
 
                File.WriteAllText(absolutePath, content, s_utf8Encoding);
                Debug.Log($"[{nameof(YandexEditorDummyUpdater)}]: Updated {fileName}.");
                changed = true;
            }
 
            return changed;
        }

        private static bool DeleteGeneratedFiles(YandexData yandexData)
        {
            var folderPath = GetGeneratedFolderPath(yandexData);
            var changed = false;
 
            // ReSharper disable once LoopCanBeConvertedToQuery
            foreach (var fileName in s_generatedFileNames)
            {
                changed |= DeleteFileWithMeta($"{folderPath}/{fileName}");
            }
 
            return DeleteDirectoryIfEmpty(folderPath) || changed;
        }

        private static bool DeleteFileWithMeta(string assetsRelativePath)
        {
            var absolutePath = ToAbsolutePath(assetsRelativePath);
            var changed = false;
 
            if (File.Exists(absolutePath))
            {
                File.Delete(absolutePath);
                Debug.Log($"[{nameof(YandexEditorDummyUpdater)}]: Deleted {Path.GetFileName(assetsRelativePath)}.");
                changed = true;
            }
 
            var metaPath = absolutePath + ".meta";
            // ReSharper disable once InvertIf
            if (File.Exists(metaPath))
            {
                File.Delete(metaPath);
                changed = true;
            }
 
            return changed;
        }

        private static bool DeleteDirectoryIfEmpty(string assetsRelativePath)
        {
            var absolutePath = ToAbsolutePath(assetsRelativePath);
            if (!Directory.Exists(absolutePath))
                return false;
 
            if (Directory.GetFiles(absolutePath).Length > 0 || Directory.GetDirectories(absolutePath).Length > 0)
                return false;
 
            Directory.Delete(absolutePath);
 
            var metaPath = absolutePath + ".meta";
            if (File.Exists(metaPath))
            {
                File.Delete(metaPath);
            }
 
            return true;
        }

        private static string GetGeneratedFolderPath(YandexData yandexData) =>
            $"{ToAssetsPath(yandexData.AssetPath)}/Common/{GeneratedFolderName}";
 
        #endregion
 
        #region Factory patch

        private static bool TryUpdateFactory(YandexData yandexData, bool applyEnhancedDummies, out bool changed)
        {
            var factoryPath = GetFactoryPath(yandexData);
            var absolutePath = ToAbsolutePath(factoryPath);
            changed = false;
 
            if (!File.Exists(absolutePath))
            {
                Debug.LogWarning(
                    $"[{nameof(YandexEditorDummyUpdater)}]: {FactoryFileName} was not found at '{factoryPath}'.");
                return false;
            }
 
            var original = File.ReadAllText(absolutePath);
            var updated = original;
 
            foreach (var factoryPatch in s_factoryPatches)
            {
                if (TryPatchFactoryMethod(updated, factoryPatch, applyEnhancedDummies, out updated)) continue;
                Debug.LogWarning(
                    $"[{nameof(YandexEditorDummyUpdater)}]: Unable to {(applyEnhancedDummies ? "apply" : "restore")} editor patch for {factoryPatch.MethodName}.");
                return false;
            }
 
            if (string.Equals(original, updated, StringComparison.Ordinal))
                return true;
 
            File.WriteAllText(absolutePath, updated, s_utf8Encoding);
            changed = true;
            Debug.Log(
                $"[{nameof(YandexEditorDummyUpdater)}]: {(applyEnhancedDummies ? "Applied" : "Restored")} editor factory patch.");
            return true;
        }

        private static bool TryPatchFactoryMethod(
            string source,
            (string MethodName, string StockReturnLine, string PatchedReturnLine) patch,
            bool applyEnhancedDummies,
            out string updated)
        {
            var sourceLine = applyEnhancedDummies ? patch.StockReturnLine : patch.PatchedReturnLine;
            var targetLine = applyEnhancedDummies ? patch.PatchedReturnLine : patch.StockReturnLine;
            var methodPattern =
                $@"(internal static [^\r\n]+ {Regex.Escape(patch.MethodName)}\‍([^)]*\‍)\s*\{{\s*#if UNITY_EDITOR\s*){Regex.Escape(sourceLine)}(?=\s*#elif)";
 
            var regex = new Regex(methodPattern, RegexOptions.Singleline | RegexOptions.CultureInvariant);
            var match = regex.Match(source);
            if (match.Success)
            {
                updated = regex.Replace(source, currentMatch => currentMatch.Groups[1].Value + targetLine, 1);
                return true;
            }
 
            var currentPattern =
                $@"internal static [^\r\n]+ {Regex.Escape(patch.MethodName)}\‍([^)]*\‍)\s*\{{\s*#if UNITY_EDITOR\s*{Regex.Escape(targetLine)}(?=\s*#elif)";
            if (Regex.IsMatch(source, currentPattern, RegexOptions.Singleline | RegexOptions.CultureInvariant))
            {
                updated = source;
                return true;
            }
 
            updated = source;
            return false;
        }

        private static string GetFactoryPath(YandexData yandexData) =>
            $"{ToAssetsPath(yandexData.AssetPath)}/Platforms/{FactoryFileName}";
 
        #endregion
 
        #region Path helpers

        private static string ToAssetsPath(string possiblyRelativeToAssetsFolder)
        {
            var path = possiblyRelativeToAssetsFolder.Replace("\\", "/");
            return path.StartsWith($"{AssetsFolder}/", StringComparison.Ordinal) ? path : $"{AssetsFolder}/{path}";
        }

        private static string ToAbsolutePath(string assetsRelativePath)
        {
            var normalizedPath = assetsRelativePath.Replace("\\", "/");
            if (string.Equals(normalizedPath, AssetsFolder, StringComparison.Ordinal))
                return Application.dataPath.Replace("\\", "/");
 
            if (!normalizedPath.StartsWith($"{AssetsFolder}/", StringComparison.Ordinal))
            {
                throw new UnityException($"Path must be {AssetsFolder}-relative: {assetsRelativePath}");
            }
 
            var relativePath = normalizedPath[(AssetsFolder.Length + 1)..];
            return Path.GetFullPath(Path.Combine(Application.dataPath, relativePath)).Replace('\\', '/');
        }
 
        #endregion
    }
}