using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using UnityPipeline.Microsoft.CodeAnalysis;
using UnityPipeline.Microsoft.CodeAnalysis.CSharp;
using UnityPipeline.Microsoft.CodeAnalysis.CSharp.Syntax;
using Unity.Pipeline.Compilation;
using UnityEngine;

namespace Unity.Pipeline.CodeReload
{
    /// <summary>
    /// Main orchestrator for in-place code reload processing.
    /// Handles the complete pipeline: source parsing -> transformation -> compilation.
    /// </summary>
    static class InPlaceReloadProcessor
    {
        /// <summary>
        /// Process a source file for in-place code reload.
        /// Extracts [CodeReload] methods, transforms to static overrides, and compiles.
        /// DEADLOCK FIX: Detects main thread and uses synchronous processing when needed.
        /// </summary>
        /// <param name="sourceFilePath">Path to source file containing [CodeReload] methods</param>
        /// <param name="assemblyDir">Optional directory to save compiled assembly</param>
        /// <param name="pdb">Emit debug symbols mapped to the original source so breakpoints bind.</param>
        /// <returns>Compilation result with success/failure and diagnostic information</returns>
        public static Task<InPlaceReloadResult> ProcessSourceFileAsync(string sourceFilePath, string assemblyDir = null, bool pdb = false, bool useInterpreter = false)
        {
            // Runs synchronously on the calling (main) thread; returns a completed Task.
            return Task.FromResult(ProcessSourceFileOnMainThread(sourceFilePath, assemblyDir, pdb, useInterpreter));
        }

        /// <summary>
        /// Process source file on main thread synchronously to avoid deadlocks.
        /// </summary>
        /// <param name="sourceFilePath">Path to source file containing [CodeReload] methods.</param>
        /// <param name="assemblyDir">Optional directory to save compiled assembly.</param>
        /// <param name="pdb">Emit debug symbols mapped to the original source so breakpoints bind.</param>
        /// <param name="useInterpreter">Route the override through the interpreter backend instead of Assembly.Load.</param>
        /// <returns>Compilation result with success/failure and diagnostic information.</returns>
        public static InPlaceReloadResult ProcessSourceFileOnMainThread(string sourceFilePath, string assemblyDir = null, bool pdb = false, bool useInterpreter = false)
        {
            var result = new InPlaceReloadResult
            {
                SourceFilePath = sourceFilePath,
                Success = false
            };

            try
            {
                Debug.Log($"CodeReload: Processing source file synchronously on main thread: {sourceFilePath}");

                // The interpreter backend needs #line directives when source-line errors are
                // enabled: its runtime errors resolve locations from the embedded PDB, which are
                // only meaningful mapped to the user's file.
                var lineInfo = useInterpreter && CodeReloadCompiler.EmitSourceLineInfo;
                var prep = PrepareOverride(sourceFilePath, pdb || lineInfo, enforcePublicAccess: !useInterpreter);
                if (!prep.Success)
                {
                    result.ErrorMessage = prep.Error;
                    result.CompilationDiagnostics = prep.Diagnostics;
                    return result;
                }

                result.OriginalTypeName = prep.TypeName;
                result.ExtractedMethods = prep.MethodNames;
                result.UpToDateMethods = prep.UpToDateMethods;
                result.TransformedCode = prep.TransformedCode;

                // A method that matches the baseline again (the edit was undone) may still carry an
                // override from an earlier reload — drop it so the compiled body runs at full speed.
                foreach (var name in prep.UpToDateMethods)
                {
                    var id = $"{prep.TypeName}.{name}";
                    if (CodeReloadRegistry.UnregisterMethodOverride(id))
                        result.RevertedMethods.Add(id);
                }

                if (prep.MethodNames.Count == 0)
                {
                    result.Success = true;
                    result.CompilationDiagnostics = prep.Diagnostics;
                    Debug.Log($"CodeReload: {sourceFilePath} is up to date — all " +
                        $"{prep.UpToDateMethods.Count} [CodeReload] method(s) match the compiled baseline" +
                        (result.RevertedMethods.Count > 0
                            ? $"; removed {result.RevertedMethods.Count} stale override(s)" : "") + ".");
                    return result;
                }

                var compilationResult = CompileTransformedCode(prep, assemblyDir, pdb, sourceFilePath, useInterpreter);

                result.Success = compilationResult.IsSuccess;
                result.AssemblyName = compilationResult.AssemblyName;
                result.RegisteredMethods = compilationResult.RegisteredMethods;
                result.CompilationDiagnostics = prep.Diagnostics.Concat(compilationResult.Diagnostics).ToList();

                if (result.Success)
                {
                    Debug.Log($"CodeReload: In-place reload successful for {sourceFilePath} - {result.RegisteredMethods.Count} methods registered" +
                        (result.UpToDateMethods.Count > 0 ? $" ({result.UpToDateMethods.Count} up to date, left compiled)" : ""));
                }
                else
                {
                    result.ErrorMessage = compilationResult.ErrorDetails ?? "Compilation failed";
                    Debug.LogError($"CodeReload: In-place reload compilation failed: {result.ErrorMessage}");
                }

                return result;
            }
            catch (Exception ex)
            {
                Debug.LogError($"CodeReload: Error processing source file {sourceFilePath}: {ex.Message}\n{ex.StackTrace}");

                result.ErrorMessage = $"Processing error: {ex.Message}";
                return result;
            }
        }

