YandexAssemblyUpdater.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using UnityEditor;
using UnityEngine;
using PackageInfo = UnityEditor.PackageManager.PackageInfo;
 
namespace SCG.SpaceAdMobile
{
    [InitializeOnLoad]
    internal class YandexAssemblyUpdater
    {
        #region Common paths
 
        private const string AssetsFolder = "Assets";
        private const string PackagesFolder = "Packages";
 
        #endregion
 
        #region Yandex updater asset constants
 
        private const string YandexUpdaterScriptFileName = "update_yandex_sdk.py";
        private const string PackageImportBridgeTemplateFileName = "PackageImportBridgeTemplate.cs.txt";
        private const string PackageImportBridgeFileName = "PackageImportBridge.cs";
 
        #endregion
 
        #region CS0414 suppression constants
 
        private const string SuppressYandex0414WarningsPreferenceKey = nameof(SpaceAdMobile) + ".SuppressYandex0414Warnings";
        private const string WarningCode0067 = "67";
        private const string WarningCode0414 = "414";
        private const string Warning414SuppressionMarker = "// UNITY_SUPPRESS_CS0414";
 
        private static readonly string[] s_cs0414WarningFileNames =
        {
            "DummyRewardedAdLoaderClient.cs",
            "DummyInterstitialAdLoaderClient.cs",
            "DummyAppOpenAdLoaderClient.cs"
        };
 
        private static readonly Regex s_warningDisableRegex = new(
            @"^(?<prefix>\s*#pragma\s+warning\s+disable\s+)(?<codes>[^/\r\n]+?)(?<comment>\s*//.*)?$",
            RegexOptions.CultureInvariant);
 
        #endregion
 
        #region Reload Fix
        private const string AdRevenueAutoCollectionResolverFileName = "AdRevenueAutoCollectionResolver.cs";
        private const string ImportWorkerGuardComment = "SCG_IMPORT_WORKER_GUARD";
        private const string ImportWorkerGuardCondition = "AssetDatabase.IsAssetImportWorkerProcess()";
 
        private static readonly string[] adRevenueAutoCollectionResolverGuardMethods =
        {
            "internal static void Init()",
            "private static void ApplyDefines()"
        };
        #endregion
 
        #region iOS Fix: Readonly & Constants
        private static readonly string[] iosMethodSignatures =
        {
            "private static void ModifyPlist(string pathToBuildProject)",
            "public static void OnPostProcessBuild(BuildTarget buildTarget, string pathToBuiltProject)"
        };
 
        private const string IosFixIfDefine = "#if UNITY_IOS || UNITY_TVOS // " + IosWrappedComment;
        private const string IosFixEndIfDefine = "#endif // " + IosWrappedComment;
        private const string IosUsingStarts = "using UnityEditor.iOS.Xcode";
        private const string IosIfCondition = "BuildTarget.iOS"; // if (buildTarget == BuildTarget.iOS)
        private const string IosWrappedComment = "UNITY_IOS_WRAPPED";
        #endregion
 
        #region State

        private static YandexData yandexData;

        private static bool is0414WarningSuppressionUpdateScheduled;
 
        #endregion
 
        #region Bootstrap
 
        private static bool isUpdateScheduled;
        private const string ActiveSdkSessionPath = "Library/YandexSdkUpdater/active-session.json";
        private const double SdkSessionCheckIntervalSeconds = 1;
        private static double nextSdkSessionCheckTime;

        private static bool IsSdkUpdateRunning()
        {
            if (EditorApplication.timeSinceStartup < nextSdkSessionCheckTime)
                return true;
 
            var running = CheckSdkUpdateSession();
            if (running)
                nextSdkSessionCheckTime = EditorApplication.timeSinceStartup + SdkSessionCheckIntervalSeconds;
 
            return running;
        }

