Added client side of save game import

Author: Krapht

InsightLogParser.Client/Cetus/CetusClient.cs

@@ -198,4 +198,31 @@ public void Dispose()
             return default;
         }
     }
+
+    public async Task<ImportSaveResponse?> ImportSaveGameAsync(Stream saveGameStream)
+    {
+        //There is no retry with this one, so get a fresh token
+        var authResult = await RefreshAuthAsync().ConfigureAwait(ConfigureAwaitOptions.None);
+        if (!authResult) return default;
+
+        var requestUri = "api/v1/sync/syncWithSave";
+
+        try
+        {
+            var content = new StreamContent(saveGameStream);
+            var result = await _httpClient.PostAsync(requestUri, content)
+                .ConfigureAwait(ConfigureAwaitOptions.None);
+            _messageWriter.WriteDebug($"CETUS: Got a {(int)result.StatusCode}-{result.StatusCode}");
+            if (!result.IsSuccessStatusCode)
+            {
+                return default;
+            }
+            return await result.Content.ReadFromJsonAsync<ImportSaveResponse>().ConfigureAwait(ConfigureAwaitOptions.None);
+        }
+        catch (Exception e)
+        {
+            _messageWriter.WriteDebug($"CETUS: Exception: {e}");
+            return default;
+        }
+    }
 }

InsightLogParser.Client/Cetus/DummyCetusClient.cs

@@ -18,6 +18,11 @@ internal class DummyCetusClient : ICetusClient
             return Task.FromResult<ScreenshotResponse?>(null);
         }
 
+        public Task<ImportSaveResponse?> ImportSaveGameAsync(Stream saveGameStream)
+        {
+            return Task.FromResult<ImportSaveResponse?>(null);
+        }
+
         public Task<PuzzleStatusResponse?> GetPuzzleStatusAsync(PuzzleStatusRequest request)
         {
             return Task.FromResult<PuzzleStatusResponse?>(null);

InsightLogParser.Client/Cetus/ICetusClient.cs

@@ -19,6 +19,7 @@ internal interface ICetusClient : IDisposable
     Task<SeenResponse?> PostSeenAsync(PlayerReport request);
     Task<SolvedResponse?> PostSolvedAsync(PlayerReport request);
     Task<ScreenshotResponse?> PostScreenshotAsync(Screenshot screenshot);
+    Task<ImportSaveResponse?> ImportSaveGameAsync(Stream saveGameStream);
 
     //"Search" operations
     Task<PuzzleStatusResponse?> GetPuzzleStatusAsync(PuzzleStatusRequest request);

InsightLogParser.Client/Configuration.cs

@@ -3,14 +3,16 @@ namespace InsightLogParser.Client;
 
 public class Configuration
 {
-    public static readonly int CurrentConfigurationVersion = 2;
+    public static readonly int CurrentConfigurationVersion = 3;
 
     public int ConfigVersion { get; set; } = CurrentConfigurationVersion;
 
     public string? ForceLogFolder { get; set; }
     public string? ForceGameRootFolder { get; set; }
     public string? ForcedParsedDatabasePath { get; set; }
     public string? ForceScreenshotFolder { get; set; }
+    public string? ForcedOfflineSaveFile { get; set; }
+
     public bool MonitorScreenshots { get; set; } = true;
     public bool ConfirmScreenshotDelete { get; set; } = true;
     public bool DeleteOnQuickUpload { get; set; } = false;

InsightLogParser.Client/Menu/AdvancedMenu.cs

@@ -6,11 +6,13 @@ internal class AdvancedMenu : IMenu
 {
     private readonly UserComputer _computer;
     private readonly MessageWriter _writer;
+    private readonly Spider _spider;
 
-    public AdvancedMenu(UserComputer computer, MessageWriter writer)
+    public AdvancedMenu(UserComputer computer, MessageWriter writer, Spider spider)
     {
         _computer = computer;
         _writer = writer;
+        _spider = spider;
     }
 
     public IEnumerable<(char? key, string text)> MenuOptions
@@ -19,6 +21,10 @@ public AdvancedMenu(UserComputer computer, MessageWriter writer)
         {
             yield return (null, "Advanced or risky operations. Press [h] to display this menu again and backspace to back");
             yield return ('c', "Cleanup steam screenshot.vdf file (at your own risk)");
+            if (_spider.IsOnline())
+            {
+                yield return ('u', "upload your offline progress to import solved puzzles");
+            }
         }
     }
 
@@ -29,6 +35,9 @@ public async Task<MenuResult> HandleOptionAsync(char keyChar)
             case 'c':
                 ConfirmSteamScreenshotCleanup();
                 return MenuResult.PrintMenu;
+            case 'u':
+                await ConfirmOfflineSaveUpload();
+                return MenuResult.PrintMenu;
             default:
                 return MenuResult.NotValidOption;
         }
@@ -51,4 +60,22 @@ private void ConfirmSteamScreenshotCleanup()
 
         _computer.CleanupSteamScreenshotFile();
     }