        /// <summary>
        /// What <see cref="PrepareOverride"/> hands back: the extracted type and surviving methods,
        /// the transformed source (null when everything was up to date), and the diagnostics
        /// gathered on the way. <see cref="Success"/> false means a hard failure with
        /// <see cref="Error"/> set.
        /// </summary>
        private sealed class OverridePreparation
        {
            public bool Success;
            public string Error;
            public string TypeName;
            public List<string> MethodNames;
            public List<string> UpToDateMethods = new List<string>();
            public string TransformedCode;
            public List<string> Diagnostics = new List<string>();
        }

        /// <summary>
        /// Shared prefix for in-place reload and push-to-player: read the file, extract [CodeReload]
        /// methods, drop the ones still matching the captured <see cref="CodeReloadBaseline"/> (they
        /// run correct AND faster compiled — <see cref="OverridePreparation.UpToDateMethods"/>
        /// reports them, and <paramref name="forceInclude"/> keeps named ones in anyway), reject
        /// non-public member access when the compiled backend will run the override
        /// (<paramref name="enforcePublicAccess"/>), and transform bodies into a static override
        /// class. When every method is up to date, succeeds with an empty
        /// <see cref="OverridePreparation.MethodNames"/> and a null
        /// <see cref="OverridePreparation.TransformedCode"/> — nothing to compile.
        /// </summary>
        private static OverridePreparation PrepareOverride(
            string sourceFilePath, bool pdb, bool enforcePublicAccess,
            string[] preprocessorSymbols = null, ICollection<string> forceInclude = null,
            bool useBaseline = true)
        {
            var prep = new OverridePreparation();

            var sourceCode = ReadSourceFile(sourceFilePath);
            if (string.IsNullOrEmpty(sourceCode))
            {
                prep.Error = $"Could not read source file: {sourceFilePath}";
                return prep;
            }

            var extraction = ExtractCodeReloadableMethods(sourceCode, preprocessorSymbols);
            // Each skip entry carries its own reason (return-type gate, nested type, …).
            foreach (var skipped in extraction.SkippedMethods)
                prep.Diagnostics.Add($"[CodeReload] {skipped} was skipped.");

            if (!extraction.HasMethods)
            {
                prep.Error = extraction.SkippedMethods.Count > 0
                    ? $"No reloadable [CodeReload] methods in {sourceFilePath}. Skipped: " +
                      $"{string.Join(", ", extraction.SkippedMethods)}."
                    : $"No [CodeReload] methods found in {sourceFilePath}";
                return prep;
            }

            // Skip methods whose declarations still match the captured baseline: their compiled
            // bodies are already what the source says, and the compiled body is strictly faster
            // than any override (the interpreter backend pays per call). No baseline captured
            // (returns null) = no filtering, the pre-baseline behavior.
            var unchanged = useBaseline
                ? CodeReloadBaseline.GetUnchangedMethods(sourceFilePath, sourceCode, preprocessorSymbols)
                : null;
            if (unchanged != null && unchanged.Count > 0)
            {
                foreach (var name in extraction.Methods.Keys.ToList())
                {
                    if (!unchanged.Contains(name)) continue;
                    if (forceInclude != null && forceInclude.Contains(name)) continue;
                    extraction.Methods.Remove(name);
                    extraction.MethodSignatures.Remove(name);
                    prep.UpToDateMethods.Add(name);
                }

                if (extraction.Methods.Count == 0)
                {
                    prep.TypeName = extraction.TypeName;
                    prep.MethodNames = new List<string>();
                    prep.Success = true;
                    return prep;
                }
            }

            // Build one compilation + semantic model for the transform, so Roslyn's metadata bind
            // is paid once per reload (shared with the string TransformMethodBodies overload).
            var model = SourceCodeTransformer.BuildSemanticModel(
                sourceCode, extraction.TypeName, out var classDecl, preprocessorSymbols);
            if (classDecl == null)
            {
                prep.Error = $"Could not find class '{extraction.TypeName}' in source.";
                return prep;
            }

            // Only the interpreter backend compiles with relaxed accessibility (see
            // RoslynCompilationService.AllowNonPublicMemberAccess) and reaches non-public members at
            // runtime, via reflection. The Assembly.Load backend keeps standard access checks — a
            // non-public access would only surface later as a raw CS0122 — so reject it up front
            // with an actionable message.
            if (enforcePublicAccess)
            {
                var validation = AccessibilityValidator.ValidatePublicAccess(
                    model, classDecl, extraction.Methods, extraction.TypeName);
                if (!validation.IsValid)
                {
                    prep.Error = validation.GetFormattedErrorMessage();
                    return prep;
                }
            }

            // enforcePublicAccess doubles as the backend discriminator (true == Assembly.Load, see
            // the callers): only the interpreter needs interpolation lowered to string.Format —
            // the compiled backend keeps interpolations native.
            prep.TransformedCode = SourceCodeTransformer.TransformMethodBodies(
                model, classDecl, extraction.Methods, extraction.TypeName, extraction.MethodSignatures,
                emitLineDirectives: pdb, originalFilePath: sourceFilePath,
                rewriteInterpolations: !enforcePublicAccess);

            prep.TypeName = extraction.TypeName;
            prep.MethodNames = extraction.Methods.Keys.ToList();
            prep.Success = true;
            return prep;
        }