        private static bool CheckSdkUpdateSession()
        {
            if (!File.Exists(ActiveSdkSessionPath))
                return false;
 
            try
            {
                var marker = File.ReadAllText(ActiveSdkSessionPath);
                var match = Regex.Match(marker, @"""ProcessId""\s*:\s*(\d+)");
                if (!match.Success || !int.TryParse(match.Groups[1].Value, out var processId))
                    return true;
 
                using var process = System.Diagnostics.Process.GetProcessById(processId);
                return !process.HasExited;
            }
            catch (ArgumentException)
            {
                return false;
            }
            catch (IOException)
            {
                return true;
            }
            catch (System.ComponentModel.Win32Exception)
            {
                return true;
            }
        }
 
        static YandexAssemblyUpdater()
        {
            if (AssetDatabase.IsAssetImportWorkerProcess())
                return;
 
            if (!DefineSymbolsManager.HasDefineSymbol(DefineSymbolsManager.YandexMobileAds))
                return;
 
            if (IsSdkUpdateRunning())
            {
                ScheduleUpdate();
                return;
            }
 
            var resource = AdAggregatorResource.Instance;
            var data = GetConfiguredYandexData(resource);
            if (data != null &&
                IsRuntimeDefineConstraintConfigured(data) &&
                IsYandexUpdaterAssetsSynchronized(data) &&
                Is0414WarningSuppressionApplied(data, SuppressYandex0414Warnings) &&
                !FixIosReferences(false))
                return;
 
            if (data != null)
                ScheduleUpdate();
        }
 
        private static void ScheduleUpdate()
        {
            if (isUpdateScheduled)
                return;
 
            isUpdateScheduled = true;
            EditorApplication.delayCall += UpdateOnDelayCall;
        }
 
        private static void UpdateOnDelayCall()
        {
            EditorApplication.delayCall -= UpdateOnDelayCall;
 
            if (AssetDatabase.IsAssetImportWorkerProcess())
            {
                isUpdateScheduled = false;
                return;
            }
 
            if (EditorApplication.isUpdating || EditorApplication.isCompiling || IsSdkUpdateRunning())
            {
                isUpdateScheduled = false;
                ScheduleUpdate();
                return;
            }
 
            isUpdateScheduled = false;
            Update();
        }
 
        #endregion

        internal static void Update()
        {
            if (AssetDatabase.IsAssetImportWorkerProcess())
                return;
 
            if (IsSdkUpdateRunning())
            {
                ScheduleUpdate();
                return;
            }
 
            var resource = AdAggregatorResource.Instance;
            if (resource == null)
            {
                throw new UnityException($"The resource file '{nameof(AdAggregatorResource)}' is missing. Please reinstall the package.");
            }
 
            resource.UseEnhancedYandexEditorDummies =
                EditorPrefs.GetBool(AdAggregatorResource.KeyUseEnhancedYandexEditorDummies, false);
            yandexData = GetConfiguredYandexData(resource) ??
                throw new UnityException("Yandex configuration is missing in AdAggregatorResource.");
            var runtimeDefineConfigured = IsRuntimeDefineConstraintConfigured(yandexData);
            var changed =
                CreateYandexAssemblyDefinition() |
                SynchronizeYandexUpdaterAssets() |
                Synchronize0414WarningSuppressions(yandexData) |
                ApplyOrRestoreEnhancedEditorDummies(resource.UseEnhancedYandexEditorDummies) |
                UpdateAssemblyReferences() |
                PatchAdRevenueAutoCollectionResolverGuard() |
                FixIosReferences();
 
            if (!runtimeDefineConfigured)
                ScheduleRuntimeDefineConstraintUpdate();
 
            if (changed && !EditorApplication.isUpdating)
                EditorApplication.delayCall += AssetDatabase.Refresh;
        }
 
        #region Yandex configuration

        private static YandexData GetConfiguredYandexData(AdAggregatorResource resource)
        {
            if (resource != null)
                yandexData = resource.Yandex;
 
            return yandexData;
        }
 
        #endregion
 
        #region Yandex asmdef creation

        private static bool CreateYandexAssemblyDefinition()
        {
            var changed = false;
 
            // Runtime asmdef
            var assetsRuntimeDir = ToAssetsPath(yandexData.AssetPath);
            changed |= EnsureFolderExists(assetsRuntimeDir);
 
            var runtimeAsmdefRel = $"{assetsRuntimeDir}/{yandexData.MainAsmdefName}.asmdef";
            changed |= EnsureAsmdefExists(runtimeAsmdefRel, yandexData.AsmdefTemplate,
                $"[{nameof(YandexAssemblyUpdater)}]: {Path.GetFileName(runtimeAsmdefRel)} has been successfully created!");
 
            // Editor asmdef (only if the folder exists or we can create it)
            var assetsEditorDir = ToAssetsPath(yandexData.EditorPath);
 
            changed |= EnsureFolderExists(assetsEditorDir);
            var editorAsmdefRel = $"{assetsEditorDir}/{yandexData.EditorAsmdefName}.asmdef";
            changed |= EnsureAsmdefExists(editorAsmdefRel, yandexData.AsmdefEditorTemplate,
                $"[{nameof(YandexAssemblyUpdater)}]: {Path.GetFileName(editorAsmdefRel)} has been successfully created!");
 
            return changed;
        }
 
        private static void ScheduleRuntimeDefineConstraintUpdate()
        {
            EditorApplication.delayCall -= AddRuntimeDefineConstraintOnDelayCall;
            EditorApplication.delayCall += AddRuntimeDefineConstraintOnDelayCall;
        }
 
        private static void AddRuntimeDefineConstraintOnDelayCall()
        {
            EditorApplication.delayCall -= AddRuntimeDefineConstraintOnDelayCall;
 
            if (AssetDatabase.IsAssetImportWorkerProcess() || EditorApplication.isUpdating || EditorApplication.isCompiling || IsSdkUpdateRunning())
            {
                ScheduleRuntimeDefineConstraintUpdate();
                return;
            }
 
            if (yandexData == null)
                return;
 
            if (IsRuntimeDefineConstraintConfigured(yandexData))
                return;
 
            var assetsRuntimeDir = ToAssetsPath(yandexData.AssetPath);
            var runtimeAsmdefRel = $"{assetsRuntimeDir}/{yandexData.MainAsmdefName}.asmdef";
            var runtimeAsmdefAbs = ToAbsolutePath(runtimeAsmdefRel);
            if (!File.Exists(runtimeAsmdefAbs))
                return;
 
            var original = File.ReadAllText(runtimeAsmdefAbs, Encoding.UTF8);
            var updated = AddDefineConstraint(original, DefineSymbolsManager.YandexMobileAds);
            if (string.Equals(original, updated, StringComparison.Ordinal))
                return;
 
            File.WriteAllText(runtimeAsmdefAbs, updated, Encoding.UTF8);
            Debug.Log($"[{nameof(YandexAssemblyUpdater)}]: Added {DefineSymbolsManager.YandexMobileAds} define constraint to {Path.GetFileName(runtimeAsmdefRel)}.");
            AssetDatabase.ImportAsset(runtimeAsmdefRel);
        }
 
        private static bool IsRuntimeDefineConstraintConfigured(YandexData data)
        {
            if (data == null)
                return false;
 
            var assetsRuntimeDir = ToAssetsPath(data.AssetPath);
            var runtimeAsmdefRel = $"{assetsRuntimeDir}/{data.MainAsmdefName}.asmdef";
            var runtimeAsmdefAbs = ToAbsolutePath(runtimeAsmdefRel);
            return File.Exists(runtimeAsmdefAbs) &&
                   File.ReadAllText(runtimeAsmdefAbs, Encoding.UTF8)
                       .Contains($"\"{DefineSymbolsManager.YandexMobileAds}\"", StringComparison.Ordinal);
        }
 
        #endregion
 
        #region Yandex SDK updater assets

        private static bool SynchronizeYandexUpdaterAssets()
        {
            var runtimeDirectory = ToAssetsPath(yandexData.AssetPath);
            var editorDirectory = ToAssetsPath(yandexData.EditorPath);
            var templateDirectory = GetYandexSupportTemplateDirectory();
 
            var changed = SynchronizeAssetFile(
                $"{templateDirectory}/{YandexUpdaterScriptFileName}",
                $"{runtimeDirectory}/{YandexUpdaterScriptFileName}");
            changed |= SynchronizeAssetFile(
                $"{templateDirectory}/{PackageImportBridgeTemplateFileName}",
                $"{editorDirectory}/{PackageImportBridgeFileName}");
 
            return changed;
        }

        private static bool IsYandexUpdaterAssetsSynchronized(YandexData data)
        {
            if (data == null)
                return false;
 
            var runtimeDirectory = ToAssetsPath(data.AssetPath);
            var editorDirectory = ToAssetsPath(data.EditorPath);
            var templateDirectory = GetYandexSupportTemplateDirectory();
 
            return AssetFilesMatch(
                       $"{templateDirectory}/{YandexUpdaterScriptFileName}",
                       $"{runtimeDirectory}/{YandexUpdaterScriptFileName}") &&
                   AssetFilesMatch(
                       $"{templateDirectory}/{PackageImportBridgeTemplateFileName}",
                       $"{editorDirectory}/{PackageImportBridgeFileName}");
        }
 
        private static string GetYandexSupportTemplateDirectory()
        {
            var templateScriptPath = AssetDatabase.FindAssets($"{nameof(YandexAssemblyUpdater)} t:MonoScript")
                .Select(AssetDatabase.GUIDToAssetPath)
                .FirstOrDefault(path =>
                {
                    var script = AssetDatabase.LoadAssetAtPath<MonoScript>(path);
                    return script != null && script.GetClass() == typeof(YandexAssemblyUpdater);
                });
            return string.IsNullOrEmpty(templateScriptPath)
                ? throw new UnityException($"The source file for {nameof(YandexAssemblyUpdater)} could not be found.")
                : Path.GetDirectoryName(templateScriptPath)?.Replace('\\', '/') ??
                  throw new UnityException(
                      $"The source directory for {nameof(YandexAssemblyUpdater)} could not be found.");
        }

        private static bool SynchronizeAssetFile(string templateAssetPath, string targetAssetPath)
        {
            var templatePath = ToAbsolutePath(templateAssetPath);
            if (!File.Exists(templatePath))
            {
                Debug.LogWarning($"[{nameof(YandexAssemblyUpdater)}]: Yandex updater template was not found: {templateAssetPath}");
                return false;
            }
 
            var targetPath = ToAbsolutePath(targetAssetPath);
            var templateContent = File.ReadAllText(templatePath, Encoding.UTF8);
            if (File.Exists(targetPath) &&
                string.Equals(File.ReadAllText(targetPath, Encoding.UTF8), templateContent, StringComparison.Ordinal))
            {
                return false;
            }
 
            var targetDirectory = Path.GetDirectoryName(targetPath);
            if (!string.IsNullOrEmpty(targetDirectory))
                Directory.CreateDirectory(targetDirectory);
 
            File.WriteAllText(targetPath, templateContent, new UTF8Encoding(false));
            return true;
        }

        private static bool AssetFilesMatch(string templateAssetPath, string targetAssetPath)
        {
            var templatePath = ToAbsolutePath(templateAssetPath);
            var targetPath = ToAbsolutePath(targetAssetPath);
            return File.Exists(templatePath) && File.Exists(targetPath) &&
                   string.Equals(
                       File.ReadAllText(templatePath, Encoding.UTF8),
                       File.ReadAllText(targetPath, Encoding.UTF8),
                       StringComparison.Ordinal);
        }
 
        #endregion
 
        #region CS0414 warning suppression

        internal static bool SuppressYandex0414Warnings
        {
            get => EditorPrefs.GetBool(SuppressYandex0414WarningsPreferenceKey, false);
            set
            {
                if (EditorPrefs.GetBool(SuppressYandex0414WarningsPreferenceKey, false) == value)
                    return;
 
                EditorPrefs.SetBool(SuppressYandex0414WarningsPreferenceKey, value);
                Schedule0414WarningSuppressionUpdate();
            }
        }

        private static void Schedule0414WarningSuppressionUpdate()
        {
            if (is0414WarningSuppressionUpdateScheduled)
                return;
 
            is0414WarningSuppressionUpdateScheduled = true;
            EditorApplication.delayCall += Update0414WarningSuppressionsOnDelayCall;
        }

        private static void Update0414WarningSuppressionsOnDelayCall()
        {
            EditorApplication.delayCall -= Update0414WarningSuppressionsOnDelayCall;
 
            if (AssetDatabase.IsAssetImportWorkerProcess())
            {
                is0414WarningSuppressionUpdateScheduled = false;
                return;
            }
 
            if (EditorApplication.isUpdating || EditorApplication.isCompiling || IsSdkUpdateRunning())
            {
                EditorApplication.delayCall += Update0414WarningSuppressionsOnDelayCall;
                return;
            }
 
            is0414WarningSuppressionUpdateScheduled = false;
            var data = GetConfiguredYandexData(AdAggregatorResource.Instance);
            if (data == null || !Synchronize0414WarningSuppressions(data))
                return;
 
            EditorApplication.delayCall += AssetDatabase.Refresh;
        }

        private static bool Synchronize0414WarningSuppressions(YandexData data)
        {
            if (data == null)
                return false;
 
            var shouldSuppress = SuppressYandex0414Warnings;
            var changedFileNames = new List<string>();
            foreach (var assetPath in Get0414WarningAssetPaths(data))
            {
                var absolutePath = ToAbsolutePath(assetPath);
                if (!File.Exists(absolutePath))
                    continue;
 
                var original = File.ReadAllText(absolutePath, Encoding.UTF8);
                var updated = shouldSuppress
                    ? Add0414WarningSuppression(original)
                    : Remove0414WarningSuppression(original);
                if (string.Equals(original, updated, StringComparison.Ordinal))
                    continue;
 
                File.WriteAllText(absolutePath, updated, new UTF8Encoding(false));
                changedFileNames.Add(Path.GetFileName(assetPath));
            }
 
            if (changedFileNames.Count == 0)
                return false;
 
            var action = shouldSuppress ? "Added" : "Removed";
            var direction = shouldSuppress ? "to" : "from";
            Debug.Log($"[{nameof(YandexAssemblyUpdater)}]: {action} warning 414 suppression {direction} {string.Join(", ", changedFileNames)}.");
            return true;
        }

        private static bool Is0414WarningSuppressionApplied(YandexData data, bool shouldSuppress)
        {
            if (data == null)
                return true;
 
            foreach (var assetPath in Get0414WarningAssetPaths(data))
            {
                var absolutePath = ToAbsolutePath(assetPath);
                if (!File.Exists(absolutePath))
                {
                    if (shouldSuppress)
                        return false;
 
                    continue;
                }
 
                var lines = File.ReadAllLines(absolutePath, Encoding.UTF8);
                if (!shouldSuppress)
                {
                    if (HasOwned0414WarningSuppression(lines))
                        return false;
 
                    continue;
                }
 
                var foundWarning67Directive = false;
                for (var index = 0; index < lines.Length; index++)
                {
                    var warningCodes = GetDisabledWarningCodes(lines[index]);
                    if (!warningCodes.Contains(WarningCode0067, StringComparer.Ordinal))
                        continue;
 
                    foundWarning67Directive = true;
                    if (!warningCodes.Contains(WarningCode0414, StringComparer.Ordinal))
                        return false;
 
                    var match = s_warningDisableRegex.Match(lines[index]);
                    var hasInlineMarker = Has0414WarningSuppressionMarker(match.Groups["comment"].Value);
                    var hasPreviousMarker = index > 0 && IsStandalone0414WarningSuppressionMarker(lines[index - 1]);
                    if (!hasInlineMarker && !hasPreviousMarker)
                        return false;
                }
 
                if (!foundWarning67Directive)
                    return false;
            }
 
            return true;
        }

        internal static void Validate0414WarningSuppressionPreference()
        {
            if (IsSdkUpdateRunning())
                return;
 
            if (!DefineSymbolsManager.HasDefineSymbol(DefineSymbolsManager.YandexMobileAds))
                return;
 
            var data = GetConfiguredYandexData(AdAggregatorResource.Instance);
            EditorPrefs.SetBool(SuppressYandex0414WarningsPreferenceKey,
                data != null && Is0414WarningSuppressionApplied(data, true));
        }

        private static string[] Get0414WarningAssetPaths(YandexData data)
        {
            var commonDirectory = $"{ToAssetsPath(data.AssetPath)}/Common";
            return s_cs0414WarningFileNames
                .Select(fileName => $"{commonDirectory}/{fileName}")
                .ToArray();
        }

        private static string Add0414WarningSuppression(string source)
        {
            if (string.IsNullOrEmpty(source))
                return source;
 
            var newline = source.Contains("\r\n", StringComparison.Ordinal) ? "\r\n" : "\n";
            var lines = source.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None).ToList();
            var changed = false;
 
            for (var index = 0; index < lines.Count; index++)
            {
                var match = s_warningDisableRegex.Match(lines[index]);
                if (!match.Success)
                    continue;
 
                var warningCodes = match.Groups["codes"].Value
                    .Split(',')
                    .Select(code => code.Trim())
                    .ToArray();
                if (!warningCodes.Contains(WarningCode0067, StringComparer.Ordinal))
                {
                    continue;
                }
 
                var comment = match.Groups["comment"].Value;
                var hasInlineMarker = Has0414WarningSuppressionMarker(comment);
                var hasPreviousMarker = index > 0 && IsStandalone0414WarningSuppressionMarker(lines[index - 1]);
                var hasWarning414 = warningCodes.Contains(WarningCode0414, StringComparer.Ordinal);
                if (hasWarning414 && !hasInlineMarker && !hasPreviousMarker)
                    continue;
 
                var updatedCodes = match.Groups["codes"].Value.TrimEnd();
                if (!hasWarning414)
                    updatedCodes += $", {WarningCode0414}";
 
                if (!hasInlineMarker)
                    comment = Append0414WarningSuppressionMarker(comment);
 
                lines[index] = $"{match.Groups["prefix"].Value}{updatedCodes}{comment}";
                if (hasPreviousMarker)
                {
                    lines.RemoveAt(index - 1);
                    index--;
                }
 
                changed = true;
            }
 
            return changed ? string.Join(newline, lines) : source;
        }

        private static string Remove0414WarningSuppression(string source)
        {
            if (string.IsNullOrEmpty(source))
                return source;
 
            var newline = source.Contains("\r\n", StringComparison.Ordinal) ? "\r\n" : "\n";
            var lines = source.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None).ToList();
            var changed = false;
 
            for (var index = 0; index < lines.Count; index++)
            {
                var match = s_warningDisableRegex.Match(lines[index]);
                if (!match.Success)
                    continue;
 
                var comment = match.Groups["comment"].Value;
                var hasInlineMarker = Has0414WarningSuppressionMarker(comment);
                var hasPreviousMarker = index > 0 && IsStandalone0414WarningSuppressionMarker(lines[index - 1]);
                if (!hasInlineMarker && !hasPreviousMarker)
                    continue;
 
                var warningCodes = match.Groups["codes"].Value
                    .Split(',')
                    .Select(code => code.Trim())
                    .ToArray();
                var updatedComment = hasInlineMarker
                    ? Remove0414WarningSuppressionMarker(comment)
                    : comment;
                var updatedCodes = match.Groups["codes"].Value.TrimEnd();
                if (warningCodes.Contains(WarningCode0067, StringComparer.Ordinal) &&
                    warningCodes.Contains(WarningCode0414, StringComparer.Ordinal))
                {
                    updatedCodes = string.Join(
                        ", ",
                        warningCodes.Where(code => !string.Equals(code, WarningCode0414, StringComparison.Ordinal)));
                }
 
                lines[index] = $"{match.Groups["prefix"].Value}{updatedCodes}{updatedComment}";
 
                if (hasPreviousMarker)
                {
                    lines.RemoveAt(index - 1);
                    index--;
                }
 
                changed = true;
            }
 
            return changed ? string.Join(newline, lines) : source;
        }

        private static bool HasOwned0414WarningSuppression(string[] lines)
        {
            for (var index = 0; index < lines.Length; index++)
            {
                var warningCodes = GetDisabledWarningCodes(lines[index]);
                if (!warningCodes.Contains(WarningCode0067, StringComparer.Ordinal) ||
                    !warningCodes.Contains(WarningCode0414, StringComparer.Ordinal))
                    continue;
 
                var match = s_warningDisableRegex.Match(lines[index]);
                if (Has0414WarningSuppressionMarker(match.Groups["comment"].Value) ||
                    index > 0 && IsStandalone0414WarningSuppressionMarker(lines[index - 1]))
                {
                    return true;
                }
            }
 
            return false;
        }

        private static bool Has0414WarningSuppressionMarker(string comment) =>
            comment.TrimEnd().EndsWith(Warning414SuppressionMarker, StringComparison.Ordinal);

        private static string Append0414WarningSuppressionMarker(string comment) =>
            string.IsNullOrEmpty(comment)
                ? $" {Warning414SuppressionMarker}"
                : $"{comment.TrimEnd()} {Warning414SuppressionMarker}";

        private static string Remove0414WarningSuppressionMarker(string comment)
        {
            var trimmedComment = comment.TrimEnd();
            var markerIndex = trimmedComment.LastIndexOf(Warning414SuppressionMarker, StringComparison.Ordinal);
            if (markerIndex < 0)
                return comment;
 
            var updatedComment = trimmedComment.Remove(markerIndex, Warning414SuppressionMarker.Length);
            return string.IsNullOrWhiteSpace(updatedComment) ||
                   string.Equals(updatedComment.Trim(), "//", StringComparison.Ordinal)
                ? string.Empty
                : updatedComment.TrimEnd();
        }

        private static bool IsStandalone0414WarningSuppressionMarker(string line) =>
            string.Equals(line.Trim(), Warning414SuppressionMarker, StringComparison.Ordinal);

        private static string[] GetDisabledWarningCodes(string line)
        {
            var match = s_warningDisableRegex.Match(line);
            return match.Success
                ? match.Groups["codes"].Value.Split(',').Select(code => code.Trim()).ToArray()
                : Array.Empty<string>();
        }
 
        #endregion
 
        #region Enhanced editor dummies
 
        private static bool ApplyOrRestoreEnhancedEditorDummies(bool useEnhancedEditorDummies) =>
            YandexEditorDummyUpdater.ApplyOrRestore(yandexData, useEnhancedEditorDummies);
 
        #endregion
 
        #region Patch Yandex asmdef

        private static bool UpdateAssemblyReferences()
        {
            if (yandexData.Asmdef == null)
                throw new UnityException("YandexData.Asmdef is not assigned. Please reference SCG.Yandex.asmdef asset.");
 
            var targetAsmdefRel = AssetDatabase.GetAssetPath(yandexData.Asmdef);
            if (string.IsNullOrWhiteSpace(targetAsmdefRel))
                throw new UnityException("Unable to resolve path to SCG.Yandex.asmdef via AssetDatabase.");
 
            var targetAsmdefAbs = ToAbsolutePath(targetAsmdefRel);
            if (!File.Exists(targetAsmdefAbs))
                throw new UnityException($"The asmdef file was not found: {targetAsmdefRel}");
 
            var original = File.ReadAllText(targetAsmdefAbs, Encoding.UTF8);
            var updated = PatchDefineConstraint(original, yandexData.RemoveDefineConstraint);
 
            if (string.Equals(original, updated, StringComparison.Ordinal))
                return false;
 
            File.WriteAllText(targetAsmdefAbs, updated, Encoding.UTF8);
            Debug.Log($"[{nameof(YandexAssemblyUpdater)}]: Assembly references updated and define constraint removed successfully.");
            return true;
        }

        private static string PatchDefineConstraint(string json, string defineToRemove)
        {
            if (string.IsNullOrWhiteSpace(defineToRemove))
                return json;
 
            var escaped = Regex.Escape(defineToRemove);
            var pattern = $"\"\\b{escaped}\\b\",?\\s*";
            var result = Regex.Replace(json, pattern, string.Empty);
 
            // Normalize trailing list comma: ", ]" -> "\n    ]"
            result = Regex.Replace(result, @",\s*\‍]", "\n    ]");
 
            // Normalize empty defineConstraints array to multiline form for readability
            result = Regex.Replace(result, @"""defineConstraints"":\s*\‍[\s*\‍]", @"""defineConstraints"": [
    ]");
 
            return result;
        }
 
        private static string AddDefineConstraint(string json, string defineToAdd)
        {
            if (string.IsNullOrWhiteSpace(defineToAdd) || json.Contains($"\"{defineToAdd}\"", StringComparison.Ordinal))
                return json;
 
            var emptyArrayPattern = @"""defineConstraints"":\s*\‍[\s*\‍]";
            if (Regex.IsMatch(json, emptyArrayPattern))
            {
                return Regex.Replace(
                    json,
                    emptyArrayPattern,
                    $"\"defineConstraints\": [\n        \"{defineToAdd}\"\n    ]");
            }
 
            var arrayPattern = @"""defineConstraints"":\s*\‍[(?<content>[\s\S]*?)\‍]";
            return Regex.Replace(
                json,
                arrayPattern,
                match =>
                {
                    var content = match.Groups["content"].Value;
                    var trimmed = content.Trim();
                    var separator = string.IsNullOrEmpty(trimmed) ? string.Empty : ",";
                    return $"\"defineConstraints\": [{content}{separator}\n        \"{defineToAdd}\"\n    ]";
                },
                RegexOptions.CultureInvariant);
        }
 
        #endregion
 
        #region AdRevenue import worker guard
 
        private static bool PatchAdRevenueAutoCollectionResolverGuard()
        {
            var changed = false;
            foreach (var file in GetAdRevenueAutoCollectionResolverPaths())
            {
                var original = File.ReadAllText(file, Encoding.UTF8);
                var updated = PatchAdRevenueAutoCollectionResolverGuard(original);
                if (string.Equals(original, updated, StringComparison.Ordinal))
                    continue;
 
                File.WriteAllText(file, updated, Encoding.UTF8);
                changed = true;
 
                var assetPath = ToAssetPathFromAbsolute(file);
                if (!string.IsNullOrEmpty(assetPath))
                    AssetDatabase.ImportAsset(assetPath);
 
                Debug.Log($"[{nameof(YandexAssemblyUpdater)}]: Updated import worker guard in {Path.GetFileName(file)}.");
            }
 
            return changed;
        }
 
        private static string[] GetAdRevenueAutoCollectionResolverPaths()
        {
            var dataPath = Application.dataPath.Replace('\\', '/');
            return Directory.Exists(dataPath)
                ? Directory.GetFiles(dataPath, AdRevenueAutoCollectionResolverFileName, SearchOption.AllDirectories)
                    .OrderBy(path => path, StringComparer.Ordinal)
                    .ToArray()
                : Array.Empty<string>();
        }
 
        private static string PatchAdRevenueAutoCollectionResolverGuard(string source)
        {
            if (string.IsNullOrEmpty(source))
                return source;
 
            var newline = source.Contains("\r\n", StringComparison.Ordinal) ? "\r\n" : "\n";
            var lines = source.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None).ToList();
            var changed = adRevenueAutoCollectionResolverGuardMethods.Aggregate(
                false,
                (current, signature) => current | PatchMethodImportWorkerGuard(lines, signature));
 
            return changed ? string.Join(newline, lines) : source;
        }
 
        private static bool PatchMethodImportWorkerGuard(List<string> lines, string signature)
        {
            if (!TryFindMethodBlock(lines, signature, out _, out var openLine, out var endLine))
                return false;
 
            var changed = RemoveImportWorkerGuard(lines, openLine + 1, endLine);
            if (!TryFindMethodBlock(lines, signature, out var methodLine, out openLine, out endLine))
                return changed;
 
            var contentStart = openLine + 1;
            if (HasImportWorkerGuard(lines, contentStart, endLine))
                return changed;
 
            var indent = GetMethodBodyIndent(lines, methodLine, contentStart, endLine);
            lines.InsertRange(contentStart, new[]
            {
                $"{indent}if ({ImportWorkerGuardCondition}) {{ // {ImportWorkerGuardComment}",
                $"{indent}    return;",
                $"{indent}}}",
                string.Empty
            });
 
            return true;
        }
 
        private static bool TryFindMethodBlock(List<string> lines, string signature, out int methodLine, out int openLine, out int endLine)
        {
            methodLine = FindMethodLine(lines, signature);
            openLine = methodLine < 0 ? -1 : FindOpeningBraceLine(lines, methodLine);
            endLine = openLine < 0 ? -1 : FindMatchingClosingBrace(lines, openLine);
            return endLine > openLine;
        }
 
        private static int FindMethodLine(List<string> lines, string signature) =>
            lines.FindIndex(line => line.TrimStart().StartsWith(signature, StringComparison.Ordinal));
 
        private static int FindOpeningBraceLine(List<string> lines, int startLine)
        {
            for (var i = startLine; i < lines.Count; i++)
            {
                var trimmed = lines[i].TrimStart();
                if (i > startLine && trimmed.StartsWith("[", StringComparison.Ordinal))
                    return -1;
 
                if (lines[i].Contains("{", StringComparison.Ordinal))
                    return i;
            }
 
            return -1;
        }
 
        private static bool RemoveImportWorkerGuard(List<string> lines, int startLine, int endLine)
        {
            var changed = false;
 
            for (var i = endLine; i >= startLine; i--)
            {
                if (!lines[i].Contains(ImportWorkerGuardComment, StringComparison.Ordinal))
                    continue;
 
                var guardOpen = lines[i].Contains("{", StringComparison.Ordinal) ? i : FindOpeningBraceLine(lines, i);
                if (guardOpen < 0)
                    continue;
 
                var guardEnd = FindMatchingClosingBrace(lines, guardOpen);
                if (guardEnd < guardOpen || guardEnd > endLine)
                    continue;
 
                lines.RemoveRange(i, guardEnd - i + 1);
                if (i < lines.Count && string.IsNullOrWhiteSpace(lines[i]))
                    lines.RemoveAt(i);
 
                changed = true;
            }
 
            return changed;
        }
 
        private static bool HasImportWorkerGuard(List<string> lines, int startLine, int endLine)
        {
            for (var i = startLine; i <= endLine && i < lines.Count; i++)
            {
                if (lines[i].Contains(ImportWorkerGuardComment, StringComparison.Ordinal))
                    return true;
            }
 
            return false;
        }
 
        private static string GetMethodBodyIndent(List<string> lines, int methodLine, int startLine, int endLine)
        {
            for (var i = startLine; i <= endLine && i < lines.Count; i++)
            {
                if (!string.IsNullOrWhiteSpace(lines[i]))
                    return LeadingWhitespace(lines[i]);
            }
 
            return LeadingWhitespace(lines[methodLine]) + "    ";
        }
 
        #endregion
 
        #region iOS Fix
 
        private static bool FixIosReferences(bool applyChanges = true)
        {
            if (AssetDatabase.IsAssetImportWorkerProcess())
                return false;
 
            var assetsDir = ToAssetsPath(yandexData.AssetPath);
            if (!AssetDatabase.IsValidFolder(assetsDir))
                return false;
 
            var path = ToAbsolutePath(assetsDir);
            var files = Directory.GetFiles(path, "*.cs", SearchOption.AllDirectories);
            var changed = false;
 
            foreach (var f in files)
            {
                var original = File.ReadAllText(f);
                var text = original;
 
                text = WrapUsings(text);
                text = WrapIosMethodDefinitions(text);
                text = WrapIosIfContents(text);
                if (ReferenceEquals(text, original) || text == original) continue;
 
                if (!applyChanges)
                    return true;
 
                File.WriteAllText(f, text);
                changed = true;
            }
 
            if (changed)
                Debug.Log($"[{nameof(YandexAssemblyUpdater)}]: Assembly fixed.");
 
            return changed;
        }
 
        private static string WrapUsings(string src)
        {
            // Split preserving line endings simplicity
            var lines = src.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None).ToList();
            var modified = false;
 
            for (var i = 0; i < lines.Count;)
            {
                var t = lines[i].Trim();
                if (!t.StartsWith(IosUsingStarts, StringComparison.Ordinal))
                {
                    i++;
                    continue;
                }
 
                // Find contiguous block of "using UnityEditor.iOS.Xcode..."
                var start = i;
                var end = i;
                while (end + 1 < lines.Count && lines[end + 1].Trim().StartsWith(IosUsingStarts, StringComparison.Ordinal))
                    end++;
 
                // Check if already wrapped exactly around this block
                var prev = start - 1 >= 0 ? lines[start - 1].Trim() : string.Empty;
                var next = end + 1 < lines.Count ? lines[end + 1].Trim() : string.Empty;
                var already =
                    prev.StartsWith("#if", StringComparison.Ordinal) && prev.Contains(IosWrappedComment) &&
                    next.StartsWith("#endif", StringComparison.Ordinal) && next.Contains(IosWrappedComment);
 
                if (!already)
                {
                    var indent = LeadingWhitespace(lines[start]);
                    lines.Insert(start, indent + IosFixIfDefine);
                    end++; // block shifted by one
                    lines.Insert(end + 1, indent + IosFixEndIfDefine);
                    modified = true;
                    i = end + 2; // skip wrapper
                }
                else
                {
                    i = end + 1; // skip existing block
                }
            }
 
            return modified ? string.Join("\n", lines) : src;
        }
 
