#nullable enable

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;

namespace ShrinkSDK.CodeGen
{

public static class ShrinkAssemblyWeaver
{
    public const string Version = "0.1.0";
    private const string EventRuntime = "ShrinkEventBus.Runtime";
    private const string NetworkEventIntegration = "ShrinkNetwork.Integration.EventBus";

    public static ShrinkWeaveResult Weave(
        string assemblyPath,
        string? pdbPath,
        IEnumerable<string> referencePaths,
        string outputAssemblyPath,
        string? outputPdbPath,
        ShrinkCodeGenPlatform platform = ShrinkCodeGenPlatform.EngineNeutral,
        string? strongNameKeyPath = null)
    {
        var diagnostics = new List<ShrinkCodeGenDiagnostic>();
        var references = referencePaths.Where(File.Exists).Select(Path.GetFullPath).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
        using var resolver = new PathAssemblyResolver(references.Append(assemblyPath));
        try
        {
            var hasSymbols = !string.IsNullOrWhiteSpace(pdbPath) && File.Exists(pdbPath);
            var reader = new ReaderParameters
            {
                AssemblyResolver = resolver,
                ReadingMode = ReadingMode.Immediate,
                ReadSymbols = hasSymbols,
                SymbolReaderProvider = hasSymbols ? new PortablePdbReaderProvider() : null
            };
            using var assemblyInput = new MemoryStream(File.ReadAllBytes(assemblyPath));
            using var symbolInput = hasSymbols ? new MemoryStream(File.ReadAllBytes(pdbPath!)) : null;
            if (hasSymbols)
                reader.SymbolStream = symbolInput;

            using var assembly = AssemblyDefinition.ReadAssembly(assemblyInput, reader);
            resolver.SetSelf(assembly);
            byte[]? strongNameKey = null;
            if (assembly.Name.HasPublicKey)
            {
                if (string.IsNullOrWhiteSpace(strongNameKeyPath))
                    throw new InvalidOperationException("Signed assemblies are not modified unless ShrinkCodeGenStrongNameKeyFile is configured.");
                if (!File.Exists(strongNameKeyPath))
                    throw new InvalidOperationException($"Strong-name key file does not exist: {strongNameKeyPath}");
                strongNameKey = File.ReadAllBytes(strongNameKeyPath);
            }

            var module = assembly.MainModule;
            var marker = FindType(module, "ShrinkSDK.Runtime.ShrinkCodeGenWovenAttribute", "ShrinkRuntime.Abstractions");
            var existingMarker = marker == null ? null : assembly.CustomAttributes.FirstOrDefault(a => a.AttributeType.FullName == marker.FullName);
            if (existingMarker != null)
            {
                var wovenVersion = existingMarker.ConstructorArguments.Count > 0
                    ? existingMarker.ConstructorArguments[0].Value as string
                    : null;
                if (wovenVersion == Version)
                    return new ShrinkWeaveResult(false, 0, 0, 0, diagnostics);
                throw new InvalidOperationException($"Assembly was woven by ShrinkSDK.CodeGen {wovenVersion ?? "unknown"}. Run a clean rebuild before weaving with {Version}.");
            }

            var inputMvid = module.Mvid.ToString("D");
            var instanceCount = 0;
            var staticCount = 0;
            if (References(module, EventRuntime))
                WeaveEventBus(module, platform, ref instanceCount, ref staticCount);
            var registryCount = WeaveRegistries(module);
            if (References(module, NetworkEventIntegration))
                registryCount += WeaveNetworkEventBindings(module);
            if (marker != null)
                AddMarker(module, marker, inputMvid);

            Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(outputAssemblyPath))!);
            using var symbolOutput = hasSymbols ? new MemoryStream() : null;
            var writer = new WriterParameters
            {
                WriteSymbols = hasSymbols,
                SymbolWriterProvider = hasSymbols ? new PortablePdbWriterProvider() : null,
                SymbolStream = symbolOutput,
                StrongNameKeyBlob = strongNameKey
            };
            assembly.Write(outputAssemblyPath, writer);
            if (hasSymbols && !string.IsNullOrWhiteSpace(outputPdbPath))
                File.WriteAllBytes(outputPdbPath!, symbolOutput!.ToArray());
            return new ShrinkWeaveResult(true, instanceCount, staticCount, registryCount, diagnostics);
        }
        catch (Exception exception)
        {
            diagnostics.Add(new ShrinkCodeGenDiagnostic(ShrinkCodeGenDiagnosticSeverity.Error, exception.Message));
            return new ShrinkWeaveResult(false, 0, 0, 0, diagnostics);
        }
    }

    private static void WeaveEventBus(ModuleDefinition module, ShrinkCodeGenPlatform platform,
        ref int instanceCount, ref int staticCount)
    {
        var subscriberAttribute = RequireType(module, "ShrinkEventBus.ShrinkEventSubscriberAttribute", EventRuntime);
        var subscribeAttribute = RequireType(module, "ShrinkEventBus.ShrinkSubscribeAttribute", EventRuntime);
        var allTypes = AllTypes(module.Types).Where(type => !type.IsInterface).ToArray();
        foreach (var type in allTypes.Where(type => HasAttribute(type, subscriberAttribute)))
        {
            var instanceHandlers = type.Methods.Where(method => !method.IsStatic && HasAttribute(method, subscribeAttribute)).ToArray();
            if (instanceHandlers.Length > 0)
            {
                var lifetime = ReadInt(type.CustomAttributes.First(a => a.AttributeType.FullName == subscriberAttribute.FullName), "Lifetime", 0);
                if (InjectInstanceBinding(module, type, instanceHandlers, subscribeAttribute))
                    instanceCount++;
                if (lifetime == 1 && platform == ShrinkCodeGenPlatform.Unity)
                    InjectAwakeToDestroyLifetime(type, module);
                else if (lifetime != 0)
                    throw new InvalidOperationException($"{type.FullName}: engine-neutral weaving supports Manual lifetime only. Godot Nodes should attach from _Ready and dispose from _ExitTree.");
            }
        }

        var staticTypes = allTypes.Where(type => HasAttribute(type, subscriberAttribute))
            .Where(type => type.Methods.Any(method => method.IsStatic && HasAttribute(method, subscribeAttribute)))
            .ToArray();
        if (staticTypes.Length > 0)
        {
            staticCount = staticTypes.Sum(type => type.Methods.Count(method => method.IsStatic && HasAttribute(method, subscribeAttribute)));
            InjectStaticBootstrap(module, staticTypes, subscriberAttribute, subscribeAttribute);
        }
    }

    private static void InjectAwakeToDestroyLifetime(TypeDefinition type, ModuleDefinition module)
    {
        if (!InheritsFrom(type, "UnityEngine.MonoBehaviour"))
            throw new InvalidOperationException($"[ShrinkEventSubscriber(Lifetime = AwakeToDestroy)] requires MonoBehaviour: {type.FullName}.");

        const string bindingFieldName = "__shrinkEventBusAwakeToDestroyBinding";
        if (type.Fields.Any(field => field.Name == bindingFieldName))
            throw new InvalidOperationException($"Reserved generated field already exists on {type.FullName}: {bindingFieldName}.");

        var disposableType = module.ImportReference(typeof(IDisposable));
        var bindingField = new FieldDefinition(bindingFieldName, FieldAttributes.Private, disposableType);
        type.Fields.Add(bindingField);
        var eventBusType = RequireType(module, "ShrinkEventBus.EventBus", EventRuntime);
        var attachMethod = ImportMethod(module, eventBusType,
            method => method.Name == "Attach" && method.IsStatic && method.Parameters.Count == 2);
        var disposeMethod = module.ImportReference(typeof(IDisposable).GetMethod(nameof(IDisposable.Dispose))
            ?? throw new InvalidOperationException("IDisposable.Dispose was not found."));
        InjectAwake(type, module, bindingField, attachMethod);
        InjectOnDestroy(type, module, bindingField, disposeMethod);
    }

    private static void InjectAwake(TypeDefinition type, ModuleDefinition module,
        FieldDefinition bindingField, MethodReference attachMethod)
    {
        var awake = type.Methods.FirstOrDefault(method =>
            method.Name == "Awake" && !method.IsStatic && method.Parameters.Count == 0);
        if (awake != null)
        {
            InsertAttachAtStart(awake, module, bindingField, attachMethod);
            return;
        }

        var baseAwake = FindBaseMethodReference(type, "Awake", module);
        awake = new MethodDefinition("Awake",
            baseAwake != null
                ? MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual
                : MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot,
            module.TypeSystem.Void);
        awake.Body.InitLocals = true;
        var il = awake.Body.GetILProcessor();
        if (baseAwake != null)
        {
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Call, baseAwake);
        }
        EmitAttach(il, awake, module, bindingField, attachMethod);
        il.Emit(OpCodes.Ret);
        type.Methods.Add(awake);
    }

    private static void InjectOnDestroy(TypeDefinition type, ModuleDefinition module,
        FieldDefinition bindingField, MethodReference disposeMethod)
    {
        var onDestroy = type.Methods.FirstOrDefault(method =>
            method.Name == "OnDestroy" && !method.IsStatic && method.Parameters.Count == 0);
        if (onDestroy != null)
        {
            InsertDisposeAtStart(onDestroy, bindingField, disposeMethod);
            return;
        }

        var baseOnDestroy = FindBaseMethodReference(type, "OnDestroy", module);
        onDestroy = new MethodDefinition("OnDestroy",
            baseOnDestroy != null
                ? MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual
                : MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot,
            module.TypeSystem.Void);
        var il = onDestroy.Body.GetILProcessor();
        EmitDispose(il, bindingField, disposeMethod);
        if (baseOnDestroy != null)
        {
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Call, baseOnDestroy);
        }
        il.Emit(OpCodes.Ret);
        type.Methods.Add(onDestroy);
    }

    private static void InsertAttachAtStart(MethodDefinition method, ModuleDefinition module,
        FieldDefinition bindingField, MethodReference attachMethod)
    {
        if (!method.HasBody || method.Body.Instructions.Count == 0)
            throw new InvalidOperationException($"Awake has no body: {method.FullName}.");
        method.Body.InitLocals = true;
        var processor = method.Body.GetILProcessor();
        var instructions = BuildAttachInstructions(processor, method, module, bindingField, attachMethod);
        var first = method.Body.Instructions[0];
        foreach (var instruction in instructions)
            processor.InsertBefore(first, instruction);
    }

    private static void EmitAttach(ILProcessor il, MethodDefinition method, ModuleDefinition module,
        FieldDefinition bindingField, MethodReference attachMethod)
    {
        foreach (var instruction in BuildAttachInstructions(il, method, module, bindingField, attachMethod))
            il.Append(instruction);
    }

    private static IReadOnlyList<Instruction> BuildAttachInstructions(ILProcessor il,
        MethodDefinition method, ModuleDefinition module, FieldDefinition bindingField,
        MethodReference attachMethod)
    {
        var defaultBusType = module.ImportReference(attachMethod.Parameters[1].ParameterType);
        var defaultBus = new VariableDefinition(defaultBusType);
        method.Body.Variables.Add(defaultBus);
        var attached = il.Create(OpCodes.Nop);
        return new[]
        {
            il.Create(OpCodes.Ldarg_0),
            il.Create(OpCodes.Ldfld, bindingField),
            il.Create(OpCodes.Brtrue_S, attached),
            il.Create(OpCodes.Ldarg_0),
            il.Create(OpCodes.Ldarg_0),
            il.Create(OpCodes.Ldloca_S, defaultBus),
            il.Create(OpCodes.Initobj, defaultBusType),
            il.Create(OpCodes.Ldloc, defaultBus),
            il.Create(OpCodes.Call, attachMethod),
            il.Create(OpCodes.Stfld, bindingField),
            attached
        };
    }

    private static void InsertDisposeAtStart(MethodDefinition method,
        FieldDefinition bindingField, MethodReference disposeMethod)
    {
        if (!method.HasBody || method.Body.Instructions.Count == 0)
            throw new InvalidOperationException($"OnDestroy has no body: {method.FullName}.");
        var processor = method.Body.GetILProcessor();
        var instructions = BuildDisposeInstructions(processor, bindingField, disposeMethod);
        var first = method.Body.Instructions[0];
        foreach (var instruction in instructions)
            processor.InsertBefore(first, instruction);
    }

    private static void EmitDispose(ILProcessor il, FieldDefinition bindingField,
        MethodReference disposeMethod)
    {
        foreach (var instruction in BuildDisposeInstructions(il, bindingField, disposeMethod))
            il.Append(instruction);
    }

    private static IReadOnlyList<Instruction> BuildDisposeInstructions(ILProcessor il,
        FieldDefinition bindingField, MethodReference disposeMethod)
    {
        var disposed = il.Create(OpCodes.Nop);
        return new[]
        {
            il.Create(OpCodes.Ldarg_0),
            il.Create(OpCodes.Ldfld, bindingField),
            il.Create(OpCodes.Brfalse_S, disposed),
            il.Create(OpCodes.Ldarg_0),
            il.Create(OpCodes.Ldfld, bindingField),
            il.Create(OpCodes.Callvirt, disposeMethod),
            il.Create(OpCodes.Ldarg_0),
            il.Create(OpCodes.Ldnull),
            il.Create(OpCodes.Stfld, bindingField),
            disposed
        };
    }

    private static MethodReference? FindBaseMethodReference(TypeDefinition type,
        string methodName, ModuleDefinition module)
    {
        try
        {
            var baseTypeReference = type.BaseType;
            while (baseTypeReference != null)
            {
                var baseType = baseTypeReference.Resolve();
                if (baseType == null) break;
                var method = baseType.Methods.FirstOrDefault(candidate =>
                    candidate.Name == methodName && !candidate.IsStatic && candidate.IsVirtual &&
                    candidate.Parameters.Count == 0);
                if (method != null)
                {
                    if (baseTypeReference is GenericInstanceType genericBase)
                    {
                        return new MethodReference(method.Name, module.ImportReference(method.ReturnType),
                            module.ImportReference(genericBase))
                        {
                            HasThis = method.HasThis,
                            ExplicitThis = method.ExplicitThis,
                            CallingConvention = method.CallingConvention
                        };
                    }
                    return module.ImportReference(method);
                }
                baseTypeReference = baseType.BaseType;
            }
        }
        catch { }
        return null;
    }

    private static bool InheritsFrom(TypeDefinition type, string expectedFullName)
    {
        var current = type.BaseType;
        while (current != null)
        {
            if (current.FullName == expectedFullName) return true;
            try { current = current.Resolve()?.BaseType; }
            catch { return false; }
        }
        return false;
    }

    private static bool InjectInstanceBinding(ModuleDefinition module, TypeDefinition owner,
        IReadOnlyList<MethodDefinition> handlers, TypeReference subscribeAttribute)
    {
        var generatedInterface = RequireType(module, "ShrinkEventBus.IShrinkGeneratedSubscriber", EventRuntime);
        if (owner.Interfaces.Any(item => item.InterfaceType.FullName == generatedInterface.FullName))
            return false;
        var resolverType = RequireType(module, "ShrinkEventBus.IShrinkBusResolver", EventRuntime);
        var busKeyType = RequireType(module, "ShrinkEventBus.ShrinkBusKey", EventRuntime);
        var bindingType = RequireType(module, "ShrinkEventBus.ShrinkEventBinding", EventRuntime);
        var helperType = RequireType(module, "ShrinkEventBus.ShrinkGeneratedBinding", EventRuntime);
        var disposableType = RequireType(module, "System.IDisposable", module.TypeSystem.CoreLibrary.Name);
        var nullableBusKey = GenericType(module, "System.Nullable`1", true, busKeyType);
        var bindingCtor = ImportMethod(module, bindingType, method => method.IsConstructor && method.Parameters.Count == 0);
        var bindingAdd = ImportMethod(module, bindingType, method => method.Name == "Add" && method.Parameters.Count == 1);
        var interfaceMethod = ImportMethod(module, generatedInterface, method => method.Name == "AttachGenerated");
        var syncSubscribe = ImportMethod(module, helperType, method => method.Name == "Subscribe" && method.HasGenericParameters);
        var asyncSubscribe = ImportMethod(module, helperType, method => method.Name == "SubscribeAsync" && method.HasGenericParameters);
        var legacySubscribe = ImportMethod(module, helperType, method => method.Name == "SubscribeAsyncLegacy" && method.HasGenericParameters);
        var asyncHandlerType = RequireType(module, "ShrinkEventBus.ShrinkAsyncEventHandler`1", EventRuntime);

        var generated = new MethodDefinition("ShrinkEventBus.IShrinkGeneratedSubscriber.AttachGenerated",
            MethodAttributes.Private | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual,
            disposableType);
        generated.Parameters.Add(new ParameterDefinition("resolver", ParameterAttributes.None, resolverType));
        generated.Parameters.Add(new ParameterDefinition("defaultBus", ParameterAttributes.Optional, nullableBusKey));
        generated.Overrides.Add(interfaceMethod);
        generated.Body.InitLocals = true;
        var bindingLocal = new VariableDefinition(bindingType);
        generated.Body.Variables.Add(bindingLocal);
        var il = generated.Body.GetILProcessor();
        il.Emit(OpCodes.Newobj, bindingCtor);
        il.Emit(OpCodes.Stloc, bindingLocal);
        var classDefaultBus = ReadString(owner.CustomAttributes.First(a => a.AttributeType.FullName == "ShrinkEventBus.ShrinkEventSubscriberAttribute"), "DefaultBus");
        foreach (var handler in handlers)
            EmitInstanceSubscription(module, il, handler, handler.CustomAttributes.First(a => a.AttributeType.FullName == subscribeAttribute.FullName), classDefaultBus,
                bindingLocal, bindingAdd, syncSubscribe, asyncSubscribe, legacySubscribe, asyncHandlerType);
        il.Emit(OpCodes.Ldloc, bindingLocal);
        il.Emit(OpCodes.Ret);
        owner.Interfaces.Add(new InterfaceImplementation(generatedInterface));
        owner.Methods.Add(generated);
        return true;
    }

    private static void EmitInstanceSubscription(ModuleDefinition module, ILProcessor il, MethodDefinition handler,
        CustomAttribute attribute, string classDefaultBus, VariableDefinition bindingLocal, MethodReference bindingAdd,
        MethodReference syncSubscribe, MethodReference asyncSubscribe, MethodReference legacySubscribe, TypeReference asyncHandlerType)
    {
        var signature = ResolveEventHandler(module, handler, syncSubscribe, asyncSubscribe, legacySubscribe, asyncHandlerType);
        var bus = ReadString(attribute, "Bus");
        if (string.IsNullOrWhiteSpace(bus)) bus = classDefaultBus;
        il.Emit(OpCodes.Ldloc, bindingLocal);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ldarg_2);
        il.Emit(OpCodes.Ldstr, bus ?? string.Empty);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldftn, module.ImportReference(handler));
        il.Emit(OpCodes.Newobj, DelegateConstructor(module, signature.DelegateType));
        EmitOptions(il, attribute);
        il.Emit(OpCodes.Call, signature.Method);
        il.Emit(OpCodes.Callvirt, bindingAdd);
    }

    private static void InjectStaticBootstrap(ModuleDefinition module, IReadOnlyList<TypeDefinition> types,
        TypeReference subscriberAttribute, TypeReference subscribeAttribute)
    {
        if (module.Types.Any(type => type.FullName == "ShrinkEventBus.Generated.ShrinkGeneratedStaticBindings"))
            return;
        var registry = RequireType(module, "ShrinkEventBus.ShrinkStaticBindingRegistry", EventRuntime);
        var syncRegister = ImportMethod(module, registry, method => method.Name == "Register" && method.HasGenericParameters);
        var asyncRegister = ImportMethod(module, registry, method => method.Name == "RegisterAsync" && method.HasGenericParameters);
        var legacyRegister = ImportMethod(module, registry, method => method.Name == "RegisterAsyncLegacy" && method.HasGenericParameters);
        var asyncHandlerType = RequireType(module, "ShrinkEventBus.ShrinkAsyncEventHandler`1", EventRuntime);
        var bootstrap = new TypeDefinition("ShrinkEventBus.Generated", "ShrinkGeneratedStaticBindings",
            TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.NotPublic, module.TypeSystem.Object);
        module.Types.Add(bootstrap);
        var register = new MethodDefinition("Register", MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig, module.TypeSystem.Void);
        bootstrap.Methods.Add(register);
        var il = register.Body.GetILProcessor();
        foreach (var type in types)
        {
            var classBus = ReadString(type.CustomAttributes.First(a => a.AttributeType.FullName == subscriberAttribute.FullName), "DefaultBus");
            foreach (var handler in type.Methods.Where(method => method.IsStatic && HasAttribute(method, subscribeAttribute)).ToArray())
            {
                var attribute = handler.CustomAttributes.First(a => a.AttributeType.FullName == subscribeAttribute.FullName);
                var signature = ResolveEventHandler(module, handler, syncRegister, asyncRegister, legacyRegister, asyncHandlerType);
                var bus = ReadString(attribute, "Bus");
                if (string.IsNullOrWhiteSpace(bus)) bus = classBus;
                var bridge = CreateStaticBridge(module, handler);
                il.Emit(OpCodes.Ldstr, bus ?? string.Empty);
                il.Emit(OpCodes.Ldnull);
                il.Emit(OpCodes.Ldftn, bridge);
                il.Emit(OpCodes.Newobj, DelegateConstructor(module, signature.DelegateType));
                EmitOptions(il, attribute);
                il.Emit(OpCodes.Call, signature.Method);
            }
        }
        il.Emit(OpCodes.Ret);
        var moduleType = module.Types.First(type => type.Name == "<Module>");
        var initializer = moduleType.Methods.FirstOrDefault(method => method.Name == ".cctor");
        if (initializer == null)
        {
            initializer = new MethodDefinition(".cctor", MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig |
                MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, module.TypeSystem.Void);
            initializer.Body.GetILProcessor().Emit(OpCodes.Ret);
            moduleType.Methods.Add(initializer);
        }
        initializer.Body.GetILProcessor().InsertBefore(initializer.Body.Instructions[0], Instruction.Create(OpCodes.Call, register));
    }

    private static (MethodReference Method, TypeReference DelegateType) ResolveEventHandler(ModuleDefinition module,
        MethodDefinition handler, MethodReference sync, MethodReference async, MethodReference legacy, TypeReference asyncHandlerType)
    {
        if (handler.Parameters.Count is < 1 or > 2)
            throw new InvalidOperationException($"{handler.FullName}: [ShrinkSubscribe] requires one event parameter and an optional CancellationToken.");
        var eventType = module.ImportReference(handler.Parameters[0].ParameterType);
        var eventInterface = RequireType(module, "ShrinkEventBus.IShrinkEvent", EventRuntime);
        if (!Implements(eventType, eventInterface.FullName))
            throw new InvalidOperationException($"{handler.FullName}: event parameter must implement IShrinkEvent.");

        MethodReference open;
        TypeReference delegateType;
        if (handler.ReturnType.MetadataType == MetadataType.Void && handler.Parameters.Count == 1)
        {
            open = sync;
            delegateType = GenericType(module, "System.Action`1", false, eventType);
        }
        else if (handler.ReturnType.FullName == "Cysharp.Threading.Tasks.UniTask" && handler.Parameters.Count == 1)
        {
            open = legacy;
            delegateType = GenericType(module, "System.Func`2", false, eventType, module.ImportReference(handler.ReturnType));
        }
        else if (handler.ReturnType.FullName == "Cysharp.Threading.Tasks.UniTask" && handler.Parameters.Count == 2 &&
                 handler.Parameters[1].ParameterType.FullName == "System.Threading.CancellationToken")
        {
            open = async;
            delegateType = new GenericInstanceType(asyncHandlerType) { GenericArguments = { eventType } };
        }
        else
            throw new InvalidOperationException($"Unsupported [ShrinkSubscribe] signature: {handler.FullName}.");
        var closed = new GenericInstanceMethod(open);
        closed.GenericArguments.Add(eventType);
        return (closed, delegateType);
    }

    private static MethodReference CreateStaticBridge(ModuleDefinition module, MethodDefinition handler)
    {
        var bridge = new MethodDefinition($"ShrinkEventBus.GeneratedStaticHandler_{handler.MetadataToken.ToInt32():X8}",
            MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig, module.ImportReference(handler.ReturnType));
        foreach (var parameter in handler.Parameters)
            bridge.Parameters.Add(new ParameterDefinition(parameter.Name, parameter.Attributes, module.ImportReference(parameter.ParameterType)));
        var il = bridge.Body.GetILProcessor();
        foreach (var parameter in bridge.Parameters) il.Emit(OpCodes.Ldarg, parameter);
        il.Emit(OpCodes.Call, module.ImportReference(handler));
        il.Emit(OpCodes.Ret);
        handler.DeclaringType.Methods.Add(bridge);
        return bridge;
    }

    private static void EmitOptions(ILProcessor il, CustomAttribute attribute)
    {
        il.Emit(OpCodes.Ldc_I4, ReadInt(attribute, "Priority", 2));
        il.Emit(OpCodes.Ldc_I4, ReadInt(attribute, "NumericPriority", 0));
        il.Emit(ReadBool(attribute, "ReceiveCanceled", false) ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
    }

    private static int WeaveRegistries(ModuleDefinition module)
    {
        var count = 0;
        count += AddRegistry(module, "ShrinkCommand.ShrinkCommandSubscriberAttribute", "ShrinkCommand.Runtime",
            "ShrinkCommand.ShrinkCommandStaticRegistryAttribute", type =>
                type.Methods.Any(method => method.IsStatic && HasAttribute(method, "ShrinkCommand.ShrinkCommandAttribute")));
        count += AddRegistry(module, "ShrinkNetwork.ShrinkNetworkMessageAttribute", "ShrinkNetwork.Runtime",
            "ShrinkNetwork.ShrinkNetworkMessageRegistryAttribute", _ => true);
        count += AddRegistry(module, "ShrinkNetwork.ShrinkNetworkSubscriberAttribute", "ShrinkNetwork.Runtime",
            "ShrinkNetwork.ShrinkNetworkStaticSubscriberRegistryAttribute", type =>
                type.Methods.Any(method => method.IsStatic && HasAttribute(method, "ShrinkNetwork.ShrinkNetworkSubscribeAttribute")));
        count += AddAppRegistry(module);
        ValidateDuplicateNetworkContracts(module);
        ValidateDuplicateCommandPaths(module);
        return count;
    }

    private static int WeaveNetworkEventBindings(ModuleDefinition module)
    {
        if (module.Types.Any(type => type.FullName ==
                                     "ShrinkNetwork.Integration.Generated.ShrinkGeneratedNetworkEventBindings"))
            return 0;
        var networkEventAttribute = FindType(module,
            "ShrinkNetwork.Integration.ShrinkNetworkEventAttribute", NetworkEventIntegration);
        var messageAttribute = FindType(module,
            "ShrinkNetwork.ShrinkNetworkMessageAttribute", "ShrinkNetwork.Runtime");
        var registryType = FindType(module,
            "ShrinkNetwork.Integration.ShrinkNetworkEventRegistry", NetworkEventIntegration);
        if (networkEventAttribute == null || messageAttribute == null || registryType == null)
            return 0;

        var registrations = AllTypes(module.Types)
            .Where(type => !type.IsAbstract && HasAttribute(type, networkEventAttribute))
            .Select(type => new
            {
                Type = type,
                Message = type.CustomAttributes.FirstOrDefault(attribute =>
                    attribute.AttributeType.FullName == messageAttribute.FullName)
            })
            .Where(item => item.Message != null)
            .ToArray();
        if (registrations.Length == 0) return 0;

        var registerOpen = ImportMethod(module, registryType,
            method => method.Name == "Register" && method.HasGenericParameters);
        var bootstrap = new TypeDefinition("ShrinkNetwork.Integration.Generated",
            "ShrinkGeneratedNetworkEventBindings",
            TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.NotPublic,
            module.TypeSystem.Object);
        module.Types.Add(bootstrap);
        var register = new MethodDefinition("Register",
            MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig,
            module.TypeSystem.Void);
        bootstrap.Methods.Add(register);
        var il = register.Body.GetILProcessor();
        foreach (var item in registrations)
        {
            var attribute = item.Message!;
            if (attribute.ConstructorArguments.Count == 0)
                throw new InvalidOperationException($"[ShrinkNetworkMessage] on {item.Type.FullName} has no opcode.");
            var opcode = Convert.ToInt32(attribute.ConstructorArguments[0].Value);
            var route = attribute.ConstructorArguments.Count > 1
                ? attribute.ConstructorArguments[1].Value as string
                : null;
            var registerClosed = new GenericInstanceMethod(registerOpen);
            registerClosed.GenericArguments.Add(module.ImportReference(item.Type));
            il.Emit(OpCodes.Ldc_I4, opcode);
            if (route == null) il.Emit(OpCodes.Ldnull);
            else il.Emit(OpCodes.Ldstr, route);
            il.Emit(OpCodes.Call, registerClosed);
        }
        il.Emit(OpCodes.Ret);
        var moduleType = module.Types.First(type => type.Name == "<Module>");
        var initializer = moduleType.Methods.FirstOrDefault(method => method.Name == ".cctor");
        if (initializer == null)
        {
            initializer = new MethodDefinition(".cctor",
                MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig |
                MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
                module.TypeSystem.Void);
            initializer.Body.GetILProcessor().Emit(OpCodes.Ret);
            moduleType.Methods.Add(initializer);
        }
        initializer.Body.GetILProcessor().InsertBefore(initializer.Body.Instructions[0],
            Instruction.Create(OpCodes.Call, register));
        return registrations.Length;
    }

    private static int AddRegistry(ModuleDefinition module, string markerName, string assemblyName,
        string registryName, Func<TypeDefinition, bool> predicate)
    {
        var marker = FindType(module, markerName, assemblyName);
        var registry = FindType(module, registryName, assemblyName);
        if (marker == null || registry == null) return 0;
        if (module.Assembly.CustomAttributes.Any(attribute => attribute.AttributeType.FullName == registry.FullName))
            return 0;
        var types = AllTypes(module.Types).Where(type => HasAttribute(type, marker)).Where(predicate).ToArray();
        if (types.Length == 0) return 0;
        AddTypeArrayAttribute(module, registry, types);
        return types.Length;
    }

    private static int AddAppRegistry(ModuleDefinition module)
    {
        var marker = FindType(module, "ShrinkApp.ShrinkAppModuleInstallerAttribute", "ShrinkApp.Core.Runtime");
        var contract = FindType(module, "ShrinkApp.IShrinkAppModuleInstaller", "ShrinkApp.Core.Runtime");
        var registry = FindType(module, "ShrinkApp.ShrinkAppInstallerRegistryAttribute", "ShrinkApp.Core.Runtime");
        if (marker == null || contract == null || registry == null) return 0;
        if (module.Assembly.CustomAttributes.Any(attribute => attribute.AttributeType.FullName == registry.FullName))
            return 0;
        var types = AllTypes(module.Types).Where(type => !type.IsAbstract && HasAttribute(type, marker) && Implements(type, contract.FullName)).ToArray();
        if (types.Length == 0) return 0;
        AddTypeArrayAttribute(module, registry, types);
        return types.Length;
    }

    private static void AddTypeArrayAttribute(ModuleDefinition module, TypeReference registry, IReadOnlyList<TypeDefinition> types)
    {
        var ctor = ImportMethod(module, registry, method => method.IsConstructor && method.Parameters.Count == 1 && method.Parameters[0].ParameterType.IsArray);
        var typeRef = new TypeReference("System", "Type", module, module.TypeSystem.CoreLibrary);
        var typeArray = new ArrayType(typeRef);
        var attribute = new CustomAttribute(ctor);
        attribute.ConstructorArguments.Add(new CustomAttributeArgument(typeArray,
            types.Select(type => new CustomAttributeArgument(typeRef, module.ImportReference(type))).ToArray()));
        module.Assembly.CustomAttributes.Add(attribute);
    }

    private static void ValidateDuplicateNetworkContracts(ModuleDefinition module)
    {
        var seen = new Dictionary<string, string>(StringComparer.Ordinal);
        foreach (var type in AllTypes(module.Types))
        foreach (var attribute in type.CustomAttributes.Where(a => a.AttributeType.FullName == "ShrinkNetwork.ShrinkNetworkMessageAttribute"))
        {
            var opcode = Convert.ToInt32(attribute.ConstructorArguments[0].Value);
            var route = attribute.ConstructorArguments.Count > 1 ? attribute.ConstructorArguments[1].Value as string ?? string.Empty : string.Empty;
            var key = $"{opcode}:{route}";
            if (seen.TryGetValue(key, out var previous))
                throw new InvalidOperationException($"Duplicate network opcode/route {key}: {previous} and {type.FullName}.");
            seen[key] = type.FullName;
        }
    }

    private static void ValidateDuplicateCommandPaths(ModuleDefinition module)
    {
        var seen = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        foreach (var type in AllTypes(module.Types))
        foreach (var method in type.Methods)
        foreach (var attribute in method.CustomAttributes.Where(a => a.AttributeType.FullName == "ShrinkCommand.ShrinkCommandAttribute"))
        {
            var path = attribute.ConstructorArguments[0].Value as string ?? string.Empty;
            if (seen.TryGetValue(path, out var previous))
                throw new InvalidOperationException($"Duplicate command path '{path}': {previous} and {method.FullName}.");
            seen[path] = method.FullName;
        }
    }

    private static void AddMarker(ModuleDefinition module, TypeReference marker, string inputMvid)
    {
        var ctor = ImportMethod(module, marker, method => method.IsConstructor && method.Parameters.Count == 2);
        var attribute = new CustomAttribute(ctor);
        attribute.ConstructorArguments.Add(new CustomAttributeArgument(module.TypeSystem.String, Version));
        attribute.ConstructorArguments.Add(new CustomAttributeArgument(module.TypeSystem.String, inputMvid));
        module.Assembly.CustomAttributes.Add(attribute);
    }

    private static bool References(ModuleDefinition module, string assemblyName) =>
        module.AssemblyReferences.Any(reference => string.Equals(reference.Name, assemblyName, StringComparison.Ordinal));

    private static TypeReference RequireType(ModuleDefinition module, string fullName, string assemblyName) =>
        FindType(module, fullName, assemblyName) ?? throw new InvalidOperationException($"Required type {fullName} was not found in {assemblyName}.");

    private static TypeReference? FindType(ModuleDefinition module, string fullName, string assemblyName)
    {
        if (string.Equals(module.Assembly.Name.Name, assemblyName, StringComparison.Ordinal))
            return module.GetType(fullName);
        var reference = module.AssemblyReferences.FirstOrDefault(item => string.Equals(item.Name, assemblyName, StringComparison.Ordinal));
        if (reference == null) return null;
        var assembly = module.AssemblyResolver.Resolve(reference);
        return assembly?.MainModule.GetType(fullName) is { } definition ? module.ImportReference(definition) : null;
    }

    private static MethodReference ImportMethod(ModuleDefinition module, TypeReference type, Func<MethodDefinition, bool> predicate)
    {
        var definition = type.Resolve() ?? throw new InvalidOperationException($"Unable to resolve {type.FullName}.");
        var method = definition.Methods.SingleOrDefault(predicate) ?? throw new InvalidOperationException($"Required method was not found on {type.FullName}.");
        return module.ImportReference(method);
    }

    private static IEnumerable<TypeDefinition> AllTypes(IEnumerable<TypeDefinition> roots)
    {
        foreach (var type in roots)
        {
            yield return type;
            foreach (var nested in AllTypes(type.NestedTypes)) yield return nested;
        }
    }

    private static bool HasAttribute(ICustomAttributeProvider provider, TypeReference attribute) => HasAttribute(provider, attribute.FullName);
    private static bool HasAttribute(ICustomAttributeProvider provider, string fullName) => provider.CustomAttributes.Any(a => a.AttributeType.FullName == fullName);

    private static bool Implements(TypeReference type, string interfaceFullName)
    {
        try
        {
            TypeDefinition? current = type.Resolve();
            while (current != null)
            {
                if (current.Interfaces.Any(item => item.InterfaceType.FullName == interfaceFullName)) return true;
                current = current.BaseType?.Resolve();
            }
        }
        catch { }
        return false;
    }

    private static TypeReference GenericType(ModuleDefinition module, string name, bool valueType, params TypeReference[] arguments)
    {
        var open = new TypeReference("System", name.Substring(name.LastIndexOf('.') + 1), module, module.TypeSystem.CoreLibrary, valueType);
        var result = new GenericInstanceType(open);
        foreach (var argument in arguments) result.GenericArguments.Add(argument);
        return result;
    }

    private static MethodReference DelegateConstructor(ModuleDefinition module, TypeReference delegateType)
    {
        var ctor = new MethodReference(".ctor", module.TypeSystem.Void, delegateType) { HasThis = true };
        ctor.Parameters.Add(new ParameterDefinition(module.TypeSystem.Object));
        ctor.Parameters.Add(new ParameterDefinition(module.TypeSystem.IntPtr));
        return ctor;
    }

    private static string ReadString(CustomAttribute attribute, string name) =>
        attribute.Properties.FirstOrDefault(item => item.Name == name).Argument.Value as string ?? string.Empty;
    private static int ReadInt(CustomAttribute attribute, string name, int fallback) =>
        attribute.Properties.FirstOrDefault(item => item.Name == name) is { Name: not null } item ? Convert.ToInt32(item.Argument.Value) : fallback;
    private static bool ReadBool(CustomAttribute attribute, string name, bool fallback) =>
        attribute.Properties.FirstOrDefault(item => item.Name == name) is { Name: not null } item ? Convert.ToBoolean(item.Argument.Value) : fallback;
}
}