+
+    private async Task ConfirmOfflineSaveUpload()
+    {
+        _writer.ConfirmOfflineSaveUpload();
+        for (var i = 0; i < 3; i++)
+        {
+            var pressedKey = Console.ReadKey(false);
+            if (pressedKey.Key != ConsoleKey.Y)
+            {
+                _writer.WriteLine("");
+                _writer.WriteInfo("Cancelled");
+                return;
+            }
+            _writer.WriteLine("");
+        }
+
+        await _spider.ImportSaveGameAsync();
+    }
 }

InsightLogParser.Client/Menu/RootMenu.cs

@@ -55,7 +55,7 @@ public async Task<MenuResult> HandleOptionAsync(char keyChar)
                 _menuHandler.EnterMenu(new RouteMenu(_menuHandler, _spider));
                 return MenuResult.Ok;
             case 'a':
-                _menuHandler.EnterMenu(new AdvancedMenu(_computer, _writer));
+                _menuHandler.EnterMenu(new AdvancedMenu(_computer, _writer, _spider));
                 return MenuResult.Ok;
             case 'C':
                 _menuHandler.EnterMenu(new CheeseMenu(_spider, _writer));

InsightLogParser.Client/MessageWriter.cs

@@ -69,17 +69,19 @@ public void WriteLogLine(string logLine)
         }
     }
 
-    public void WriteInfo(string infoLine)
+    public void WriteInfo(string infoLine, ConsoleColor color)
     {
         lock (_lock)
         {
-            Console.ForegroundColor = ConsoleColor.DarkGreen;
+            Console.ForegroundColor = color;
             Console.Write("[INFO]");
             Console.ResetColor();
             Console.WriteLine($": {infoLine}");
         }
     }
 
+    public void WriteInfo(string infoLine) => WriteInfo(infoLine, ConsoleColor.DarkGreen);
+
     public void WriteDebug(string debugMessage)
     {
         if (!ShouldShowDebug()) return;
@@ -471,6 +473,22 @@ public void ConfirmScreenshotCleanup()
         }
     }
 
+    public void ConfirmOfflineSaveUpload()
+    {
+        lock (_lock)
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("This will upload your offline save to extract solved puzzles from it");
+            Console.WriteLine("The server will add solves for all relevant solved puzzles from your offline save");
+            Console.WriteLine("Additionally it will REMOVE any solved puzzles not marked as solved in your offline save that are dated EARLIER than the MOST RECENT solved puzzle in your offline save");
+            Console.WriteLine("This will clean up any stale solves you might have that are not actually counted by the game");
+            Console.WriteLine("Please be aware that just because it works for me does not mean it will work for you");
+            Console.WriteLine("*** Before using this, make sure that your offline save file is fully up to date with your online save ***");
+            Console.WriteLine("At your own risk, press [y] three times to proceed or any other key to cancel");
+            Console.ResetColor();
+        }
+    }
+
     public void WriteClosest(IEnumerable<DistanceModel> distanceModels, bool containsCetusInfo)
     {
         lock (_lock)

InsightLogParser.Client/ParsedDatabase.cs

@@ -1,6 +1,7 @@
 using System.Globalization;
 using System.Text;
 using System.Text.Json;
+using InsightLogParser.Common.ApiModels;
 using InsightLogParser.Common.ParsedDbModels;
 using InsightLogParser.Common.PuzzleParser;
 using InsightLogParser.Common.World;
@@ -317,7 +318,74 @@ public void RemoveNonWorldPuzzles(GamePuzzleHandler puzzleHandler)
             }
         }
 
