SubModule.cs

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using TaleWorlds.CampaignSystem;
using TaleWorlds.Core;
using TaleWorlds.InputSystem;
using TaleWorlds.Localization;
using TaleWorlds.Library;
using TaleWorlds.MountAndBlade;
using UniversalPatch.Services;
using UniversalPatch.Helpers;
using UniversalPatch.Pipeline;
using UniversalPatch.Settings;

namespace UniversalPatch
{
    public class SubModule : MBSubModuleBase
    {
        private static string ModVersion
        {
            get
            {
                var informationalVersion = Assembly.GetExecutingAssembly()
                    .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion;
                if (string.IsNullOrEmpty(informationalVersion))
                {
                    return Assembly.GetExecutingAssembly().GetName().Version?.ToString(3) ?? "unknown";
                }

                var plusIndex = informationalVersion!.IndexOf('+');
                return plusIndex >= 0 ? informationalVersion.Substring(0, plusIndex) : informationalVersion;
            }
        }

        private ConfigurationService? _configService;
        private PatchPipeline? _pipeline;
        private PatchExecutionService? _executionService;
        private ItemFlagsPatch? _flagsPatch;
        private StealthCalculationPatch? _stealthPatch;

        protected override void OnSubModuleLoad()
        {
            base.OnSubModuleLoad();

            try
            {
                // 1. Settings file location + path init
                ModSettingsPathService.RestoreSettingsFileToMcmFolder();
                ModSettingsPathService.EnsureRuntimeDataDirectoryInitialized();
                _ = UniversalPatchSettings.Instance;

                // 2. Display loaded message
                var loadedMessage = new TextObject("{=UP_Msg_Loaded}[Universal Patch] v{VERSION} loaded!");
                loadedMessage.SetTextVariable("VERSION", ModVersion);
                LoggingService.DisplayMessage(new InformationMessage(loadedMessage.ToString(), AlkeariPalette.Success));

                // 3. Config service
                _configService = new ConfigurationService();
                _configService.LoadConfiguration();
                UniversalPatchSettings.ReapplyPatchesRequested += OnReapplyPatchesRequested;

                // 4. Baselines
                var xmlBaseline = new ItemXmlBaselineService();
                var armorBaseline = new ArmorRuntimeBaselineService();
                var priceBaseline = new PriceRuntimeBaselineService();

                // 5. Create patches
                _flagsPatch = new ItemFlagsPatch(xmlBaseline);
                _stealthPatch = new StealthCalculationPatch(xmlBaseline);

                var patches = new IItemPatch[]
                {
                    new DuplicateDetectionPatch(xmlBaseline),
                    new ItemNamingPatch(_configService),
                    _flagsPatch,
                    _stealthPatch,
                    new ArmorStandardizationPatch(xmlBaseline, armorBaseline),
                    new PriceNormalizationPatch(xmlBaseline, priceBaseline),
                    new WeaponStandardizationPatch(xmlBaseline),
                    new MountStandardizationPatch(xmlBaseline),
                    new TierCorrectionPatch(xmlBaseline),
                    new WeightNormalizationPatch(xmlBaseline),
                    new CultureAssignmentPatch(xmlBaseline),
                };

                // 6. Pipeline + execution service
                _pipeline = new PatchPipeline(_configService, patches);
                _executionService = new PatchExecutionService(_pipeline);

                // 7. Detect mods
                var loadedModNames = ModDetectionHelper.GetLoadedModNames();
                if (loadedModNames.Count > 0)
                {
                    var modsMessage = new TextObject("{=UP_Msg_ModsDetected}[Universal Patch] Detected mods: {MODS}");
                    modsMessage.SetTextVariable("MODS", string.Join(", ", loadedModNames));
                    LoggingService.DisplayMessage(new InformationMessage(modsMessage.ToString(), AlkeariPalette.Secondary));
                }

                var isRbmLoaded = ModDetectionHelper.IsRbmLoaded();
                if (isRbmLoaded)
                {
                    LoggingService.DisplayLocalizedMessage("{=UP_Msg_RbmDetected}[Universal Patch] RBM detected", AlkeariPalette.Secondary);
                }

                // 8. Check conflicts
                if (ModDetectionHelper.HasKnownConflictingMods())
                {
                    LoggingService.DisplayLocalizedMessage("{=UP_Msg_ConflictWarning}[Universal Patch] Warning: Conflicting armor mods detected - adjust settings accordingly", AlkeariPalette.Attention);
                }
            }
            catch (Exception ex)
            {
                var errorMessage = new TextObject("{=UP_Msg_InitError}[Universal Patch] Error during initialization: {ERROR}");
                errorMessage.SetTextVariable("ERROR", ex.Message);
                LoggingService.DisplayMessage(new InformationMessage(errorMessage.ToString(), AlkeariPalette.Attention));
            }
        }