        /// <summary>
        /// Compile a source file's [CodeReload] override(s) to raw assembly IL bytes without
        /// registering them locally — for pushing to a player that runs them through the
        /// interpreter. Editor-side only (needs Roslyn). <paramref name="useBaseline"/> false
        /// bypasses the <see cref="CodeReloadBaseline"/> filter — the caller can't vouch that the
        /// target player was built from the baselined sources.
        /// </summary>
        internal static PushCompileResult CompileOverrideForPush(string sourceFilePath, string[] preprocessorSymbols = null,
            ICollection<string> forceInclude = null, bool useBaseline = true)
        {
            var r = new PushCompileResult();
            try
            {
                // When source-line errors are enabled, #line directives map each body to the
                // original file so the embedded PDB's sequence points — used by the player-side
                // interpreter for runtime error messages — carry the user's real line numbers.
                // enforcePublicAccess: false — pushed overrides run through the on-device
                // interpreter, which reaches non-public members by reflection.
                var prep = PrepareOverride(sourceFilePath, pdb: CodeReloadCompiler.EmitSourceLineInfo,
                        enforcePublicAccess: false, preprocessorSymbols, forceInclude, useBaseline);
                if (!prep.Success)
                {
                    r.Error = prep.Error;
                    r.Diagnostics = prep.Diagnostics;
                    return r;
                }

                r.UpToDateMethods = prep.UpToDateMethods;
                if (prep.MethodNames.Count == 0)
                {
                    // Everything matches the baseline — a push would only replace compiled bodies
                    // with slower interpreted ones on the device.
                    r.Success = true;
                    r.TypeName = prep.TypeName;
                    r.Diagnostics = prep.Diagnostics;
                    return r;
                }

                var tempName = $"PushReload_{prep.TypeName}_{DateTime.Now:yyyyMMdd_HHmmss}";
                if (!CodeReloadCompiler.TryCompileOverrideBytes(prep.TransformedCode, tempName, out var il, out var compileDiagnostics, documentPath: sourceFilePath, preprocessorSymbols: preprocessorSymbols))
                {
                    r.Error = "Compilation failed";
                    r.Diagnostics = prep.Diagnostics.Concat(compileDiagnostics).ToList();
                    return r;
                }

                r.Success = true;
                r.TypeName = prep.TypeName;
                r.MethodNames = prep.MethodNames;
                r.IlBytes = il;
                r.Diagnostics = prep.Diagnostics.Concat(compileDiagnostics).ToList();
                return r;
            }
            catch (Exception ex)
            {
                r.Error = $"Push compile error: {ex.Message}";
                return r;
            }
        }

