start refactoring verification target selection

Author: AnakinRaW

modules/ModdingToolBase

@@ -4,6 +4,7 @@
 using System.IO.Abstractions;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using PG.StarWarsGame.Engine;
 using PG.StarWarsGame.Infrastructure.Clients.Steam;
 using PG.StarWarsGame.Infrastructure.Games;
 using PG.StarWarsGame.Infrastructure.Mods;
@@ -12,6 +13,17 @@
 
 namespace AET.ModVerify.App.GameFinder;
 
+internal class GameFinderSettings
+{
+    internal static readonly GameFinderSettings Default = new();
+    
+    public bool InitMods { get; init; } = true;
+    
+    public bool SearchFallbackGame { get; init; } = true;
+
+    public GameEngineType? Engine { get; init; } = null;
+}
+
 internal class GameFinderService
 {
     private readonly IServiceProvider _serviceProvider;
@@ -29,18 +41,27 @@ public GameFinderService(IServiceProvider serviceProvider)
         _logger = _serviceProvider.GetService<ILoggerFactory>()?.CreateLogger(GetType());
     }
 
-    public GameFinderResult FindGames()
+    public GameFinderResult FindGames(GameFinderSettings settings)
     {
         var detectors = new List<IGameDetector>
         {
             new DirectoryGameDetector(_fileSystem.DirectoryInfo.New(Environment.CurrentDirectory), _serviceProvider),
             new SteamPetroglyphStarWarsGameDetector(_serviceProvider),
         };
 
-        return FindGames(detectors);
+        return FindGames(detectors, settings);
+    }
+    
+    public IGame FindGame(string gamePath, GameFinderSettings settings)
+    {
+        var detectors = new List<IGameDetector>
+        {
+            new DirectoryGameDetector(_fileSystem.DirectoryInfo.New(gamePath), _serviceProvider),
+        };
+        return FindGames(detectors, settings).Game;
     }
 
-    public GameFinderResult FindGamesFromPathOrGlobal(string path)
+    public GameFinderResult FindGamesFromPathOrGlobal(string path, GameFinderSettings settings)
     {
         // There are four common situations: 
         // 1. path points to the actual game directory
@@ -62,29 +83,10 @@ public GameFinderResult FindGamesFromPathOrGlobal(string path)
 
         // Cases 3 & 4
         detectors.Add(new SteamPetroglyphStarWarsGameDetector(_serviceProvider));
-        return FindGames(detectors);
-    }
-
-    private bool TryDetectGame(GameType gameType, IList<IGameDetector> detectors, out GameDetectionResult result)
-    {
-        var gd = new CompositeGameDetector(detectors, _serviceProvider);
-
-        try
-        {
-            result = gd.Detect(gameType);
-            if (result.GameLocation is null)
-                return false;
-            return true;
-        }
-        catch (Exception e)
-        {
-            result = GameDetectionResult.NotInstalled(gameType);
-            _logger?.LogTrace("Unable to find game installation: {Message}", e.Message);
-            return false;
-        }
+        return FindGames(detectors, settings);
     }
-
-    private GameFinderResult FindGames(IList<IGameDetector> detectors)
+    
+    private GameFinderResult FindGames(IList<IGameDetector> detectors, GameFinderSettings settings)
     {
         // FoC needs to be tried first
         if (!TryDetectGame(GameType.Foc, detectors, out var result))
@@ -102,34 +104,58 @@ private GameFinderResult FindGames(IList<IGameDetector> detectors)
 
         var game = _gameFactory.CreateGame(result, CultureInfo.InvariantCulture);
 
-        SetupMods(game);
+        if (settings.InitMods) 
+            SetupMods(game);
 
 
         IGame? fallbackGame = null;
-        // If the game is Foc we want to set up Eaw as well as the fallbackGame
-        if (game.Type == GameType.Foc)
+        if (settings.SearchFallbackGame)
         {
-            var fallbackDetectors = new List<IGameDetector>();
-            
-            if (game.Platform == GamePlatform.SteamGold)
-                fallbackDetectors.Add(new SteamPetroglyphStarWarsGameDetector(_serviceProvider));
-            else
-                throw new NotImplementedException("Searching fallback game for non-Steam games is currently is not yet implemented.");
+            // If the game is Foc we want to set up Eaw as well as the fallbackGame
+            if (game.Type == GameType.Foc)
+            {
+                var fallbackDetectors = new List<IGameDetector>();
+
+                if (game.Platform == GamePlatform.SteamGold)
+                    fallbackDetectors.Add(new SteamPetroglyphStarWarsGameDetector(_serviceProvider));
+                else
+                    throw new NotImplementedException("Searching fallback game for non-Steam games is currently is not yet implemented.");
 
-            if (!TryDetectGame(GameType.Eaw, fallbackDetectors, out var fallbackResult) || fallbackResult.GameLocation is null)
-                throw new GameNotFoundException("Unable to find fallback game installation: Wrong install path?");
+                if (!TryDetectGame(GameType.Eaw, fallbackDetectors, out var fallbackResult) || fallbackResult.GameLocation is null)
+                    throw new GameNotFoundException("Unable to find fallback game installation: Wrong install path?");
 
-            _logger?.LogInformation(ModVerifyConstants.ConsoleEventId, 
-                "Found fallback game installation: {FallbackResultGameIdentity} at {GameLocationFullName}", fallbackResult.GameIdentity, fallbackResult.GameLocation.FullName);
+                _logger?.LogInformation(ModVerifyConstants.ConsoleEventId,
+                    "Found fallback game installation: {FallbackResultGameIdentity} at {GameLocationFullName}", fallbackResult.GameIdentity, fallbackResult.GameLocation.FullName);
 
-            fallbackGame = _gameFactory.CreateGame(fallbackResult, CultureInfo.InvariantCulture);
+                fallbackGame = _gameFactory.CreateGame(fallbackResult, CultureInfo.InvariantCulture);
 
-            SetupMods(fallbackGame);
+                if (settings.InitMods)
+                    SetupMods(fallbackGame);
+            }
         }
 
         return new GameFinderResult(game, fallbackGame);
     }
 