-        private void MakeBackup()
+        public void ImportSaves(ImportSolve[] importedSolves, HashSet<int> allSolvedIds, DateTimeOffset mostRecentSolveTime)
+        {
+            lock (_lock)
+            {
+                foreach (var puzzleZone in _db.Zones.Keys)
+                {
+                    var zoneNode = _db.Zones[puzzleZone];
+                    foreach (var type in zoneNode.SolvedEntries.Keys)
+                    {
+                        var localSolves = zoneNode.SolvedEntries[type];
+
+                        //Add new solves
+                        var imported = importedSolves
+                            .Where(x => x.PuzzleZone == puzzleZone && x.PuzzleType == type)
+                            .ToList();
+                        var importedCounter = 0;
+                        foreach (var importSolve in imported)
+                        {
+                            if (!localSolves.ContainsKey(importSolve.PuzzleId))
+                            {
+                                localSolves.Add(importSolve.PuzzleId, new PuzzleNode
+                                {
+                                    Solves = [importSolve.SolvedAt]
+                                });
+                                _dirty = true;
+                                importedCounter++;
+                            }
+                        }
+
+                        //Remove stale solves
+                        var stales = new List<(int puzzleId, PuzzleNode node)>();
+                        foreach (var (puzzleId, node) in localSolves)
+                        {
+                            //If it is solved, it is not stale
+                            if (allSolvedIds.Contains(puzzleId)) continue;
+
+                            //If we have a solve after the most recent time, we can't say if it's stale or not
+                            if (node.Solves.Any(x => x >= mostRecentSolveTime)) continue;
+
+                            stales.Add((puzzleId, node));
+                        }
+
+                        foreach (var valueTuple in stales)
+                        {
+                            localSolves.Remove(valueTuple.puzzleId);
+                            _dirty = true;
+                        }
+                        var puzzleName = WorldInformation.GetPuzzleName(type);
+                        var zoneName = WorldInformation.GetZoneName(puzzleZone);
+
+                        if (importedCounter > 0) _messageWriter.WriteInfo($"Imported {importedCounter} solves of {puzzleName} from {zoneName} to local db", ConsoleColor.Green);
+                        if (stales.Count > 0) _messageWriter.WriteInfo($"Removed {stales.Count} stale local solves of {puzzleName} from {zoneName}", ConsoleColor.Yellow);
+                    }
+                }
+
+                if (_dirty)
+                {
+                    var backupPath = MakeBackup();
+                    _messageWriter.WriteInfo($"Changes will be made to the local db, a backup has been saved at {backupPath}", ConsoleColor.Yellow);
+                }
+                else
+                {
+                    _messageWriter.WriteInfo("Local db was already up to date");
+                }
+            }
+        }
+
+        private string MakeBackup()
         {
             var pathPart = Path.GetDirectoryName(_jsonPath);
             if (string.IsNullOrWhiteSpace(pathPart)) pathPart = ".";
@@ -326,6 +394,7 @@ private void MakeBackup()
             var timestring = DateTime.Now.ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture);
             var backupName = $"{filePart}-backup-{timestring}{extensionPart}";
             File.Copy(_jsonPath, backupName);
+            return backupName;
         }
 
         public bool IsSolved(int puzzleKrakenId)

InsightLogParser.Client/Spider.cs

@@ -485,6 +485,43 @@ public void TargetOtherMatchbox()
             _teleportManager.SetTarget(furthest);
         }
 
+        public async Task ImportSaveGameAsync()
+        {
+            var saveFilePath = _computer.GetOfflineSaveFile();
+            if (!File.Exists(saveFilePath))
+            {
+                _messageWriter.WriteError($"Could not find file '{saveFilePath}'");
+                return;
+            }
+
+            ImportSaveResponse? response;
+            await using (var fs = File.OpenRead(saveFilePath))
+            {
+                response = await _cetusClient.ImportSaveGameAsync(fs);
+            }
+
+            if (response == null)
+            {
+                _messageWriter.WriteError("Something went wrong");
+                return;
+            }
+
+            var allSolvedIds = response
+                .AllSolves
+                .OrderBy(x => x)
+                .Select(x => x.ToString());
+
+            const string solvedPuzzleIdFile = "solvedpuzzleids.txt";
+            _messageWriter.WriteInfo($"Saving {response.AllSolves.Length} solved puzzle ids to " + solvedPuzzleIdFile);
+            await File.WriteAllTextAsync(solvedPuzzleIdFile, string.Join(",", allSolvedIds));
+
+            _messageWriter.WriteInfo($"Server flagged {response.ImportedSolves.Length} previously unsolved puzzles as solved");
+            _messageWriter.WriteInfo($"Server flagged {response.RemovedStales.Length} previously solved puzzles as unsolved as they were stale");
+
+            //Update local db
+            _db.ImportSaves(response.ImportedSolves, response.AllSolves.ToHashSet(), response.MostRecentSolve);
+        }
+
         public async Task ListClosestAsync(int numberToList, bool use2dDistance)
         {
             var lastTeleport = _teleportManager.GetLastTeleport();

InsightLogParser.Client/UserComputer.cs

@@ -69,6 +69,19 @@ public string GetPrimaryLogFile()
         return logFile;
     }
 
+    public string GetOfflineSaveFile()
+    {
+        if (!string.IsNullOrWhiteSpace(_configuration.ForcedOfflineSaveFile))
+        {
+            return _configuration.ForcedOfflineSaveFile;
+        }
+        else
+        {
+            var appDataFolder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            return Path.Combine(appDataFolder, "IslandsofInsight", "Saved", "SaveGames", "OfflineSavegame.sav");
+        }
+    }
+
     private string[]? FindSteamGameLibraryLocations()
     {
         //Find the steam install directory in the registry