        private static string WrapIosIfContents(string src)
        {
            // Split to keep exact line structure; join with '\n' later.
            var lines = src.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None).ToList();
            var modified = false;
 
            for (var i = 0; i < lines.Count; i++)
            {
                // Fast scan for the BuildTarget.iOS usage
                if (!lines[i].Contains(IosIfCondition))
                    continue;
 
                // Skip partial matches (e.g. NamedBuildTarget.iOS)
                var pos = lines[i].IndexOf(IosIfCondition, StringComparison.Ordinal);
                if (pos > 0 && char.IsLetterOrDigit(lines[i][pos - 1]))
                    continue;
 
                // Walk upwards to the actual 'if (...)' line that owns this condition
                var ifLine = i;
                while (ifLine >= 0 && !lines[ifLine].Contains("if"))
                    ifLine--;
                if (ifLine < 0) continue;
 
                // Skip preprocessor #if — only wrap C# if-statement bodies
                if (lines[ifLine].TrimStart().StartsWith("#", StringComparison.Ordinal))
                    continue;
 
                // Find the opening brace '{' for that 'if'
                var openLine = -1;
                for (var j = ifLine; j < lines.Count; j++)
                {
                    // Stop on the first '{' after the 'if (...)'
                    if (lines[j].Contains("{")) { openLine = j; break; }
                    // Break if another 'if' appears before '{' – avoid nesting confusion
                    if (j > ifLine && lines[j].Contains("if")) break;
                }
                if (openLine < 0) continue;
 
                // Find the matching closing brace '}' for the block that starts at openLine
                var endLine = FindMatchingClosingBrace(lines, openLine);
                if (endLine <= openLine) continue;
 
                // Calculate the *body* range (exclusive of braces)
                var contentStart = openLine + 1;
                var contentEnd = endLine - 1;
                if (contentEnd < contentStart) continue;
 
                // Idempotency: if the insertion point already sits inside our #if/#endif region, skip.
                if (RegionNearHasMarker(lines, contentStart, IosWrappedComment))
                    continue;
 
                // Use the indentation of the first body line for our directives
                var indent = LeadingWhitespace(lines[contentStart]);
 
                // Insert #if *before* the first body line
                lines.Insert(contentStart, indent + IosFixIfDefine);
 
                lines.Insert(endLine + 1, indent + IosFixEndIfDefine);
 
                modified = true;
 
                // Jump beyond the just inserted #endif to avoid reprocessing this block
                i = endLine + 2;
            }
 