+    private bool TryDetectGame(GameType gameType, IList<IGameDetector> detectors, out GameDetectionResult result)
+    {
+        var gd = new CompositeGameDetector(detectors, _serviceProvider);
+
+        try
+        {
+            result = gd.Detect(gameType);
+            if (result.GameLocation is null)
+                return false;
+            return true;
+        }
+        catch (Exception e)
+        {
+            result = GameDetectionResult.NotInstalled(gameType);
+            _logger?.LogTrace("Unable to find game installation: {Message}", e.Message);
+            return false;
+        }
+    }
+
     private void SetupMods(IGame game)
     {
         var modFinder = _serviceProvider.GetRequiredService<IModFinder>();

src/ModVerify.CliApp/GameFinder/GameFinderService.cs

@@ -16,92 +16,102 @@
 
 namespace AET.ModVerify.App.ModSelectors;
 
-internal class AutomaticModSelector(IServiceProvider serviceProvider) : ModSelectorBase(serviceProvider)
+internal class AutomaticSelector(IServiceProvider serviceProvider) : VerificationTargetSelectorBase(serviceProvider)
 {
     private readonly IFileSystem _fileSystem = serviceProvider.GetRequiredService<IFileSystem>();
 
-    public override GameLocations? Select(
-        GameInstallationsSettings settings, 
-        out IPhysicalPlayableObject? targetObject, 
-        out GameEngineType? actualEngineType)
+    public override VerificationTarget Select(GameInstallationsSettings settings)
     {
-        var pathToVerify = settings.AutoPath;
-        if (pathToVerify is null)
+        var targetPath = settings.AutoPath;
+        if (targetPath is null)
             throw new InvalidOperationException("path to verify cannot be null.");
 
-        actualEngineType = settings.EngineType;
+        var engine = settings.Engine;
 
         GameFinderResult finderResult;
         try
         {
-            finderResult = GameFinderService.FindGamesFromPathOrGlobal(pathToVerify);
+            finderResult = GameFinderService.FindGamesFromPathOrGlobal(targetPath, GameFinderSettings.Default);
         }
         catch (GameNotFoundException)
         {
-            Logger?.LogError(ModVerifyConstants.ConsoleEventId, "Unable to find games based of the given location '{SettingsGamePath}'. Consider specifying all paths manually.", settings.GamePath);
-            targetObject = null;
-            return null;
+            Logger?.LogError(ModVerifyConstants.ConsoleEventId, "Unable to find games based of the specified target path '{Path}'. Consider specifying all paths manually.", settings.GamePath);
+            throw;
         }
 
 
-        var modOrGame = GetAttachedModOrGame(finderResult, actualEngineType, pathToVerify);
+        GameLocations locations;
+
+        var targetObject = GetAttachedModOrGame(finderResult, engine, targetPath);
 
-        if (modOrGame is not null)
+        
+        if (targetObject is null)
         {
-            var actualType = modOrGame.Game.Type.ToEngineType();
-            actualEngineType ??= actualType;
-            if (actualEngineType != actualType)
-                throw new ArgumentException($"The specified game type '{actualEngineType}' does not match the actual type of the game or mod to verify.");
+            if (!settings.Engine.HasValue)
+                throw new ArgumentException("Game engine not specified. Use --engine argument to set it.");
 
-            targetObject = modOrGame;
-            return GetLocations(targetObject, finderResult, settings.AdditionalFallbackPaths);
-        }
+            Logger?.LogDebug("The requested mod at '{TargetPath}' is detached from its games.", targetPath);
 
-        if (!settings.EngineType.HasValue)
-            throw new ArgumentException("Unable to determine game type. Use --type argument to set the game type.");
+            // The path is a detached mod, that exists on a different location than the game.
+            locations = GetDetachedModLocations(targetPath, finderResult, settings, out var mod);
+            targetObject = mod;
+        }
+        else
+        {
+            var actualType = targetObject.Game.Type.ToEngineType();
+            engine ??= actualType;
+            if (engine != actualType)
+                throw new ArgumentException($"The specified game type '{engine}' does not match the actual type of the game or mod to verify.");
+            locations = GetLocations(targetObject, finderResult.FallbackGame, settings.AdditionalFallbackPaths);
+        }
 
-        Logger?.LogDebug("The requested mod at '{PathToVerify}' is detached from its games.", pathToVerify);
+        return new VerificationTarget
+        {
+            Engine = engine.Value,
+            Location = locations,
+            Name = GetTargetName(targetObject, locations),
+            Version = GetTargetVersion(targetObject)
+        };
 
-        // The path is a detached mod, that exists on a different location than the game.
-        var result = GetDetachedModLocations(pathToVerify, finderResult, settings, out var mod);
-        targetObject = mod;
-        return result;
     }
 
-    private IPhysicalPlayableObject? GetAttachedModOrGame(GameFinderResult finderResult, GameEngineType? requestedEngineType, string searchPath)
+    private IPhysicalPlayableObject? GetAttachedModOrGame(GameFinderResult finderResult, GameEngineType? requestedEngineType, string targetPath)
     {
-        var fullSearchPath = _fileSystem.Path.GetFullPath(searchPath);
+        var targetFullPath = _fileSystem.Path.GetFullPath(targetPath);
 
-        if (finderResult.Game.Directory.FullName.Equals(fullSearchPath, StringComparison.OrdinalIgnoreCase))
+        // If the target is the game directory itself.
+        if (targetFullPath.Equals(finderResult.Game.Directory.FullName, StringComparison.OrdinalIgnoreCase))
         {
             if (finderResult.Game.Type.ToEngineType() != requestedEngineType)
-                throw new ArgumentException($"The specified game type '{requestedEngineType}' does not match the actual type of the game '{searchPath}' to verify.");
+                throw new ArgumentException($"The specified game type '{requestedEngineType}' does not match the actual type of the game '{targetPath}' to verify.");
             return finderResult.Game;
         }
 
         if (finderResult.FallbackGame is not null &&
-            finderResult.FallbackGame.Directory.FullName.Equals(fullSearchPath, StringComparison.OrdinalIgnoreCase))
+            targetFullPath.Equals(finderResult.FallbackGame.Directory.FullName, StringComparison.OrdinalIgnoreCase))
         {
+            throw new NotImplementedException("When does this actually happen???");
+
             if (finderResult.FallbackGame.Type.ToEngineType() != requestedEngineType)
-                throw new ArgumentException($"The specified game type '{requestedEngineType}' does not match the actual type of the game '{searchPath}' to verify.");
+                throw new ArgumentException($"The specified game type '{requestedEngineType}' does not match the actual type of the game '{targetPath}' to verify.");
             return finderResult.FallbackGame;
         }
 
-        return GetMatchingModFromGame(finderResult.Game, requestedEngineType, fullSearchPath) ??
-               GetMatchingModFromGame(finderResult.FallbackGame, requestedEngineType, fullSearchPath);
+        return GetMatchingModFromGame(finderResult.Game, requestedEngineType, targetFullPath) ??
+               GetMatchingModFromGame(finderResult.FallbackGame, requestedEngineType, targetFullPath);
     }
 
     private GameLocations GetDetachedModLocations(string modPath, GameFinderResult gameResult, GameInstallationsSettings settings, out IPhysicalMod mod)
     {
         IGame game = null!;
 
-        if (gameResult.Game.Type.ToEngineType() == settings.EngineType)
+        if (gameResult.Game.Type.ToEngineType() == settings.Engine)
             game = gameResult.Game;
-        if (gameResult.FallbackGame is not null && gameResult.FallbackGame.Type.ToEngineType() == settings.EngineType)
+        if (gameResult.FallbackGame is not null && gameResult.FallbackGame.Type.ToEngineType() == settings.Engine)
             game = gameResult.FallbackGame;
 
         if (game is null)
-            throw new GameNotFoundException($"Unable to find game of type '{settings.EngineType}'");
+            throw new GameNotFoundException($"Unable to find game of type '{settings.Engine}'");
 
         var modFinder = ServiceProvider.GetRequiredService<IModFinder>();
         var modRef = modFinder.FindMods(game, _fileSystem.DirectoryInfo.New(modPath)).FirstOrDefault();
@@ -116,7 +126,7 @@ private GameLocations GetDetachedModLocations(string modPath, GameFinderResult g
 
         mod.ResolveDependencies();
 
-        return GetLocations(mod, gameResult, settings.AdditionalFallbackPaths);
+        return GetLocations(mod, gameResult.FallbackGame, settings.AdditionalFallbackPaths);
     }
 
     private static IPhysicalMod? GetMatchingModFromGame(IGame? game, GameEngineType? requestedEngineType, string modPath)
@@ -132,7 +142,7 @@ private GameLocations GetDetachedModLocations(string modPath, GameFinderResult g
                 if (physicalMod.Directory.FullName.Equals(modPath, StringComparison.OrdinalIgnoreCase))
                 {
                     if (!isGameSupported)
-                        throw new ArgumentException($"The specified game type '{requestedEngineType}' does not match the actual type of the mod '{modPath}' to verify.");
+                        throw new ArgumentException($"The specified engine type '{requestedEngineType}' does not match the required of the mod '{modPath}' to verify.");
                     return physicalMod;
                 }
             }

…App/ModSelectors/AutomaticModSelector.cs …CliApp/ModSelectors/AutomaticSelector.cssrc/ModVerify.CliApp/ModSelectors/AutomaticModSelector.cs renamed to src/ModVerify.CliApp/ModSelectors/AutomaticSelector.cs src/ModVerify.CliApp/ModSelectors/AutomaticModSelector.cs renamed to src/ModVerify.CliApp/ModSelectors/AutomaticSelector.cs

@@ -5,24 +5,29 @@
 using AET.ModVerify.App.Settings;
 using AET.ModVerify.App.Utilities;
 using AnakinRaW.ApplicationBase;
-using PG.StarWarsGame.Engine;
 using PG.StarWarsGame.Infrastructure;
 using PG.StarWarsGame.Infrastructure.Games;
 using PG.StarWarsGame.Infrastructure.Mods;
 
 namespace AET.ModVerify.App.ModSelectors;
 
-internal class ConsoleModSelector(IServiceProvider serviceProvider) : ModSelectorBase(serviceProvider)
+internal class ConsoleSelector(IServiceProvider serviceProvider) : VerificationTargetSelectorBase(serviceProvider)
 {
-    public override GameLocations Select(
-        GameInstallationsSettings settings, 
-        out IPhysicalPlayableObject targetObject,
-        out GameEngineType? actualEngineType)
+    public override VerificationTarget Select(GameInstallationsSettings settings)
     {
-        var gameResult = GameFinderService.FindGames();
-        targetObject = SelectPlayableObject(gameResult);
-        actualEngineType = targetObject.Game.Type.ToEngineType();
-        return GetLocations(targetObject, gameResult, settings.AdditionalFallbackPaths);
+        var gameResult = GameFinderService.FindGames(GameFinderSettings.Default);
+        var targetObject = SelectPlayableObject(gameResult);
+        var engine = targetObject.Game.Type.ToEngineType();
+        
+        var gameLocations = GetLocations(targetObject, gameResult.FallbackGame, settings.AdditionalFallbackPaths);
+
+        return new VerificationTarget
+        {
+            Engine = engine,
+            Location = gameLocations,
+            Name = GetTargetName(targetObject, gameLocations),
+            Version = GetTargetVersion(targetObject)
+        };
     }
 
     private static IPhysicalPlayableObject SelectPlayableObject(GameFinderResult finderResult)

…liApp/ModSelectors/ConsoleModSelector.cs …y.CliApp/ModSelectors/ConsoleSelector.cssrc/ModVerify.CliApp/ModSelectors/ConsoleModSelector.cs renamed to src/ModVerify.CliApp/ModSelectors/ConsoleSelector.cs src/ModVerify.CliApp/ModSelectors/ConsoleModSelector.cs renamed to src/ModVerify.CliApp/ModSelectors/ConsoleSelector.cs

@@ -0,0 +1,8 @@
+using AET.ModVerify.App.Settings;
+
+namespace AET.ModVerify.App.ModSelectors;
+
+internal interface IVerificationTargetSelector
+{
+    VerificationTarget Select(GameInstallationsSettings settings);
+}