        protected override void OnSubModuleUnloaded()
        {
            base.OnSubModuleUnloaded();

            try
            {
                UnsubscribeFromCampaignEvents();
                UniversalPatchSettings.ReapplyPatchesRequested -= OnReapplyPatchesRequested;
                _configService?.SaveConfiguration();
                LoggingService.DisplayLocalizedMessage("{=UP_Msg_ConfigSaved}[Universal Patch] Configuration saved", AlkeariPalette.Success);
            }
            catch (Exception ex)
            {
                var errorMessage = new TextObject("{=UP_Msg_ConfigSaveError}[Universal Patch] Error saving configuration: {ERROR}");
                errorMessage.SetTextVariable("ERROR", ex.Message);
                LoggingService.DisplayMessage(new InformationMessage(errorMessage.ToString(), AlkeariPalette.Attention));
            }
        }

        protected override void OnGameStart(Game game, IGameStarter gameStarterObject)
        {
            base.OnGameStart(game, gameStarterObject);

            try
            {
                if (game.GameType is Campaign)
                {
                    SubscribeToCampaignEvents();

                    // Treat each campaign load/start as a fresh session; patch once when the session launches.
                    if (_executionService != null)
                    {
                        _executionService.NeedsRepatch = true;
                    }

                    var settings = UniversalPatchSettings.Instance;
                    if (settings != null && _executionService != null)
                    {
                        _executionService.UpdateSettingsHash();
                    }
                }
            }
            catch (Exception ex)
            {
                var errorMessage = new TextObject("{=UP_Msg_PatchError}[Universal Patch] Error during patching: {ERROR}");
                errorMessage.SetTextVariable("ERROR", ex.Message);
                LoggingService.DisplayMessage(new InformationMessage(errorMessage.ToString(), AlkeariPalette.Attention));
            }
        }

        private void SubscribeToCampaignEvents()
        {
            try
            {
                CampaignEvents.OnSessionLaunchedEvent.AddNonSerializedListener(this, OnSessionLaunched);
                // Both events change their argument lists across game versions, and crafting orders do
                // not exist in the oldest ones, so each is bound by name to whatever shape this game has.
                SubscribeToItemEvent("OnNewItemCraftedEvent");
                SubscribeToItemEvent("OnCraftingOrderCompletedEvent");
            }
            catch (Exception ex)
            {
                var errorMessage = new TextObject("{=UP_Msg_EventError}[Universal Patch] Error subscribing to campaign events: {ERROR}");
                errorMessage.SetTextVariable("ERROR", ex.Message);
                LoggingService.DisplayMessage(new InformationMessage(errorMessage.ToString(), AlkeariPalette.Attention));
            }
        }

        private void UnsubscribeFromCampaignEvents()
        {
            try
            {
                CampaignEvents.OnSessionLaunchedEvent.ClearListeners(this);
                ClearItemEventListeners("OnNewItemCraftedEvent");
                ClearItemEventListeners("OnCraftingOrderCompletedEvent");
            }
            catch
            {
                // Ignore unsubscribe errors during shutdown
            }
        }