            return modified ? string.Join("\n", lines) : src;
        }
 
        private static string WrapIosMethodDefinitions(string src)
        {
            var lines = src.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None).ToList();
            var modified = false;
 
            for (var i = 0; i < lines.Count; i++)
            {
                var trimmed = lines[i].Trim();
 
                // If current position is already in our region, do nothing
                if (RegionNearHasMarker(lines, i, IosWrappedComment))
                    continue;
 
                foreach (var sig in iosMethodSignatures)
                {
                    // Exact signature match (no regex – safer)
                    if (!trimmed.Equals(sig, StringComparison.Ordinal))
                        continue;
 
                    // Find '{' that opens the method body
                    var openLine = -1;
                    for (var j = i; j < lines.Count; j++)
                    {
                        if (lines[j].Contains("{")) { openLine = j; break; }
                        // If attributes start on next lines, abort to avoid false detection
                        if (j > i && lines[j].TrimStart().StartsWith("[", StringComparison.Ordinal)) break;
                    }
                    if (openLine < 0) break;
 
                    // Find matching closing '}' for the method body
                    var endLine = FindMatchingClosingBrace(lines, openLine);
                    if (endLine <= openLine) break;
 
                    var contentStart = openLine + 1;
                    var body = lines.GetRange(contentStart, endLine - contentStart);
                    body.RemoveAll(line => line.Trim().Equals(IosFixIfDefine, StringComparison.Ordinal) ||
                                           line.Trim().Equals(IosFixEndIfDefine, StringComparison.Ordinal));
                    body.Insert(0, IosFixIfDefine);
                    body.Add(IosFixEndIfDefine);
 
                    if (!lines.Skip(contentStart).Take(endLine - contentStart).SequenceEqual(body))
                    {
                        lines.RemoveRange(contentStart, endLine - contentStart);
                        lines.InsertRange(contentStart, body);
                        modified = true;
                    }
 
                    i = contentStart + body.Count;
                    break;
                }
            }
 