        /// <summary>
        /// Check if a source file contains [CodeReload] methods.
        /// Simple synchronous check to avoid async deadlocks in tests.
        /// </summary>
        /// <param name="sourceFilePath">Path to source file to check</param>
        /// <returns>True if file contains [CodeReload] methods</returns>
        public static Task<bool> ContainsCodeReloadableMethodsAsync(string sourceFilePath)
        {
            try
            {
                if (!File.Exists(sourceFilePath))
                {
                    return Task.FromResult(false);
                }

                // Use synchronous read for simple attribute check to avoid deadlocks
                var sourceCode = File.ReadAllText(sourceFilePath);
                if (string.IsNullOrEmpty(sourceCode))
                {
                    return Task.FromResult(false);
                }

                // Quick check for the [CodeReload] attribute. Prefix match (no closing bracket) so
                // combined attribute lists like [CodeReload, DebugPanel("x")] still pass.
                var result = sourceCode.Contains("[CodeReload");
                return Task.FromResult(result);
            }
            catch (Exception ex)
            {
                Debug.LogError($"CodeReload: Error checking for [CodeReload] methods in {sourceFilePath}: {ex.Message}");
                return Task.FromResult(false);
            }
        }

        /// <summary>
        /// Read source file content synchronously (for main thread).
        /// </summary>
        private static string ReadSourceFile(string filePath)
        {
            try
            {
                if (!File.Exists(filePath))
                {
                    Debug.LogError($"CodeReload: Source file not found: {filePath}");
                    return null;
                }

                return File.ReadAllText(filePath);
            }
            catch (Exception ex)
            {
                Debug.LogError($"CodeReload: Error reading source file {filePath}: {ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// Extract [CodeReload] methods from source code.
        /// </summary>
        private static CodeReloadableExtractionResult ExtractCodeReloadableMethods(
            string sourceCode, string[] preprocessorSymbols = null)
        {
            var result = new CodeReloadableExtractionResult();

            try
            {
                var syntaxTree = CSharpSyntaxTree.ParseText(sourceCode,
                    RoslynCompilationService.ProjectParseOptions(preprocessorSymbols));
                var root = syntaxTree.GetRoot();

                // Find the class containing [CodeReload] methods.
                var classDeclaration = root.DescendantNodes()
                    .OfType<ClassDeclarationSyntax>()
                    .FirstOrDefault(c => c.DescendantNodes().OfType<MethodDeclarationSyntax>().Any(HasCodeReloadAttribute));

                if (classDeclaration == null)
                {
                    return result;
                }

                result.TypeName = classDeclaration.Identifier.ValueText;

                // The transform lifts bodies into ONE override class for the top-level type chosen
                // above. Tagged methods anywhere else in the file — in a NESTED type (which the
                // weaver still weaves: Cecil's GetTypes() is recursive) or in a sibling top-level
                // type — would otherwise be dropped without a word, leaving a woven prologue that
                // never finds an override. Surface each one loudly; when nothing else is
                // reloadable, these become the reload's error.
                foreach (var method in root.DescendantNodes()
                             .OfType<MethodDeclarationSyntax>().Where(HasCodeReloadAttribute))
                {
                    var owner = method.Ancestors().OfType<TypeDeclarationSyntax>().FirstOrDefault();
                    if (owner == null || owner == classDeclaration)
                        continue;
                    var ownerChain = string.Join(".", method.Ancestors()
                        .OfType<TypeDeclarationSyntax>().Reverse().Select(t => t.Identifier.ValueText));
                    result.SkippedMethods.Add(owner.Parent is TypeDeclarationSyntax
                        ? $"'{method.Identifier.ValueText}' (declared in nested type '{ownerChain}' — " +
                          "code reload only supports methods declared directly in a top-level class)"
                        : $"'{method.Identifier.ValueText}' (declared in '{ownerChain}' — only the first " +
                          $"type with [CodeReload] methods, '{result.TypeName}', is reloaded per file; split the file)");
                }

                var codeReloadableMethods = classDeclaration.Members
                    .OfType<MethodDeclarationSyntax>()
                    .Where(HasCodeReloadAttribute);

                foreach (var method in codeReloadableMethods)
                {
                    var methodName = method.Identifier.ValueText;

                    // Tagged methods must pass the same gate the weaver applies (void or
                    // IEnumerator returns; instance or static). The weaver never weaves a
                    // dispatch prologue into the others, so their override would register and
                    // then never run — reload would report success while silently no-opping.
                    if (!IsMethodLevelSupported(method, out var skipReason))
                    {
                        result.SkippedMethods.Add($"'{methodName}' ({skipReason})");
                        continue;
                    }
                    var methodBody = ExtractMethodBody(method);
                    var signature = ExtractMethodSignature(method);

                    if (methodBody != null)
                    {
                        result.Methods[methodName] = methodBody;
                        result.MethodSignatures[methodName] = signature;
                    }
                }

                Debug.Log($"CodeReload: Extracted {result.Methods.Count} [CodeReload] methods from class {result.TypeName}");
                return result;
            }
            catch (Exception ex)
            {
                Debug.LogError($"CodeReload: Error extracting [CodeReload] methods: {ex.Message}");
                return result;
            }
        }

        /// <summary>
        /// Check if method has [CodeReload] attribute. The unqualified name must match exactly: a
        /// suffix match also catches [OnCodeReload] — the post-reload callback, not a reload target —
        /// and pushing that name makes the player-side registry lookup fail for the whole file.
        /// Internal so <see cref="CodeReloadBaseline"/> hashes exactly the methods extraction picks.
        /// </summary>
        internal static bool HasCodeReloadAttribute(MethodDeclarationSyntax method)
        {
            return method.AttributeLists
                .SelectMany(al => al.Attributes)
                .Any(a => UnqualifiedAttributeName(a) == "CodeReload");
        }

        /// <summary>
        /// Attribute name as the source wrote it, minus any namespace qualifier and the optional
        /// "Attribute" suffix — [Foo.BarAttribute] and [Bar] both yield "Bar".
        /// </summary>
        private static string UnqualifiedAttributeName(AttributeSyntax attr)
        {
            var name = attr.Name.ToString();
            var lastDot = name.LastIndexOf('.');
            if (lastDot >= 0)
                name = name.Substring(lastDot + 1);
            if (name.EndsWith("Attribute"))
                name = name.Substring(0, name.Length - "Attribute".Length);
            return name;
        }

        /// <summary>
        /// Gate for explicitly-tagged [CodeReload] methods, mirroring the skips the weaver applies
        /// (CodeReloadInPlaceILPostProcessor.Process): unsupported return types get no dispatch
        /// prologue, so extracting them would produce an override that never runs. Instance and
        /// STATIC methods both weave (a static dispatches with a null instance). Coroutines
        /// (System.Collections.IEnumerator) are supported: the weaver routes them through the
        /// result dispatch, and the override's iterator — compiled or interpreted — is what
        /// StartCoroutine drives.
        /// </summary>
        private static bool IsMethodLevelSupported(MethodDeclarationSyntax method, out string reason)
        {
            var returnType = method.ReturnType.ToString();
            if (returnType != "void" &&
                returnType is not ("IEnumerator" or "System.Collections.IEnumerator"))
            {
                reason = $"returns {returnType} — void methods and IEnumerator coroutines only";
                return false;
            }

            reason = null;
            return true;
        }

        /// <summary>
        /// Extract method body content (excluding braces).
        /// null when the method has no block body at all (expression-bodied, abstract).
        /// </summary>
        private static string ExtractMethodBody(MethodDeclarationSyntax method)
        {
            if (method.Body == null)
                return null;

            var bodyText = method.Body.ToString().Trim();
            // Remove outer braces
            if (bodyText.StartsWith("{") && bodyText.EndsWith("}"))
            {
                bodyText = bodyText.Substring(1, bodyText.Length - 2).Trim();
            }
            return bodyText;
        }

        /// <summary>
        /// Extract method signature information.
        /// </summary>
        private static MethodSignatureInfo ExtractMethodSignature(MethodDeclarationSyntax method)
        {
            var signature = new MethodSignatureInfo
            {
                ReturnType = method.ReturnType.ToString()
            };

            foreach (var parameter in method.ParameterList.Parameters)
            {
                var paramInfo = new ParameterInfo
                {
                    Type = parameter.Type?.ToString() ?? "object",
                    Name = parameter.Identifier.ValueText,
                    HasDefaultValue = parameter.Default != null,
                    DefaultValue = parameter.Default?.Value?.ToString()
                };

                signature.Parameters.Add(paramInfo);
            }

            return signature;
        }

        /// <summary>
        /// Compile transformed code synchronously (for main thread).
        /// </summary>
        private static CodeReloadCompileResult CompileTransformedCode(
            OverridePreparation prep,
            string assemblyDir,
            bool emitPdb,
            string documentPath,
            bool useInterpreter)
        {
            try
            {
                // Generate a temporary file name for the transformed code
                var tempFileName = $"InPlace_{prep.TypeName}_{DateTime.Now:yyyyMMdd_HHmmss}";

                return CodeReloadCompiler.CompileSourceCodeOnMainThread(
                    prep.TransformedCode,
                    tempFileName,
                    assemblyDir,
                    emitPdb,
                    documentPath,
                    useInterpreter
                        ? new InterpreterOverrideSet
                        {
                            TypeName = prep.TypeName,
                            MethodNames = prep.MethodNames
                        }
                        : null);
            }
            catch (Exception ex)
            {
                Debug.LogError($"CodeReload: Error compiling transformed code for {prep.TypeName}: {ex.Message}");

                return CodeReloadCompileResult.Failure(
                    "Compilation Error",
                    ex.Message,
                    0,
                    new List<string> { ex.ToString() });
            }
        }

        /// <summary>
        /// Result of extracting [CodeReload] methods from source code.
        /// </summary>
        private class CodeReloadableExtractionResult
        {
            /// <summary>
            /// Name of the class containing [CodeReload] methods.
            /// </summary>
            public string TypeName { get; set; }

            /// <summary>
            /// Dictionary of method names to their extracted body code.
            /// </summary>
            public Dictionary<string, string> Methods { get; set; } = new Dictionary<string, string>();

            /// <summary>
            /// Dictionary of method names to their signature information.
            /// </summary>
            public Dictionary<string, MethodSignatureInfo> MethodSignatures { get; set; } = new Dictionary<string, MethodSignatureInfo>();

            /// <summary>
            /// Whether any [CodeReload] methods were found.
            /// </summary>
            public bool HasMethods => Methods.Count > 0;

            /// <summary>
            /// Explicitly-tagged methods that were rejected with the reason ("'Total' (returns
            /// int — void methods and IEnumerator coroutines only)"), so the caller can report
            /// them instead of failing opaquely.
            /// </summary>
            public List<string> SkippedMethods { get; } = new List<string>();
        }
    }

    /// <summary>
    /// Result of in-place code reload processing.
    /// </summary>
    class InPlaceReloadResult
    {
        /// <summary>
        /// Path to the source file that was processed.
        /// </summary>
        public string SourceFilePath { get; set; }

        /// <summary>
        /// Whether the processing was successful.
        /// </summary>
        public bool Success { get; set; }

        /// <summary>
        /// Name of the original type containing [CodeReload] methods.
        /// </summary>
        public string OriginalTypeName { get; set; }

        /// <summary>
        /// List of method names that were extracted and processed.
        /// </summary>
        public List<string> ExtractedMethods { get; set; } = new List<string>();

        /// <summary>
        /// Generated transformed code for code reload assembly.
        /// </summary>
        public string TransformedCode { get; set; }

        /// <summary>
        /// Name of the compiled assembly (if successful).
        /// </summary>
        public string AssemblyName { get; set; }

        /// <summary>
        /// List of registered method IDs (if successful).
        /// </summary>
        public List<string> RegisteredMethods { get; set; } = new List<string>();

        /// <summary>
        /// [CodeReload] method names skipped because they still match the compiled baseline —
        /// their compiled bodies keep running (no interpreter cost).
        /// </summary>
        internal List<string> UpToDateMethods { get; set; } = new List<string>();

        /// <summary>
        /// Method ids whose stale override was removed because the source matches the compiled
        /// baseline again (the edit was reverted).
        /// </summary>
        internal List<string> RevertedMethods { get; set; } = new List<string>();

        /// <summary>Every extracted method matched the baseline; nothing was compiled or registered.</summary>
        internal bool AllUpToDate => Success && ExtractedMethods.Count == 0 && UpToDateMethods.Count > 0;

        /// <summary>
        /// Error message if processing failed.
        /// </summary>
        public string ErrorMessage { get; set; }

        /// <summary>
        /// Compilation diagnostics (warnings, errors).
        /// </summary>
        public List<string> CompilationDiagnostics { get; set; } = new List<string>();

        /// <summary>
        /// Execution time in milliseconds.
        /// </summary>
        public long ExecutionTimeMs { get; set; }
    }

    /// <summary>
    /// Result of compiling an override for pushing to a player (no local registration).
    /// </summary>
    internal class PushCompileResult
    {
        public bool Success { get; set; }
        public string TypeName { get; set; }
        public List<string> MethodNames { get; set; } = new List<string>();
        public byte[] IlBytes { get; set; }
        public string Error { get; set; }
        public List<string> Diagnostics { get; set; } = new List<string>();

        /// <summary>[CodeReload] method names skipped because they still match the compiled baseline.</summary>
        public List<string> UpToDateMethods { get; set; } = new List<string>();

        /// <summary>Every extracted method matched the baseline; there is nothing to push.</summary>
        public bool AllUpToDate => Success && MethodNames.Count == 0 && UpToDateMethods.Count > 0;
    }
}