        private static object? GetCampaignEvent(string eventName)
        {
            return typeof(CampaignEvents).GetProperty(eventName, BindingFlags.Public | BindingFlags.Static)?.GetValue(null);
        }

        private void SubscribeToItemEvent(string eventName)
        {
            var campaignEvent = GetCampaignEvent(eventName);
            var addListener = campaignEvent?.GetType().GetMethod("AddNonSerializedListener");
            if (campaignEvent == null || addListener == null)
            {
                return;
            }

            var actionType = addListener.GetParameters()[1].ParameterType;
            var parameters = actionType.GetGenericArguments().Select(t => Expression.Parameter(t)).ToArray();
            var itemParameter = parameters.FirstOrDefault(p => p.Type == typeof(ItemObject));
            if (itemParameter == null)
            {
                LoggingService.LogWarning($"{eventName} carries no item on this game version; crafted items from it are not patched");
                return;
            }

            var handler = typeof(SubModule).GetMethod(nameof(OnItemCreated), BindingFlags.NonPublic | BindingFlags.Instance)!;
            var listener = Expression.Lambda(actionType, Expression.Call(Expression.Constant(this), handler, itemParameter), parameters).Compile();
            addListener.Invoke(campaignEvent, new object[] { this, listener });
        }

        private void ClearItemEventListeners(string eventName)
        {
            var campaignEvent = GetCampaignEvent(eventName);
            campaignEvent?.GetType().GetMethod("ClearListeners")?.Invoke(campaignEvent, new object[] { this });
        }

        private void OnItemCreated(ItemObject item)
        {
            try
            {
                _flagsPatch?.ApplyFlagModifications(item);
                _stealthPatch?.ApplyStealthValue(item);
            }
            catch (Exception ex)
            {
                LoggingService.LogException("OnItemCreated", ex);
            }
        }

        private void OnSessionLaunched(CampaignGameStarter starter)
        {
            ApplyPatchesIfPossible("session launched");
        }

        protected override void OnApplicationTick(float dt)
        {
            base.OnApplicationTick(dt);

            try
            {
                if (_executionService?.IsPatching == true)
                {
                    return;
                }

                if (_pipeline == null)
                {
                    return;
                }

                var settings = UniversalPatchSettings.Instance;
                if (settings == null)
                {
                    return;
                }

                if (Game.Current?.GameType is not Campaign)
                {
                    return;
                }

                if (IsHotkeyPressed(settings))
                {
                    ApplyPatchesIfPossible("hotkey");
                    return;
                }

                _executionService?.CheckSettingsChanges(dt);
            }
            catch (Exception ex)
            {
                LoggingService.LogException("OnApplicationTick", ex);
            }
        }

        private void OnReapplyPatchesRequested()
        {
            if (_configService == null)
            {
                return;
            }

            try
            {
                _configService.LoadConfiguration();

                if (_executionService == null)
                {
                    throw new InvalidOperationException("Patch execution service not initialized.");
                }

                _executionService.NeedsRepatch = true;
                ApplyPatchesIfPossible("apply patch button");
            }
            catch (Exception ex)
            {
                var errorMessage = new TextObject("{=UP_Msg_ReapplyError}[Universal Patch] Error reapplying patches: {ERROR}");
                errorMessage.SetTextVariable("ERROR", ex.Message);
                LoggingService.DisplayMessage(new InformationMessage(errorMessage.ToString(), AlkeariPalette.Attention));
            }
        }

        private void ApplyPatchesIfPossible(string reason)
        {
            _executionService?.ExecutePatchingIfPossible(reason);
        }

        /// <summary>
        /// Checks whether the hotkey combination is currently pressed.
        /// Reads directly from MCM settings each frame for instant responsiveness.
        /// </summary>
        private static bool IsHotkeyPressed(UniversalPatchSettings settings)
        {
            return HotkeyHelper.IsHotkeyPressed(
                settings.GetSelectedKey(),
                settings.GetSelectedModifierIndex());
        }
    }
}