            return modified ? string.Join("\n", lines) : src;
        }
 
        // Returns index of the line that contains the matching closing brace for the block that opens at 'openLine'.
        private static int FindMatchingClosingBrace(List<string> lines, int openLine)
        {
            var depth = 0;
            for (var i = openLine; i < lines.Count; i++)
            {
                depth += CountChar(lines[i], '{');
                depth -= CountChar(lines[i], '}');
 
                if (depth == 0)
                    return i;
            }
            return -1;
        }
 
        private static int CountChar(string s, char ch) => s.Count(t => t == ch);
 
        private static string LeadingWhitespace(string s)
        {
            var i = 0;
            while (i < s.Length && char.IsWhiteSpace(s[i])) i++;
            return s[..i];
        }
 
        private static bool RegionNearHasMarker(List<string> lines, int index, string marker)
        {
            // Determines whether 'index' is inside a #if ... // marker ... #endif region.
            var stack = new Stack<(int start, bool hasMarker)>();
 
            for (var i = 0; i < lines.Count; i++)
            {
                var t = lines[i].Trim();
                if (t.StartsWith("#if"))
                {
                    var has = t.Contains(marker);
                    stack.Push((i, has));
                }
                else if (t.StartsWith("#endif"))
                {
                    if (stack.Count == 0) continue;
                    var (start, has) = stack.Pop();
                    if (has && index >= start && index <= i)
                        return true;
                }
            }
            return false;
        }
 
        #endregion
 
        #region Helpers

        private static bool EnsureFolderExists(string assetsRelativePath)
        {
            assetsRelativePath = assetsRelativePath.Replace("\\", "/");
            if (AssetDatabase.IsValidFolder(assetsRelativePath))
                return false;
 
            var segments = assetsRelativePath.Split('/');
            if (segments.Length == 0 || !string.Equals(segments[0], AssetsFolder, StringComparison.Ordinal))
                throw new UnityException($"Path must be {AssetsFolder}-relative: {assetsRelativePath}");
 
            var current = AssetsFolder;
            for (var i = 1; i < segments.Length; i++)
            {
                var next = $"{current}/{segments[i]}";
                if (!AssetDatabase.IsValidFolder(next))
                {
                    AssetDatabase.CreateFolder(current, segments[i]);
                }
                current = next;
            }
 
            return !AssetDatabase.IsValidFolder(assetsRelativePath)
                ? throw new UnityException($"Unable to create folder: {assetsRelativePath}")
                : true;
        }

        private static bool EnsureAsmdefExists(string assetsRelativeFile, string content, string createdLog)
        {
            if (string.IsNullOrEmpty(assetsRelativeFile))
                return false;
 
            assetsRelativeFile = assetsRelativeFile.Replace("\\", "/");
            var absolute = ToAbsolutePath(assetsRelativeFile);
            if (File.Exists(absolute))
                return false;
 
            var dir = Path.GetDirectoryName(absolute);
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir!);
 
            File.WriteAllText(absolute, content, Encoding.UTF8);
            Debug.Log(createdLog);
            AssetDatabase.ImportAsset(assetsRelativeFile);
            return true;
        }

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

        private static string ToAssetPathFromAbsolute(string absolutePath)
        {
            var normalized = Path.GetFullPath(absolutePath).Replace('\\', '/');
            var dataPath = Application.dataPath.Replace('\\', '/');
            if (!normalized.StartsWith(dataPath + "/", StringComparison.Ordinal))
                return string.Empty;
 
            var tail = normalized[dataPath.Length..].TrimStart('/');
            return string.IsNullOrEmpty(tail) ? AssetsFolder : $"{AssetsFolder}/{tail}";
        }

        private static string ToAbsolutePath(string assetPath)
        {
            if (string.IsNullOrEmpty(assetPath))
                throw new UnityException("Empty asset path.");
 
            var normalized = assetPath.Replace('\\', '/');
 
            // "Assets" root (exact match or starts with "Assets/")
            if (string.Equals(normalized, AssetsFolder, StringComparison.Ordinal) ||
                normalized.StartsWith(AssetsFolder + "/", StringComparison.Ordinal))
            {
                var tail = normalized.Length == AssetsFolder.Length
                    ? string.Empty
                    : normalized[AssetsFolder.Length..].TrimStart('/');
 
                var abs = Path.Combine(Application.dataPath, tail);
                return Path.GetFullPath(abs).Replace('\\', '/');
            }
 
            // "Packages/<id>/..." (must strictly start with "Packages/")
            if (normalized.StartsWith(PackagesFolder + "/", StringComparison.Ordinal))
            {
                var pinfo = PackageInfo.FindForAssetPath(normalized)
                           ?? throw new UnityException($"Unable to resolve package for '{assetPath}'.");
 
                // Part inside the package folder
                var relInside = normalized.Length > pinfo.assetPath.Length
                    ? normalized[pinfo.assetPath.Length..].TrimStart('/')
                    : string.Empty;
 
                var abs = string.IsNullOrEmpty(relInside)
                    ? pinfo.resolvedPath
                    : Path.Combine(pinfo.resolvedPath, relInside);
 
                return Path.GetFullPath(abs).Replace('\\', '/');
            }
 
            // Absolute path passthrough
            if (Path.IsPathRooted(normalized))
                return Path.GetFullPath(normalized).Replace('\\', '/');
 
            // Project-relative fallback
            var projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
            return Path.GetFullPath(Path.Combine(projectRoot, normalized)).Replace('\\', '/');
        }
 
        #endregion
    }
}