fix and test automatic selector

Author: AnakinRaW

src/ModVerify.CliApp/GameFinder/GameFinderService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO.Abstractions;
 using Microsoft.Extensions.DependencyInjection;
@@ -51,7 +52,7 @@ public GameFinderResult FindGames(GameFinderSettings settings)
 
         return FindGames(detectors, settings);
     }
-    
+
     public IGame FindGame(string gamePath, GameFinderSettings settings)
     {
         var detectors = new List<IGameDetector>
@@ -61,6 +62,25 @@ public IGame FindGame(string gamePath, GameFinderSettings settings)
         return FindGames(detectors, settings).Game;
     }
 
+    public bool TryFindGame(string gamePath, GameFinderSettings settings, [NotNullWhen(true)]out IGame? game)
+    {
+        var detectors = new List<IGameDetector>
+        {
+            new DirectoryGameDetector(_fileSystem.DirectoryInfo.New(gamePath), _serviceProvider),
+        };
+
+        try
+        {
+            game = FindGames(detectors, settings).Game;
+            return true;
+        }
+        catch (GameNotFoundException)
+        {
+            game = null;
+            return false;
+        }
+    }
+
     public GameFinderResult FindGamesFromPathOrGlobal(string path, GameFinderSettings settings)
     {
         // There are four common situations: 
@@ -88,55 +108,79 @@ public GameFinderResult FindGamesFromPathOrGlobal(string path, GameFinderSetting
 
     private GameFinderResult FindGames(IList<IGameDetector> detectors, GameFinderSettings settings)
     {
-        // FoC needs to be tried first
-        if (!TryDetectGame(GameType.Foc, detectors, out var result))
+        GameDetectionResult? detectionResult = null;
+        if (settings.Engine is GameEngineType.Eaw)
+        {
+            _logger?.LogTrace("Trying to find requested EaW installation.");
+            if (!TryDetectGame(GameType.Eaw, detectors, out detectionResult))
+            {
+                var e = new GameNotFoundException($"Unable to find requested game installation '{settings.Engine}'. Wrong install path?");
+                _logger?.LogTrace(e, e.Message);
+                throw e;
+            }
+        }
+        
+        if (detectionResult is null && !TryDetectGame(GameType.Foc, detectors, out detectionResult))
         {
+            if (settings.Engine is GameEngineType.Foc)
+            {
+                var e = new GameNotFoundException($"Unable to find requested game installation '{settings.Engine}'. Wrong install path?");
+                _logger?.LogTrace(e, e.Message);
+                throw e;
+            }
+            
+            // If the engine is unspecified, we also need to check for EaW.
             _logger?.LogTrace("Unable to find FoC installation. Trying again with EaW...");
-            if (!TryDetectGame(GameType.Eaw, detectors, out result))
+            if (!TryDetectGame(GameType.Eaw, detectors, out detectionResult))
                 throw new GameNotFoundException("Unable to find game installation: Wrong install path?");
         }
 
-        if (result.GameLocation is null)
+        if (detectionResult.GameLocation is null)
             throw new GameNotFoundException("Unable to find game installation: Wrong install path?");
 
         _logger?.LogInformation(ModVerifyConstants.ConsoleEventId, 
-            "Found game installation: {ResultGameIdentity} at {GameLocationFullName}", result.GameIdentity, result.GameLocation.FullName);
+            "Found game installation: {ResultGameIdentity} at {GameLocationFullName}", detectionResult.GameIdentity, detectionResult.GameLocation.FullName);
 
-        var game = _gameFactory.CreateGame(result, CultureInfo.InvariantCulture);
+        var game = _gameFactory.CreateGame(detectionResult, CultureInfo.InvariantCulture);
 
         if (settings.InitMods) 
             SetupMods(game);
 
 
         IGame? fallbackGame = null;
-        if (settings.SearchFallbackGame)
+        if (SearchForFallbackGame(settings, detectionResult))
         {
-            // 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>();
+            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 (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);
 
-                if (settings.InitMods)
-                    SetupMods(fallbackGame);
-            }
+            if (settings.InitMods)
+                SetupMods(fallbackGame);
         }
 
         return new GameFinderResult(game, fallbackGame);
     }
 
+    private static bool SearchForFallbackGame(GameFinderSettings settings, GameDetectionResult? foundGame)
+    {
+        if (settings.Engine is GameEngineType.Eaw)
+            return false;
+        if (foundGame is { Installed: true, GameIdentity.Type: GameType.Eaw })
+            return false;
+        return settings.SearchFallbackGame;
+    }
+
     private bool TryDetectGame(GameType gameType, IList<IGameDetector> detectors, out GameDetectionResult result)
     {
         var gd = new CompositeGameDetector(detectors, _serviceProvider);

src/ModVerify.CliApp/ModVerifyApplication.cs

@@ -76,6 +76,19 @@ private async Task<int> RunVerify()
                 .CreateSelector(targetSettings)
                 .Select(targetSettings);
         }
+        catch (ArgumentException ex)
+        {
+            ConsoleUtilities.WriteApplicationFatalError(_appEnvironment.ApplicationName, 
+                $"The specified arguments are not correct: {ex.Message}");
+            _logger?.LogError(ex, "Invalid application arguments: {Message}", ex.Message);
+            return ex.HResult;
+        }
+        catch (TargetNotFoundException ex)
+        {
+            ConsoleUtilities.WriteApplicationFatalError(_appEnvironment.ApplicationName, ex.Message);
+            _logger?.LogError(ex, ex.Message);
+            return ex.HResult;
+        }
         catch (GameNotFoundException ex)
         {
             ConsoleUtilities.WriteApplicationFatalError(_appEnvironment.ApplicationName, 

src/ModVerify.CliApp/Settings/VerificationTargetSettings.cs

@@ -9,7 +9,7 @@ internal sealed record VerificationTargetSettings
     public bool Interactive => string.IsNullOrEmpty(TargetPath) && ModPaths.Count == 0 && string.IsNullOrEmpty(GamePath) && string.IsNullOrEmpty(FallbackGamePath);
 
     [MemberNotNullWhen(true, nameof(TargetPath))]
-    public bool UseAutoDetection => !string.IsNullOrEmpty(TargetPath);
+    public bool UseAutoDetection => !string.IsNullOrEmpty(TargetPath) && ModPaths.Count == 0 && string.IsNullOrEmpty(GamePath) && string.IsNullOrEmpty(FallbackGamePath);
 
     [MemberNotNullWhen(true, nameof(GamePath))]
     public bool ManualSetup => !string.IsNullOrEmpty(GamePath);