commented protobuf compilation

ParadoxSaveParser.CLI/Modes/Interactive.cs

@@ -0,0 +1,138 @@
+using Path = DTLib.Filesystem.Path;
+
+namespace ParadoxSaveParser.CLI;
+
+internal enum Mode
+{
+    Unset, Search, Interactive
+}
+
+internal static partial class Modes
+{
+    internal static void Interactive()
+    {
+        ColoredConsole.Clear();
+        ColoredConsole.WriteTitle("interactive mode", fg: ConsoleColor.Cyan);
+        ColoredConsole.WriteLine($"working directory: '{Environment.CurrentDirectory}'", ConsoleColor.Gray);
+        IOPath? inputPath = null;
+        IOPath? outputPath = null;
+        
+        while (true)
+        {
+            try
+            {
+                ColoredConsole.Write("> ", ConsoleColor.Blue);
+                string input = ColoredConsole.ReadLine(ConsoleColor.Gray);
+                if (string.IsNullOrEmpty(input))
+                    continue;
+
+                const string helpMessage =
+                    """
+                    Commands dont have arguments. Just write command name ant it will ask you for more information.
+                    Avaliable commands:
+                        h, help - show this message
+                        q, quit, exit - close the program
+                        pwd - show working directory
+                        cd - change working directory
+                        ls - show list of files in working directory
+                        i, input - set input file path
+                        o, output - set output file path
+                        s, search - perform search in input file using expression 
+                    """;
+
+                if (input.Contains(' '))
+                {
+                    ColoredConsole.WriteLine("Commands dont have arguments." 
+                                             + " Just write command name ant it will ask you for more information.", 
+                        ConsoleColor.Red);
+                    continue;
+                }
+                
+                switch (input)
+                {
+                    default:
+                        ColoredConsole.WriteLine("Unknown command, use 'help' for a list of commands.",
+                            ConsoleColor.Red);
+                        continue;
+
+                    case "q":
+                    case "quit":
+                    case "exit":
+                        return;
+
+                    case "h":
+                    case "help":
+                        ColoredConsole.WriteLine(helpMessage, ConsoleColor.White);
+                        break;
+
+                    case "i":
+                    case "input":
+                        ColoredConsole.Write("Input file path: ", ConsoleColor.Blue);
+                        input = ColoredConsole.ReadLine(ConsoleColor.Gray);
+                        if (string.IsNullOrEmpty(input))
+                            throw new ArgumentException("Input file path is required");
+                        inputPath = input;
+                        break;
+
+                    case "o":
+                    case "output":
+                        ColoredConsole.Write("Output file path [default=stdout]: ", ConsoleColor.Blue);
+                        input = ColoredConsole.ReadLine(ConsoleColor.Gray);
+                        if(string.IsNullOrEmpty(input))
+                            outputPath = null;
+                        else outputPath = input;
+                        break;
+
+                    case "s":
+                    case "search":
+                        if (inputPath is null)
+                            throw new ArgumentException("Input file path is required");
+
+                        ColoredConsole.Write("search expression: ", ConsoleColor.Blue);
+                        var searchQuery = ColoredConsole.ReadLine(ConsoleColor.Gray);
+                        if (string.IsNullOrEmpty(searchQuery))
+                            throw new ArgumentException("Search expression is required");
+
+                        ColoredConsole.WriteHLine('-', ConsoleColor.Cyan);
+                        Console.ResetColor();
+                        Search(searchQuery, inputPath.Value, outputPath);
+                        ColoredConsole.WriteHLine('-', ConsoleColor.Green);
+                        break;
+
+                    case "pwd":
+                        ColoredConsole.WriteLine(Environment.CurrentDirectory, ConsoleColor.White);
+                        break;
+
+                    case "cd":
+                        ColoredConsole.Write("Change working directory to: ", ConsoleColor.Blue);
+                        input = ColoredConsole.ReadLine(ConsoleColor.Gray);
+                        if (!string.IsNullOrEmpty(input))
+                        {
+                            Environment.CurrentDirectory = new IOPath(input).Str;
+                            ColoredConsole.WriteLine(Environment.CurrentDirectory, ConsoleColor.Green);
+                        }
+
+                        break;
+
+                    case "ls":
+                        IOPath curdir = Directory.GetCurrent();
+                        foreach (var dir in Directory.GetDirectories(curdir))
+                        {
+                            ColoredConsole.WriteLine(dir.RemoveBase(curdir).Str + Path.Sep, ConsoleColor.Cyan);
+                        }
+
+                        foreach (var file in Directory.GetFiles(curdir))
+                        {
+                            ColoredConsole.WriteLine(file.RemoveBase(curdir).Str, ConsoleColor.White);
+                        }
+
+                        break;
+                }
+            }
+            catch (Exception ex)
+            {
+                ColoredConsole.WriteLine(ex.ToStringDemystified(), ConsoleColor.Red);
+            }
+        }
+    }
+}

ParadoxSaveParser.CLI/Modes/Search.cs

@@ -0,0 +1,49 @@
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text.Json;
+using ParadoxSaveParser.Lib;
+
+namespace ParadoxSaveParser.CLI;
+
+internal static partial class Modes
+{
+    internal static void Search(string searchQuery, IOPath inputPath, IOPath? outputPath)
+    {
+        Stream inputStream = File.OpenRead(inputPath);
+        try
+        {
+            byte[] head4 = new byte[4];
+            inputStream.ReadExactly(head4);
+            inputStream.Seek(0, SeekOrigin.Begin);
+            if (head4.SequenceEqual<byte>([(byte)'P', (byte)'K', 3, 4]))
+            {
+                var zipArchive = new ZipArchive(inputStream, ZipArchiveMode.Read);
+                var zipEntry = zipArchive.Entries.FirstOrDefault(e => e.Name == "gamestate");
+                if (zipEntry is null)
+                    throw new Exception("'gamestate' file not found in zip archive");
+                var unzipped = new MemoryStream((int)zipEntry.Length);
+                zipEntry.Open().CopyTo(unzipped);
+                zipArchive.Dispose(); // closes inputStream
+                unzipped.Seek(0, SeekOrigin.Begin);
+                inputStream = unzipped;
+            }
+
+            using var outputStream = outputPath is null
+                ? Console.OpenStandardOutput()
+                : File.OpenWrite(outputPath.Value);
+
+            var searchExpression = SearchExpressionCompiler.Compile(searchQuery);
+
+            var parser = new SaveParserEU4(inputStream, searchExpression);
+            var parsedValue = parser.Parse();
+            JsonSerializer.Serialize(outputStream, parsedValue,
+                ParsedValueJsonContext.Default.DictionaryStringObject);
+            outputStream.WriteByte((byte)'\n');
+        }
+        finally
+        {
+            inputStream.Dispose();
+        }
+    }
+}

ParadoxSaveParser.CLI/ParadoxSaveParser.CLI.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <ImplicitUsings>disable</ImplicitUsings>
+        <InvariantGlobalization>true</InvariantGlobalization>
+        <PublishAot>true</PublishAot>
+    </PropertyGroup>
+    
+    <ItemGroup>
+        <ProjectReference Include="..\ParadoxSaveParser.Lib\ParadoxSaveParser.Lib.csproj"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="DTLib" Version="1.7.4" />
+    </ItemGroup>
+</Project>

ParadoxSaveParser.CLI/ParadoxSaveParser.CLI.csproj.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=modes/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

ParadoxSaveParser.CLI/Program.cs

@@ -0,0 +1,70 @@
+global using System;
+global using DTLib.Console;
+global using DTLib.Demystifier;
+global using DTLib.Filesystem;
+global using Directory = DTLib.Filesystem.Directory;
+global using File = DTLib.Filesystem.File;
+using ParadoxSaveParser.CLI;
+
+try
+{
+    Mode mode = Mode.Unset;
+    IOPath? inputPath = null;
+    IOPath? outputPath = null;
+    string? searchQuery = null;
+
+    new LaunchArgumentParser(
+            new LaunchArgument(["-i", "--input"],
+                "Set input file path",
+                s => inputPath = s,
+                "gamestate or zip file"),
+
+            new LaunchArgument(["-o", "--output"],
+                "Set output file path",
+                s => outputPath = s,
+                "json file [default=stdout]"),
+
+            new LaunchArgument(["-s", "--search"],
+                "Search in input file",
+                s =>
+                {
+                    searchQuery = s;
+                    mode = Mode.Search;
+                },
+                "search expression")
+        )
+        .AllowNoArguments()
+        .ParseAndHandle(args);
+
+    if (args.Length == 0)
+        mode = Mode.Interactive;
+
+    switch (mode)
+    {
+        default:
+            throw new ArgumentOutOfRangeException(nameof(mode));
+        case Mode.Unset:
+            throw new Exception("No action specified");
+        case Mode.Search:
+            if (string.IsNullOrEmpty(searchQuery))
+                throw new ArgumentException("Search expression is required");
+            if (inputPath is null)
+                throw new ArgumentException("Input file path is required");
+            Modes.Search(searchQuery, inputPath.Value, outputPath);
+            break;
+        case Mode.Interactive:
+            Modes.Interactive();
+            break;
+    }
+}
+catch (LaunchArgumentParser.ExitAfterHelpException)
+{
+    // this exception is throwed after -h argument to close the program
+}
+catch (Exception ex)
+{
+    ColoredConsole.WriteLine(ex.ToStringDemystified(), ConsoleColor.Red);
+    Console.ResetColor();
+    Environment.Exit(1);
+}
+Console.ResetColor();

ParadoxSaveParser.Lib.Tests/ParadoxSaveParser.Lib.Tests.csproj

@@ -1,21 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
     <PropertyGroup>
         <TargetFramework>net8.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
+        <LangVersion>latest</LangVersion>
         <Nullable>enable</Nullable>
+        <ImplicitUsings>disable</ImplicitUsings>
+        <InvariantGlobalization>true</InvariantGlobalization>
 
         <IsPackable>false</IsPackable>
         <IsTestProject>true</IsTestProject>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+        <ProjectReference Include="..\ParadoxSaveParser.Lib\ParadoxSaveParser.Lib.csproj"/>
-        <PackageReference Include="DTLib" Version="1.6.5"/>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
-        <PackageReference Include="NUnit" Version="3.14.0"/>
-        <PackageReference Include="NUnit.Analyzers" Version="3.9.0"/>
-        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
     </ItemGroup>
     
     <ItemGroup>
@@ -23,7 +19,17 @@
     </ItemGroup>
     
     <ItemGroup>
-        <ProjectReference Include="..\ParadoxSaveParser.Lib\ParadoxSaveParser.Lib.csproj"/>
+        <PackageReference Include="coverlet.collector" Version="6.0.4">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="DTLib" Version="1.7.4" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.0" />
+        <PackageReference Include="NUnit" Version="4.3.2" />
+        <PackageReference Include="NUnit.Analyzers" Version="4.7.0">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
     </ItemGroup>
-
 </Project>

ParadoxSaveParser.Lib.Tests/SearchExpressionTests.cs

@@ -1,5 +1,7 @@
+using System.IO;
 using System.Text.Encodings.Web;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using DTLib.Extensions;
 
 namespace ParadoxSaveParser.Lib.Tests;
@@ -21,7 +23,8 @@ public class SearchExpressionTests
     {
         WriteIndented = false,
         Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
-        MaxDepth = 1024
+        MaxDepth = 1024,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
     };
 
     internal static string JsonToPdx(string json)

ParadoxSaveParser.Lib/ParadoxSaveParser.Lib.csproj

@@ -1,11 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <TargetFramework>net8.0</TargetFramework>
-        <ImplicitUsings>disable</ImplicitUsings>
+        <LangVersion>latest</LangVersion>
         <Nullable>enable</Nullable>
+        <ImplicitUsings>disable</ImplicitUsings>
+        <InvariantGlobalization>true</InvariantGlobalization>
     </PropertyGroup>
-    <ItemGroup>
-      <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.3" />
-    </ItemGroup>
     
+    <ItemGroup>
+      <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.5" />
+    </ItemGroup>
 </Project>

ParadoxSaveParser.Lib/ParsedValueJsonContext.cs

@@ -0,0 +1,14 @@
+using System.Text.Json.Serialization;
+
+namespace ParadoxSaveParser.Lib;
+
+[JsonSourceGenerationOptions(MaxDepth = 1024, WriteIndented = true)]
+[JsonSerializable(typeof(Dictionary<string, object>))]
+[JsonSerializable(typeof(List<object>))]
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(long))]
+[JsonSerializable(typeof(double))]
+[JsonSerializable(typeof(bool))]
+public partial class ParsedValueJsonContext : JsonSerializerContext
+{
+}

ParadoxSaveParser.Lib/SaveParserEU4.cs

@@ -16,9 +16,6 @@ public class SaveParserEU4
     private readonly ObjectPool<StringBuilder> _stringBuilderPool;
     private ISearchExpression? _searchExprCurrent;
 
-    public int SBPoolGetCount = 0;
-    public int SBPoolReturnCount = 0;
-
     /// <param name="savefile">
     ///     Uncompressed stream of <c>gamestate</c> file which can be extracted from save archive
     /// </param>
@@ -50,7 +47,6 @@ public class SaveParserEU4
             throw new Exception($"Invalid gamestate header. Expected '{expectedHeader}', got '{headStr}'.");
 
         StringBuilder strb = _stringBuilderPool.Get();
-        SBPoolGetCount++;
         int line = 2;
         int column = 0;
         bool isQuoteOpen = false;
@@ -80,7 +76,6 @@ public class SaveParserEU4
                 value = strb,
             };
             strb = _stringBuilderPool.Get();
-            SBPoolGetCount++;
             isStrInQuotes = false;
             return true;
         }
@@ -95,7 +90,6 @@ public class SaveParserEU4
                     if (TryCompleteStringToken())
                         yield return strToken;
                     _stringBuilderPool.Return(strb);
-                    SBPoolReturnCount++;
                     yield break;
                 case '\"':
                     isQuoteOpen = !isQuoteOpen;
@@ -150,7 +144,6 @@ public class SaveParserEU4
         }
 
         _stringBuilderPool.Return(strb);
-        SBPoolReturnCount++;
     }
 
 
@@ -161,16 +154,29 @@ public class SaveParserEU4
         switch (tok.type)
         {
             case TokenType.StringOrNumber:
-                string tokStr = tok.value!.ToString();
+                try
-                _stringBuilderPool.Return(tok.value);
+                {
-                SBPoolReturnCount++;
+                    // string values can be empty
-                if (tokStr[0] != '-' && !char.IsDigit(tokStr[0]))
+                    if (tok.value!.Length == 0)
+                        return string.Empty;
+                    if (tok.value.Equals("yes"))
+                        return true;
+                    if (tok.value.Equals("no"))
+                        return false;
+                    
+                    string tokStr = tok.value.ToString();
+                    if (tokStr[0] != '-' && !char.IsDigit(tokStr[0]))
+                        return tokStr;
+                    if (tokStr.Contains('.') && double.TryParse(tokStr, out double d))
+                        return d;
+                    if (long.TryParse(tokStr, out long l))
+                        return l;
                     return tokStr;
-                if (tokStr.Contains('.') && double.TryParse(tokStr, out double d))
+                }
-                    return d;
+                finally
-                if (long.TryParse(tokStr, out long l))
+                {
-                    return l;
+                    _stringBuilderPool.Return(tok.value!);
-                return tokStr;
+                }
             case TokenType.BracketOpen:
                 object obj = ParseListOrDict();
                 return obj;
@@ -194,9 +200,6 @@ public class SaveParserEU4
                 return true;
             case TokenType.StringOrNumber:
                 _stringBuilderPool.Return(tok.value!);
-                SBPoolReturnCount++;
-                return true;
-            case TokenType.Equals:
                 return true;
             case TokenType.BracketClose:
                 return false;
@@ -218,11 +221,13 @@ public class SaveParserEU4
             else if (tok.type == TokenType.StringOrNumber)
             {
                 _stringBuilderPool.Return(tok.value!);
-                SBPoolReturnCount++;
             }
         }
     }
 
+    private static bool IsEmptyCollection(object value)
+        => value is Dictionary<string, object> { Count: 0 } or List<object> { Count: 0 };
+
     // doesn't move next
     private object ParseListOrDict()
     {
@@ -238,13 +243,30 @@ public class SaveParserEU4
     private List<object> ParseList()
     {
         List<object> list = new();
-        while (true)
+        for (int i = 0; ; i++)
         {
             if (!_tokens.MoveNext())
                 throw new Exception("Unexpected end of file");
+
+            ISearchExpression? searchExprNext = null;
+            if (_searchExprCurrent != null 
+                && !_searchExprCurrent.DoesMatch(new SearchArgs(i, string.Empty), out searchExprNext))
+            {
+                if(!SkipValue())
+                    break;
+                continue;
+            }
+            var searchExprPrev = _searchExprCurrent;
+            _searchExprCurrent = searchExprNext;
             object? value = ParseValue();
+            _searchExprCurrent = searchExprPrev;
             if (value is null)
                 break;
+
+            // do dot add empty collections into list
+            if (IsEmptyCollection(value))
+                continue;
+            
             list.Add(value);
         }
 
@@ -252,9 +274,9 @@ public class SaveParserEU4
     }
 
     // moves next
-    private Dictionary<string, List<object>> ParseDict()
+    private Dictionary<string, object> ParseDict()
     {
-        Dictionary<string, List<object>> dict = new();
+        Dictionary<string, object> dict = new();
 
         // root is a dict without closing bracket, so this method must check _tokenIndex < _tokens.Count
         for (int localIndex = 0; _tokens.MoveNext(); localIndex++)
@@ -300,9 +322,9 @@ public class SaveParserEU4
             if (_searchExprCurrent != null
                 && !_searchExprCurrent.DoesMatch(new SearchArgs(localIndex, keySB), out searchExprNext))
             {
-                SkipValue();
+                if(!SkipValue())
+                    throw new UnexpectedTokenException(_tokens.Current.Value);
                 _stringBuilderPool.Return(keySB);
-                SBPoolReturnCount++;
                 continue;
             }
 
@@ -315,20 +337,32 @@ public class SaveParserEU4
 
             string keyStr = keySB.ToString();
             _stringBuilderPool.Return(keySB);
-            SBPoolReturnCount++;
-            if (!dict.TryGetValue(keyStr, out var list))
-            {
-                list = new List<object>();
-                dict.Add(keyStr, list);
-            }
             
-            list.Add(value);
+            // Paradox save format has another way of defining list:
+            // a = 1
+            // a = 2
+            // It means `a = { 1 2 }`
+            if (dict.TryGetValue(keyStr, out var firstValue))
+            {
+                // Do dot add empty collections into list.
+                // `key:{}` is okay, but i don't want to see `key:[{},{},{},{},{},{}]`
+                if (IsEmptyCollection(value))
+                    continue;
+                
+                if (firstValue is List<object> existingList)
+                    existingList.Add(value);
+                else dict[keyStr] = new List<object> { firstValue, value };
+            }
+            else
+            {
+                dict.Add(keyStr, value);
+            }
         }
 
         return dict;
     }
 
-    public Dictionary<string, List<object>> Parse()
+    public Dictionary<string, object> Parse()
     {
         var root = ParseDict();
         return root;

ParadoxSaveParser.Lib/SearchExpression.cs

@@ -1,6 +1,6 @@
 namespace ParadoxSaveParser.Lib;
 
-public record SearchArgs
+public readonly record struct SearchArgs
 {
     public readonly string KeyStr;
     public readonly StringBuilder? KeySB;
@@ -41,7 +41,8 @@ public static class SearchExpressionCompiler
             var subExprs = new List<ISearchExpression>();
             int supExprBegin = 1;
             int bracketBalance = 1;
-            for (int i = supExprBegin; i < query.Length && bracketBalance != 0; i++)
+            int i = supExprBegin;
+            for (; i < query.Length && bracketBalance != 0; i++)
             {
                 if (CharEqualsAndNotEscaped('(', query, i))
                 {
@@ -60,7 +61,7 @@ public static class SearchExpressionCompiler
                 }
             }
 
-            if (query[^1] != ')')
+            if (i != query.Length)
                 throw new NotImplementedException("Expressions after ')' are not supported");
 
             if (bracketBalance > 0)
@@ -68,7 +69,7 @@ public static class SearchExpressionCompiler
             if (bracketBalance < 0)
                 throw new Exception("Too many closing brackets");
 
-            var subPartLast = query.Slice(supExprBegin, query.Length - supExprBegin - 1);
+            var subPartLast = query.Slice(supExprBegin, i - 1 - supExprBegin);
             var subExprLast = Compile(subPartLast);
             subExprs.Add(subExprLast);
             return new MultipleMatchExpression(subExprs);
@@ -86,7 +87,10 @@ public static class SearchExpressionCompiler
         ReadOnlySpan<char> remaining = default;
         if (partBeforePointLength < query.Length)
             remaining = query.Slice(partBeforePointLength + 1);
-        if (part is "*") return new AnyMatchExpression(remaining.IsEmpty ? null : Compile(remaining));
+        if (part is "*") 
+            return new AnyMatchExpression(remaining.IsEmpty ? null : Compile(remaining));
+        if (part is "~")
+            return new NoMatchExpression();
         
         for (int j = 0; j < part.Length; j++)
             if (CharEqualsAndNotEscaped('*', part, j))
@@ -111,6 +115,15 @@ public static class SearchExpressionCompiler
         }
     }
 
+    private record NoMatchExpression : ISearchExpression
+    {
+        public bool DoesMatch(SearchArgs args, out ISearchExpression? nextSearchExpression)
+        {
+            nextSearchExpression = null;
+            return false;
+        }
+    }
+
     private record MultipleMatchExpression(List<ISearchExpression> subExprs) : ISearchExpression
     {
         public bool DoesMatch(SearchArgs args, out ISearchExpression? nextSearchExpression)

ParadoxSaveParser.WebAPI/BackgroundTasks/BackgroundJobManager.cs

@@ -0,0 +1,25 @@
+using ParadoxSaveParser.WebAPI.Database;
+using ParadoxSaveParser.WebAPI.SaveDataFilters;
+
+namespace ParadoxSaveParser.WebAPI.BackgroundTasks;
+
+public class BackgroundJobManager
+{
+    private readonly ILogger _parentLogger;
+    private long _lastJobId;
+
+    public BackgroundJobManager(ILogger logger)
+    {
+        _parentLogger = logger;
+    }
+    
+    public SaveParsingOperation StartNewParsingOperation(
+        SaveFileMetadata meta, ISaveDataFilter filter, CancellationToken ct)
+    {
+        long nextId = Interlocked.Increment(ref _lastJobId);
+        var contextLogger = new ContextLogger($"BackgroundJob-{nextId}", _parentLogger);
+        var op = new SaveParsingOperation(nextId, meta, filter, contextLogger, ct);
+        op.StartAsync();
+        return op;
+    }
+}

ParadoxSaveParser.WebAPI/BackgroundTasks/SaveParsingOperation.cs

@@ -0,0 +1,102 @@
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text.Encodings.Web;
+using System.Text.Json.Serialization;
+using ParadoxSaveParser.WebAPI.Database;
+using ParadoxSaveParser.WebAPI.SaveDataFilters;
+
+namespace ParadoxSaveParser.WebAPI.BackgroundTasks;
+
+public class SaveParsingOperation
+{
+    public readonly long OperationId;
+    
+    private readonly SaveFileMetadata _meta;
+    private readonly ISaveDataFilter _filter;
+    private readonly ContextLogger _logger;
+    private readonly CancellationToken _ct;
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        WriteIndented = false,
+        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        MaxDepth = 1024,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+    };
+
+    public SaveParsingOperation(long operationId, SaveFileMetadata meta, ISaveDataFilter filter,
+        ContextLogger logger, CancellationToken ct)
+    {
+        OperationId = operationId;
+        _meta = meta;
+        _filter = filter;
+        _logger = logger;
+        _ct = ct;
+    }
+
+    public async void StartAsync()
+    {
+        try
+        {
+            _logger.LogInfo($"Starting background parsing operation of {_meta.game} save {_meta.id}");
+            switch (_meta.game)
+            {
+                case Game.EU4:
+                    await ParseSaveEU4();
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(_meta.game.ToString());
+            }
+            _logger.LogInfo($"Finished parsing operation of {_meta.game} save {_meta.id}");
+        }
+        catch (Exception ex)
+        {
+            string errorMesage = ex.ToStringDemystified();
+            _logger.LogError(errorMesage);
+            try
+            {
+                await Program.DB.SetMetadataError(_meta, errorMesage);
+            }
+            catch (Exception ex2)
+            {
+                _logger.LogError(ex2);
+            }
+        }
+        finally
+        {
+            GC.Collect(GC.MaxGeneration, GCCollectionMode.Aggressive, true, true);
+        }
+    }
+    
+    private async Task ParseSaveEU4()
+    {
+        // wait for save file closing
+        await Task.Delay(200, _ct);
+        Dictionary<string, object> parsedData;
+        await using (var gamestateStream = PathHelper.CreateTempFile())
+        {
+            using (var zipArchive = ZipFile.Open(_meta.GetSaveFilePath().Str, ZipArchiveMode.Read))
+            {
+                var zipEntry = zipArchive.Entries.FirstOrDefault(e => e.Name == "gamestate");
+                if (zipEntry is null)
+                    throw new Exception("Invalid save format: no 'gamestate' file found");
+
+                await zipEntry.Open().CopyToAsync(gamestateStream, _ct);
+                gamestateStream.Seek(0, SeekOrigin.Begin);
+            }
+            
+            await Program.DB.UpdateMetadataStatus(_meta, SaveFileProcessingStatus.Parsing);
+            var parser = new SaveParserEU4(gamestateStream, _filter.SearchExpression);
+            parsedData = parser.Parse();
+        }
+
+        _filter.Apply(parsedData);
+
+        await Program.DB.UpdateMetadataStatus(_meta, SaveFileProcessingStatus.SavingResults);
+        var resultFilePath = _meta.GetParsedDataPath();
+        await using (var resultFile = File.OpenWrite(resultFilePath))
+            await JsonSerializer.SerializeAsync(resultFile, parsedData, _jsonOptions, _ct);
+        await Program.DB.UpdateMetadataStatus(_meta, SaveFileProcessingStatus.Done);
+    }
+}

ParadoxSaveParser.WebAPI/Database/DatabaseConnector.cs

@@ -0,0 +1,106 @@
+using System.Linq;
+using SQLite;
+
+namespace ParadoxSaveParser.WebAPI.Database;
+
+public class DatabaseConnector
+{
+    private readonly int _uploadsLifetimeDays;
+    private readonly SQLiteAsyncConnection _db;
+    private readonly ContextLogger _logger;
+
+    public DatabaseConnector(string databasePath, int uploadsLifetimeDays, ILogger logger)
+    {
+        _uploadsLifetimeDays = uploadsLifetimeDays;
+        _db = new SQLiteAsyncConnection(databasePath);
+        _logger = new ContextLogger("Database", logger);
+    }
+
+    public async Task InitializeAsync()
+    {
+        await _db.CreateTableAsync<SaveFileMetadata>();
+    }
+    
+    public async Task<SaveFileMetadata?> GetMetadata(string id)
+    {
+        return (await _db.QueryAsync<SaveFileMetadata>(
+            "select * from SaveFileMetadata where id = ?", id))
+            .FirstOrDefault();
+    }
+    
+    public async Task<SaveFileMetadata> CreateMetadata(Game game)
+    {
+        var meta = new SaveFileMetadata
+        {
+            id = Guid.NewGuid().ToString(),
+            game = game,
+            status = SaveFileProcessingStatus.Initialized,
+            uploadDateTime = DateTime.Now
+        };
+        await _db.InsertAsync(meta);
+        return meta;
+    }
+
+    public async Task UpdateMetadataStatus(SaveFileMetadata meta, SaveFileProcessingStatus status)
+    {
+        meta.status = status;
+        await _db.UpdateAsync(meta);
+    }
+
+    public async Task SetMetadataError(SaveFileMetadata meta, string errorMessage)
+    {
+        meta.errorMessage = errorMessage;
+        await UpdateMetadataStatus(meta, SaveFileProcessingStatus.Error);
+        TryDeleteAssociatedFiles(meta);
+    }
+
+    public async Task DeleteMetadata(SaveFileMetadata meta, string reason)
+    {
+        _logger.LogDebug($"Deleting save file (id: {meta.id} reason: {reason}" +
+                         $"uploadDate: {meta.uploadDateTime:yyyy/MM/dd})");
+        await _db.DeleteAsync(meta);
+        TryDeleteAssociatedFiles(meta);
+    }
+
+    /// <summary>
+    /// WARNING: Call this method only when no parsing operations are running.
+    /// </summary>
+    public async Task DeleteInvalidData()
+    {
+        _logger.LogInfo("Deleting invalid data...");
+        
+        var expirationDate = DateTime.Now.AddDays(-_uploadsLifetimeDays);
+        var metadataTable = _db.Table<SaveFileMetadata>();
+        var metadataList = await metadataTable.ToListAsync();
+        int deleteCount = 0;
+        foreach (var meta in metadataList)
+        {
+            string deletionReason;
+            if(meta.status != SaveFileProcessingStatus.Done)
+                deletionReason = $"invalid status ({meta.status})";
+            else if (meta.uploadDateTime < expirationDate)
+               deletionReason = "expired";
+            else if(!meta.AssociatedFilesExist())
+                deletionReason = "files not found";
+            else continue;
+            
+            deleteCount++;
+            await DeleteMetadata(meta, deletionReason);
+        }
+
+        _logger.LogInfo($"Deleted {deleteCount} invalid records");
+    }
+
+    private void TryDeleteFile(IOPath file)
+    {
+        if (!File.Exists(file)) return;
+        _logger.LogDebug($"Deleting file '{file}'");
+        File.Delete(file);
+    }
+
+    private void TryDeleteAssociatedFiles(SaveFileMetadata meta)
+    {
+        TryDeleteFile(meta.GetSaveFilePath());
+        TryDeleteFile(meta.GetParsedDataPath());
+    }
+}

ParadoxSaveParser.WebAPI/Database/SaveFileMetadata.cs

@@ -0,0 +1,45 @@
+using System.Text.Json.Serialization;
+
+namespace ParadoxSaveParser.WebAPI.Database;
+
+public enum SaveFileProcessingStatus
+{
+    Initialized,
+    Uploaded,
+    Parsing,
+    SavingResults,
+    Done,
+    Error,
+}
+
+public class SaveFileMetadata
+{
+    [SQLite.PrimaryKey]
+    [SQLite.NotNull]
+    public string id { get; init; } = null!;
+
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    [SQLite.NotNull]
+    public Game game { get; init; }
+
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    [SQLite.NotNull]
+    public SaveFileProcessingStatus status { get; set; }
+    
+    [SQLite.NotNull]
+    public DateTime uploadDateTime { get; set; }
+    
+    // if error occured during parsing, it's message is saved here
+    // status stays the same as when error occured
+    public string? errorMessage { get; set; }
+    
+    
+    public IOPath GetSaveFilePath() => Path.Concat(PathHelper.SAVES_DIR, id + ".eu4");
+
+    public IOPath GetParsedDataPath() => Path.Concat(PathHelper.PARSED_DIR, id + ".parsed.json");
+
+    public bool AssociatedFilesExist()
+    {
+        return File.Exists(GetSaveFilePath()) && File.Exists(GetParsedDataPath());
+    }
+}

ParadoxSaveParser.WebAPI/Game.cs

@@ -0,0 +1,7 @@
+namespace ParadoxSaveParser.WebAPI;
+
+public enum Game
+{
+    Unknown,
+    EU4
+}

ParadoxSaveParser.WebAPI/HttpHelpers/ErrorMessage.cs

@@ -0,0 +1,17 @@
+using System.Net;
+using System.Text.Json.Serialization;
+
+namespace ParadoxSaveParser.WebAPI.HttpHelpers;
+
+public record ErrorMessage
+{
+    public ErrorMessage(HttpStatusCode statusCode, string message)
+    {
+        StatusCode = statusCode;
+        Message = message;
+    }
+
+    [JsonIgnore] public HttpStatusCode StatusCode { get; }
+
+    [JsonPropertyName("errorMessage")] public string Message { get; }
+}

ParadoxSaveParser.WebAPI/HttpHelpers/RequestHelper.cs

@@ -0,0 +1,17 @@
+using System.Linq;
+using System.Net;
+
+namespace ParadoxSaveParser.WebAPI.HttpHelpers;
+
+public class RequestHelper
+{
+    internal static ValueOrError<string> GetQueryValue(HttpListenerContext ctx, string paramName)
+    {
+        string[]? values = ctx.Request.QueryString.GetValues(paramName);
+        string? value = values?.FirstOrDefault();
+        if (string.IsNullOrEmpty(value))
+            return new ErrorMessage(HttpStatusCode.BadRequest,
+                $"No request parameter '{paramName}' provided");
+        return value;
+    }
+}

ParadoxSaveParser.WebAPI/HttpHelpers/ReturnHelper.cs

@@ -0,0 +1,96 @@
+using System.IO;
+using System.Net;
+using System.Text.Encodings.Web;
+using System.Text.Json.Serialization;
+using DTLib.Extensions;
+
+namespace ParadoxSaveParser.WebAPI.HttpHelpers;
+
+public class ReturnHelper
+{
+    private static readonly JsonSerializerOptions _responseJsonSerializerOptions = new()
+    {
+        WriteIndented = false,
+        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        MaxDepth = 1024,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+    };
+
+    private static async Task ResponseShort(HttpListenerContext ctx,
+        ContextLogger logger,
+        CancellationToken ct,
+        byte[] value,
+        HttpStatusCode statusCode,
+        string contentType)
+    {
+        ctx.Response.StatusCode = (int)statusCode;
+        ctx.Response.ContentType = contentType;
+        logger.LogDebug($"short response (length: {value.Length} type: {contentType})");
+        if (value.Length > 4000)
+        {
+            logger.LogWarn($"response (length: {value.Length} type: {contentType})\n"
+                + $"Content is too big for {nameof(ResponseShort)}."
+                + $"You should send stream instead of byte array.");
+        }
+        await ctx.Response.OutputStream.WriteAsync(value, ct);
+    }
+    
+    public static async Task<HttpStatusCode> ResponseString(
+        HttpListenerContext ctx,
+        ContextLogger logger,
+        CancellationToken ct,
+        string value, 
+        HttpStatusCode statusCode = HttpStatusCode.OK,
+        string contentType = "text/plain")
+    {
+        await ResponseShort(ctx, logger, ct, value.ToBytes(), statusCode, contentType);
+        logger.LogDebug(value);
+        return statusCode;
+    }
+
+    public static async Task<HttpStatusCode> ResponseJson(
+        HttpListenerContext ctx,
+        ContextLogger logger,
+        CancellationToken ct,
+        object value,
+        HttpStatusCode statusCode = HttpStatusCode.OK)
+    {
+        string json = JsonSerializer.Serialize(
+            value, 
+            value.GetType(),
+            _responseJsonSerializerOptions);
+        return await ResponseString(ctx, logger, ct, json, statusCode, "application/json");
+    }
+
+    public static async Task<HttpStatusCode> ResponseError(
+        HttpListenerContext ctx, 
+        ContextLogger logger,
+        CancellationToken ct, 
+        ErrorMessage error)
+    {
+        return await ResponseJson(ctx, logger, ct, error, error.StatusCode);
+    }
+
+    public static async Task<HttpStatusCode> ResponseStream(HttpListenerContext ctx,
+        ContextLogger logger,
+        CancellationToken ct,
+        Stream valueStream,
+        HttpStatusCode statusCode = HttpStatusCode.OK,
+        string contentType = "application/octet-stream")
+    {
+        try
+        {
+            ctx.Response.StatusCode = (int)statusCode;
+            ctx.Response.ContentType = contentType;
+            logger.LogDebug($"stream response (type: {contentType})");
+            await valueStream.CopyToAsync(ctx.Response.OutputStream, ct);
+            return statusCode;
+        }
+        catch (Exception ex)
+        {
+            return await ResponseError(ctx, logger, ct, 
+                new ErrorMessage(HttpStatusCode.InternalServerError, 
+                ex.ToStringDemystified()));
+        }
+    }
+}

ParadoxSaveParser.WebAPI/HttpHelpers/ValueOrError.cs

@@ -0,0 +1,19 @@
+namespace ParadoxSaveParser.WebAPI.HttpHelpers;
+
+public class ValueOrError<T>
+    {
+        public readonly ErrorMessage? Error;
+        public readonly T? Value;
+
+        private ValueOrError(T? value, ErrorMessage? error)
+        {
+            Value = value;
+            Error = error;
+        }
+
+        public bool HasError => Error is not null;
+
+        public static implicit operator ValueOrError<T>(T v) => new(v, null);
+
+        public static implicit operator ValueOrError<T>(ErrorMessage e) => new(default, e);
+    }

ParadoxSaveParser.WebAPI/ParadoxSaveParser.WebAPI.csproj

@@ -13,6 +13,16 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="DTLib.Web" Version="1.2.2"/>
+        <PackageReference Include="DTLib.Web" Version="1.4.0" />
+<!--        <PackageReference Include="Google.Protobuf" Version="3.31.0" />-->
+        <PackageReference Include="sqlite-net-pcl" Version="1.9.172" />
     </ItemGroup>
+
+<!--    <ItemGroup>-->
+<!--        <Compile Include="obj\Protobuf\*.g.cs" />-->
+<!--    </ItemGroup>-->
+
+<!--    <Target Name="PreBuild" BeforeTargets="PreBuildEvent">-->
+<!--        <Exec Command="sh -c &quot;mkdir -p obj/Protobuf &amp;&amp; protoc Protobuf/*.proto &#45;&#45;csharp_out=obj/Protobuf &#45;&#45;csharp_opt=file_extension=.g.cs&quot;" />-->
+<!--    </Target>-->
 </Project>

ParadoxSaveParser.WebAPI/PathHelper.cs

@@ -1,13 +1,37 @@
-namespace ParadoxSaveParser.WebAPI;
+using System.IO;
+
+namespace ParadoxSaveParser.WebAPI;
 
 public static class PathHelper
 {
-    public static readonly IOPath DATA_DIR = "data";
+    public static readonly IOPath PUBLIC_DIR = "public";
+    public static readonly IOPath DATA_DIR = Path.Concat(PUBLIC_DIR, "data");
     public static readonly IOPath SAVES_DIR = Path.Concat(DATA_DIR, "saves");
+    public static readonly IOPath PARSED_DIR = Path.Concat(DATA_DIR, "parsed");
+    public static readonly IOPath TEMP_DIR = "temp";
 
-    public static IOPath GetMetaFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".meta.json");
+    public static void CreateProgramDirectories()
+    {
+        Directory.Create(DATA_DIR);
+        Directory.Create(SAVES_DIR);
+        Directory.Create(PARSED_DIR);
+        Directory.Create(TEMP_DIR);
+    }
 
-    public static IOPath GetSaveFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".eu4");
+    public static void CleanTempDirectory()
+    {
+        Directory.Delete(TEMP_DIR);
+        Directory.Create(TEMP_DIR);
+    }
 
-    public static IOPath GetParsedSaveFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".parsed.json");
+    public static Stream CreateTempFile()
+    {
+        string fileName = Guid.NewGuid().ToString();
+        IOPath filePath = Path.Concat(TEMP_DIR, fileName);
+        var stream = System.IO.File.Open(filePath.Str, FileMode.CreateNew, FileAccess.ReadWrite,
+            FileShare.Read | FileShare.Delete);
+        // file stays as a ghost until it is closed
+        File.Delete(filePath);
+        return stream;
+    }
 }

ParadoxSaveParser.WebAPI/Program.HttpHelpers.cs

@@ -1,97 +0,0 @@
-using System.Linq;
-using System.Net;
-using System.Text.Encodings.Web;
-using System.Text.Json.Serialization;
-using DTLib.Extensions;
-
-namespace ParadoxSaveParser.WebAPI;
-
-public partial class Program
-{
-    private static readonly JsonSerializerOptions _responseJsonSerializerOptions = new()
-    {
-        WriteIndented = false,
-        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
-        MaxDepth = 1024
-    };
-
-    public static async Task<HttpStatusCode> ReturnResponseString(HttpListenerContext ctx,
-        string value, HttpStatusCode statusCode = HttpStatusCode.OK)
-    {
-        ctx.Response.StatusCode = (int)statusCode;
-        ctx.Response.ContentType = "text/plain";
-        await ctx.Response.OutputStream.WriteAsync(
-            value.ToBytes(),
-            _mainCancel.Token);
-        return statusCode;
-    }
-
-    public static async Task<HttpStatusCode> ReturnResponseJson(HttpListenerContext ctx,
-        object value, HttpStatusCode statusCode = HttpStatusCode.OK)
-    {
-        ctx.Response.StatusCode = (int)statusCode;
-        ctx.Response.ContentType = "application/json";
-        await JsonSerializer.SerializeAsync(
-            ctx.Response.OutputStream,
-            value,
-            value.GetType(),
-            _responseJsonSerializerOptions,
-            _mainCancel.Token);
-        return statusCode;
-    }
-
-    public static async Task<HttpStatusCode> ReturnResponseError(HttpListenerContext ctx, ErrorMessage error)
-    {
-        ctx.Response.StatusCode = (int)error.StatusCode;
-        ctx.Response.ContentType = "application/json";
-        await JsonSerializer.SerializeAsync(
-            ctx.Response.OutputStream,
-            error,
-            typeof(ErrorMessage),
-            _responseJsonSerializerOptions,
-            _mainCancel.Token);
-        return error.StatusCode;
-    }
-
-
-    internal static ValueOrError<string> GetRequestQueryValue(HttpListenerContext ctx, string paramName)
-    {
-        string[]? values = ctx.Request.QueryString.GetValues(paramName);
-        string? value = values?.FirstOrDefault();
-        if (string.IsNullOrEmpty(value))
-            return new ErrorMessage(HttpStatusCode.BadRequest,
-                $"No request parameter '{paramName}' provided");
-        return value;
-    }
-
-    public record ErrorMessage
-    {
-        public ErrorMessage(HttpStatusCode statusCode, string message)
-        {
-            StatusCode = statusCode;
-            Message = message;
-        }
-
-        [JsonIgnore] public HttpStatusCode StatusCode { get; }
-
-        [JsonPropertyName("errorMessage")] public string Message { get; }
-    }
-
-    public class ValueOrError<T>
-    {
-        public readonly ErrorMessage? Error;
-        public readonly T? Value;
-
-        private ValueOrError(T? value, ErrorMessage? error)
-        {
-            Value = value;
-            Error = error;
-        }
-
-        public bool HasError => Error is not null;
-
-        public static implicit operator ValueOrError<T>(T v) => new(v, null);
-
-        public static implicit operator ValueOrError<T>(ErrorMessage e) => new(default, e);
-    }
-}

ParadoxSaveParser.WebAPI/Program.RequestHandlers.cs

@@ -1,117 +0,0 @@
-using System.IO.Compression;
-using System.Linq;
-using System.Net;
-
-namespace ParadoxSaveParser.WebAPI;
-
-public partial class Program
-{
-    private static async Task<HttpStatusCode> UploadSaveHandler(HttpListenerContext ctx)
-    {
-        string? contentType = ctx.Request.Headers.GetValues("Content-Type")?.FirstOrDefault();
-        if (contentType != "application/octet-stream")
-            return await ReturnResponseError(ctx, new ErrorMessage(
-                HttpStatusCode.BadRequest,
-                $"Invalid request Content-Type: '{contentType}'"));
-
-        string saveId = Guid.NewGuid().ToString();
-        var metaFilePath = PathHelper.GetMetaFilePath(saveId);
-        if (File.Exists(metaFilePath))
-            return await ReturnResponseError(ctx, new ErrorMessage(
-                HttpStatusCode.InternalServerError,
-                $"Guid collision! file' {metaFilePath}' already exists."));
-
-        var meta = new SaveFileMetadata
-            { id = saveId, game = Game.EU4, status = SaveFileProcessingStatus.Initialized };
-        if (!_saveMetadataStorage.TryAdd(saveId, meta))
-            return await ReturnResponseError(ctx, new ErrorMessage(
-                HttpStatusCode.InternalServerError,
-                $"Guid collision! Can't create metadata with id {saveId}"));
-
-        meta.status = SaveFileProcessingStatus.Uploading;
-        var saveFilePath = PathHelper.GetSaveFilePath(meta.id);
-        await using var saveFile = File.OpenWrite(saveFilePath);
-        await using var remoteStream = ctx.Request.InputStream;
-        await remoteStream.CopyToAsync(saveFile, _mainCancel.Token);
-        meta.status = SaveFileProcessingStatus.Uploaded;
-
-        return await ReturnResponseString(ctx, saveId);
-    }
-
-    private static ValueOrError<SaveFileMetadata> GetMetaFromRequestId(HttpListenerContext ctx,
-        string requestParamName)
-    {
-        var idOrError = GetRequestQueryValue(ctx, requestParamName);
-        if (idOrError.HasError)
-            return idOrError.Error!;
-
-        if (!_saveMetadataStorage.TryGetValue(idOrError.Value!, out var meta))
-            return new ErrorMessage(HttpStatusCode.InternalServerError,
-                $"Save with id {idOrError.Value} not found");
-
-        return meta;
-    }
-
-    private static async Task<HttpStatusCode> GetSaveStatusHandler(HttpListenerContext ctx)
-    {
-        var metaOrError = GetMetaFromRequestId(ctx, "id");
-        if (metaOrError.HasError)
-            return await ReturnResponseError(ctx, metaOrError.Error!);
-
-        return await ReturnResponseJson(ctx, metaOrError.Value!);
-    }
-
-    private static async Task<HttpStatusCode> ParseSaveEU4Handler(HttpListenerContext ctx)
-    {
-        var metaOrError = GetMetaFromRequestId(ctx, "id");
-        if (metaOrError.HasError)
-            return await ReturnResponseError(ctx, metaOrError.Error!);
-        var meta = metaOrError.Value!;
-
-        var searchQueryOrError = GetRequestQueryValue(ctx, "search");
-        if (searchQueryOrError.HasError)
-            return await ReturnResponseError(ctx, searchQueryOrError.Error!);
-        string searchQuery = searchQueryOrError.Value!;
-
-        try
-        {
-            string extractedGamestatePath = PathHelper.GetSaveFilePath(meta.id) + ".gamestate";
-            using (var zipArchive = ZipFile.Open(PathHelper.GetSaveFilePath(meta.id).Str, ZipArchiveMode.Read))
-            {
-                var zipEntry = zipArchive.Entries.FirstOrDefault(e => e.Name == "gamestate");
-                if (zipEntry is null)
-                    return await ReturnResponseError(ctx, new ErrorMessage(
-                        HttpStatusCode.BadRequest,
-                        "Invalid save format: no 'gamestate' file found"));
-
-                zipEntry.ExtractToFile(extractedGamestatePath, true);
-            }
-
-            var gamestateStream = File.OpenRead(extractedGamestatePath);
-
-            meta.status = SaveFileProcessingStatus.Parsing;
-            var se = SearchExpressionCompiler.Compile(searchQuery);
-            var parser = new SaveParserEU4(gamestateStream, se);
-            var result = parser.Parse();
-
-            meta.status = SaveFileProcessingStatus.SavingResults;
-            var resultFilePath = PathHelper.GetParsedSaveFilePath(meta.id);
-            await using var resultFile = File.OpenWrite(resultFilePath);
-            await JsonSerializer.SerializeAsync(resultFile, result, _saveSerializerOptions, _mainCancel.Token);
-            meta.status = SaveFileProcessingStatus.Done;
-            meta.SaveToFile();
-        }
-        catch (Exception ex)
-        {
-            string errorMesage = ex.ToStringDemystified();
-            _loggerRoot.LogWarn(nameof(ParseSaveEU4Handler), errorMesage);
-            return await ReturnResponseError(ctx, new ErrorMessage(HttpStatusCode.BadRequest, errorMesage));
-        }
-        finally
-        {
-            GC.Collect();
-        }
-
-        return await ReturnResponseJson(ctx, meta);
-    }
-}

ParadoxSaveParser.WebAPI/Program.cs

@@ -11,116 +11,110 @@ global using ParadoxSaveParser.Lib;
 global using Directory = DTLib.Filesystem.Directory;
 global using File = DTLib.Filesystem.File;
 global using Path = DTLib.Filesystem.Path;
-using System.Collections.Concurrent;
+using DTLib.Console;
-using System.Diagnostics;
-using System.IO;
-using System.Text.Encodings.Web;
 using DTLib.Dtsod;
 using DTLib.Web;
 using DTLib.Web.Routes;
+using ParadoxSaveParser.WebAPI.BackgroundTasks;
+using ParadoxSaveParser.WebAPI.Database;
+using ParadoxSaveParser.WebAPI.Routes;
+using ParadoxSaveParser.WebAPI.SaveDataFilters;
+// ReSharper disable MethodHasAsyncOverload
 
 namespace ParadoxSaveParser.WebAPI;
 
-public static partial class Program
+public static class Program
 {
-    private static readonly IOPath _configPath = "./config.dtsod";
+    internal static bool IsDebug = true;
-    private static Config _config = new();
+    internal static DatabaseConnector DB = null!;
 
-    private static readonly ILogger _loggerRoot = new CompositeLogger(
-        new ConsoleLogger(),
-        new FileLogger("logs", "ParadoxSaveParser.WebAPI"));
 
-    private static readonly CancellationTokenSource _mainCancel = new();
+    public static async Task Main(string[] args)
-    private static readonly ConcurrentDictionary<string, SaveFileMetadata> _saveMetadataStorage = new();
-
-    private static readonly JsonSerializerOptions _saveSerializerOptions = new()
-    {
-        WriteIndented = true,
-        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
-        MaxDepth = 1024
-    };
-
-    public static void Main(string[] args)
     {
         Console.InputEncoding = Encoding.UTF8;
         Console.OutputEncoding = Encoding.UTF8;
         Console.CursorVisible = false;
-        var logger = new ContextLogger(nameof(Main), _loggerRoot);
+        
+        #if DEBUG
+        IsDebug = true;
+        #endif
+        
+        new LaunchArgumentParser(
+                new LaunchArgument(["-d", "--debug"], 
+                    "enables debug log output to console",
+                    () => IsDebug = true)
+            ).AllowNoArguments().ParseAndHandle(args);
+        
+        var loggerRoot = new CompositeLogger(
+            new ConsoleLogger
+            {
+                DebugLogEnabled = IsDebug
+            },
+            new FileLogger("logs", "ParadoxSaveParser.WebAPI")
+            {
+                DebugLogEnabled = true
+            });
+        var loggerMain = new ContextLogger(nameof(Main), loggerRoot);
+        loggerMain.LogDebug("Debug log is enabled");
+
+        CancellationTokenSource mainCancel = new();
         Console.CancelKeyPress += (_, e) =>
         {
             e.Cancel = true;
-            logger.LogInfo("Ctrl+C Pressed");
+            loggerMain.LogInfo("Ctrl+C Pressed");
-            _mainCancel.Cancel();
+            mainCancel.Cancel();
         };
 
         try
         {
-            Stopwatch stopwatch = new();
-            using var save = File.OpenRead("data/gamestate");
-            stopwatch.Start();
-            var parser = new SaveParserEU4(save, SearchExpressionCompiler.Compile("saved_event_target"));
-            var result = parser.Parse();
-            stopwatch.Stop();
-            using (var resultFile = File.OpenWrite("data/parsed.json"))
-            {
-                JsonSerializer.Serialize(resultFile, result, _saveSerializerOptions);
-            }
-            Console.WriteLine($"get: {parser.SBPoolGetCount} return: {parser.SBPoolReturnCount} " +
-                              $"delta: {parser.SBPoolGetCount - parser.SBPoolReturnCount}");
-            Console.WriteLine(stopwatch.Elapsed);
-            return;
-            
             // config
-            if (!File.Exists(_configPath))
+            IOPath configPath = "./config.dtsod";
+            Config config;
+            if (File.Exists(configPath))
             {
-                logger.LogWarn("config file not found.");
+                config = Config.FromDtsod(new DtsodV23(File.ReadAllText(configPath)));
-                File.WriteAllText(_configPath, _config.ToString());
-                logger.LogWarn($"created default at {_configPath}.");
             }
             else
             {
-                _config = Config.FromDtsod(new DtsodV23(File.ReadAllText(_configPath)));
+                loggerMain.LogWarn("config file not found.");
+                config = new();
+                File.WriteAllText(configPath, config.ToString());
+                loggerMain.LogWarn($"created default at {configPath}.");
             }
             
-            PrepareLocalFiles();
+            PathHelper.CreateProgramDirectories();
+            PathHelper.CleanTempDirectory();
+            DB = new("database.sqlite", 30, loggerRoot);
+            await DB.InitializeAsync();
+            await DB.DeleteInvalidData();
+
+            var bgJobManager = new BackgroundJobManager(loggerRoot);
+            var saveFilters = new Dictionary<Game, ISaveDataFilter>
+            {
+                { Game.EU4, new SaveDataFilterEU4() },
+            };
             
             // http server
-            var router = new SimpleRouter(_loggerRoot);
+            var router = new SimpleRouter(loggerRoot);
-            router.DefaultRoute = new ServeFilesRouteHandler("public");
+            router.DefaultRoute = new SimpleRouter.RouteWithMethod(HttpMethod.GET, 
-            router.MapRoute("/getSaveStatus", HttpMethod.GET, GetSaveStatusHandler);
+                new ServeFilesRouteHandler(PathHelper.PUBLIC_DIR));
-            router.MapRoute("/uploadSave/eu4", HttpMethod.POST, UploadSaveHandler);
+            router.MapRoute("/uploadSave", HttpMethod.POST,
-            router.MapRoute("/parseSave/eu4", HttpMethod.POST, ParseSaveEU4Handler);
+                new UploadSaveHandler(mainCancel.Token, bgJobManager, saveFilters));
+            router.MapRoute("/getSaveStatus", HttpMethod.GET,
+                new GetSaveStatusHandler(mainCancel.Token));
+            router.MapRoute("/getSaveData", HttpMethod.GET,
+                new GetSaveDataHandler(mainCancel.Token));
 
-            var app = new WebApp(_config.BaseUrl, _loggerRoot, router, _mainCancel.Token);
+            var app = new WebApp(config.BaseUrl, loggerRoot, router, mainCancel.Token);
-            app.Run().GetAwaiter().GetResult();
+            await app.Run();
         }
         catch (OperationCanceledException ex)
         {
-            logger.LogWarn($"catched OperationCanceledException from {ex.Source}");
+            loggerMain.LogWarn($"catched OperationCanceledException from {ex.Source}");
         }
         catch (Exception ex)
         {
-            logger.LogError(ex.ToStringDemystified());
+            loggerMain.LogError(ex.ToStringDemystified());
-        }
-    }
-
-    public static void PrepareLocalFiles()
-    {
-        Directory.Create(PathHelper.DATA_DIR);
-        Directory.Create(PathHelper.SAVES_DIR);
-        foreach (string metaFilePath in System.IO.Directory.GetFiles(
-                     PathHelper.SAVES_DIR.Str, "*.meta.json",
-                     SearchOption.TopDirectoryOnly))
-        {
-            using var metaFile = File.OpenRead(metaFilePath);
-            var meta = JsonSerializer.Deserialize<SaveFileMetadata>(metaFile) ??
-                       throw new NullReferenceException(metaFilePath);
-            if (meta.status != SaveFileProcessingStatus.Done)
-                _loggerRoot.LogWarn(nameof(PrepareLocalFiles),
-                    $"metadata file '{metaFilePath}' status has invalid status {meta.status}");
-
-            if (!_saveMetadataStorage.TryAdd(meta.id, meta))
-                throw new Exception("Guid collision!");
         }
     }
 }

ParadoxSaveParser.WebAPI/Protobuf/ParsedData.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+option csharp_namespace = "ParadoxSaveParser.WebAPI.MyProtobuf";
+
+message Item {
+  oneof value {
+    bool b = 1;
+    int64 i64 = 2;
+    double f64 = 3;
+    string str = 4;
+    ItemList list = 5;
+    ItemListMap map = 6;
+  }
+}
+
+message ItemList {
+  repeated Item items = 1;
+}
+
+message ItemListMap {
+  map<string, ItemList> items_map = 1;
+}

ParadoxSaveParser.WebAPI/README.md

@@ -0,0 +1,44 @@
+# WebAPI
+Simple web application created using DTLib.Web.
+
+
+## Important
+Restart web application once per day to delete outdated data and clean RAM.
+
+## Routes
+### POST `/uploadSave`
+- **Query Params:**
+  - `game` - short name of the game (see [../README.md](../README.md))
+- **Request Body:** `application/octet-stream` - .eu4 file
+- **Response:**
+    ```json
+    { "saveId": "string" }
+    ```
+    or `{ "errorMessage": "string" }`
+
+### GET `/getSaveStatus`
+- **Query Params:**
+    - `id` - id of uploaded save file
+- **Response:** [SaveFileMetadata](./SaveFileMetadata.cs)
+    ```json
+    {
+        "id": "string",
+        "game": "string",
+        "status": "string",
+        "errorMessage": "string?"
+    }
+    ```
+
+### GET `/getSaveData`
+- **Query Params:**
+    - `id` - id of uploaded save file
+- **Response:**
+    ```json5
+    {
+        "key0": [ "objects" ],
+        "key1": [ "objects" ],
+        //...
+    }
+    ```
+    or `{ "errorMessage": "string" }`
+

ParadoxSaveParser.WebAPI/Routes/GetSaveDataHandler.cs

@@ -0,0 +1,44 @@
+using System.Net;
+using ParadoxSaveParser.WebAPI.Database;
+using ParadoxSaveParser.WebAPI.HttpHelpers;
+
+namespace ParadoxSaveParser.WebAPI.Routes;
+
+internal class GetSaveDataHandler : RouteHandlerBase
+{
+    public GetSaveDataHandler(CancellationToken cancelAllToken) 
+        : base(cancelAllToken)
+    {
+    }
+
+    public override async Task<HttpStatusCode> HandleRequest(
+        HttpListenerContext ctx, ContextLogger requestLogger)
+    {
+        var idOrError = RequestHelper.GetQueryValue(ctx, "id");
+        if (idOrError.HasError)
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, idOrError.Error!);
+        string id = idOrError.Value!;
+
+        var meta = await Program.DB.GetMetadata(id);
+        if(meta is null)
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, 
+                new ErrorMessage(HttpStatusCode.NotFound,
+                    $"Save with id {id} not found"));
+        if(meta.status != SaveFileProcessingStatus.Done)
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, 
+                new ErrorMessage(HttpStatusCode.BadRequest,
+                    $"Save with id {id} has status {meta.status}"));
+        
+        IOPath dataFilePath = meta.GetParsedDataPath();
+        if (!File.Exists(dataFilePath))
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
+                new ErrorMessage(HttpStatusCode.InternalServerError, 
+                    $"Save with id {id} not found")
+            );
+
+        await using var dataFile = File.OpenRead(dataFilePath);
+        
+        return await ReturnHelper.ResponseStream(ctx, requestLogger, _cancelAllToken,
+            dataFile, contentType: "application/json");
+    }
+}

ParadoxSaveParser.WebAPI/Routes/GetSaveStatusHandler.cs

@@ -0,0 +1,30 @@
+using System.Net;
+using ParadoxSaveParser.WebAPI.HttpHelpers;
+
+namespace ParadoxSaveParser.WebAPI.Routes;
+
+internal class GetSaveStatusHandler : RouteHandlerBase
+{
+    public GetSaveStatusHandler(CancellationToken cancelAllToken) 
+        : base(cancelAllToken)
+    {
+    }
+
+    public override async Task<HttpStatusCode> HandleRequest(
+        HttpListenerContext ctx, ContextLogger requestLogger)
+    {
+        var idOrError = RequestHelper.GetQueryValue(ctx, "id");
+        if (idOrError.HasError)
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, idOrError.Error!);
+        string id = idOrError.Value!;
+
+        var meta = await Program.DB.GetMetadata(id);
+        if (meta is null)
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
+                new ErrorMessage(HttpStatusCode.InternalServerError, 
+                    $"Save with id {id} not found")
+                );
+
+        return await ReturnHelper.ResponseJson(ctx, requestLogger, _cancelAllToken, meta);
+    }
+}

ParadoxSaveParser.WebAPI/Routes/RouteHandlerBase.cs

@@ -0,0 +1,16 @@
+using System.Net;
+using DTLib.Web.Routes;
+
+namespace ParadoxSaveParser.WebAPI.Routes;
+
+public abstract class RouteHandlerBase : IRouteHandler
+{
+    protected readonly CancellationToken _cancelAllToken;
+    
+    protected RouteHandlerBase(CancellationToken cancelAllToken)
+    {
+        _cancelAllToken = cancelAllToken;
+    }
+
+    public abstract Task<HttpStatusCode> HandleRequest(HttpListenerContext ctx, ContextLogger requestLogger);
+}

ParadoxSaveParser.WebAPI/Routes/UploadSaveHandler.cs

@@ -0,0 +1,56 @@
+using System.Linq;
+using System.Net;
+using ParadoxSaveParser.WebAPI.BackgroundTasks;
+using ParadoxSaveParser.WebAPI.Database;
+using ParadoxSaveParser.WebAPI.HttpHelpers;
+using ParadoxSaveParser.WebAPI.SaveDataFilters;
+
+namespace ParadoxSaveParser.WebAPI.Routes;
+
+public class UploadSaveHandler : RouteHandlerBase
+{
+    private readonly BackgroundJobManager _bgJobManager;
+    private readonly Dictionary<Game, ISaveDataFilter> _saveFilters;
+
+    public UploadSaveHandler(
+        CancellationToken cancelAllToken, 
+        BackgroundJobManager bgJobManager,
+        Dictionary<Game, ISaveDataFilter> saveFilters) 
+        : base(cancelAllToken)
+    {
+        _bgJobManager = bgJobManager;
+        _saveFilters = saveFilters;
+    }
+
+    public override async Task<HttpStatusCode> HandleRequest(
+        HttpListenerContext ctx, ContextLogger requestLogger)
+    {
+        string? contentType = ctx.Request.Headers.GetValues("Content-Type")?.FirstOrDefault();
+        if (contentType != "application/octet-stream")
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
+                    new ErrorMessage(HttpStatusCode.BadRequest,
+                $"Invalid request Content-Type: '{contentType}'"));
+
+        var gameStrOrError = RequestHelper.GetQueryValue(ctx, "game");
+        if (gameStrOrError.HasError)
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, gameStrOrError.Error!);
+
+        if (!Enum.TryParse(gameStrOrError.Value, ignoreCase: true, out Game game))
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
+                new ErrorMessage(HttpStatusCode.BadRequest,
+                    $"Invalid requested game: '{gameStrOrError.Value}'"));  
+        var meta = await Program.DB.CreateMetadata(game);
+
+        var saveFilePath = meta.GetSaveFilePath();
+        await using (var saveFile = File.OpenWrite(saveFilePath))
+        {
+            await using (var remoteStream = ctx.Request.InputStream)
+                await remoteStream.CopyToAsync(saveFile, _cancelAllToken);
+        }
+        await Program.DB.UpdateMetadataStatus(meta, SaveFileProcessingStatus.Uploaded);
+
+        _bgJobManager.StartNewParsingOperation(meta, _saveFilters[meta.game], _cancelAllToken);
+        dynamic responseData = new { meta.id };
+        return await ReturnHelper.ResponseJson(ctx, requestLogger, _cancelAllToken, responseData);
+    }
+}

ParadoxSaveParser.WebAPI/SaveDataFilters/ISaveDataFilter.cs

@@ -0,0 +1,9 @@
+namespace ParadoxSaveParser.WebAPI.SaveDataFilters;
+
+public interface ISaveDataFilter
+{
+    public string SearchString { get; }
+    public ISearchExpression SearchExpression { get; }
+    
+    public void Apply(Dictionary<string, object> data);
+}

ParadoxSaveParser.WebAPI/SaveDataFilters/SaveFilterEU4.cs

@@ -0,0 +1,48 @@
+using System.Linq;
+using ParsedDict = System.Collections.Generic.Dictionary<string, object>;
+
+namespace ParadoxSaveParser.WebAPI.SaveDataFilters;
+
+public class SaveDataFilterEU4 : ISaveDataFilter
+{
+    public string SearchString { get; }
+    public ISearchExpression SearchExpression { get; }
+    
+    public SaveDataFilterEU4()
+    {
+        SearchString =
+            """
+            (
+                active_war|
+                previous_war|
+                income_statistics|
+                nation_size_statistics|
+                inflation_statistics|
+                countries.(
+                    ---.~|REB.~|PIR.~|NAT.~|
+                    *.(
+                        flags.~|hidden_flags.~|variables.~|estate.~|active_agenda.~|
+                        power_projection.~|ai.~|history.~|navy.~|army.~|mercenary_company.~|
+                        active_relations.~|border_pct.~|border_sit.~|border_provinces.~|
+                        neighbours.~|home_neighbours.~|core_neighbours.~|inflation_history.~|
+                        opinion_cache.~|owned_provinces.~|controlled_provinces.~|core_provinces.~|
+                        claim_provinces.~|leader.~|*
+                    )
+                )
+            )
+            """
+            .Replace("\r", "").Replace("\n", "").Replace("\t", "").Replace(" ", "");
+        SearchExpression = SearchExpressionCompiler.Compile(SearchString);
+    }
+
+    
+    public void Apply(ParsedDict data)
+    {
+        var countries = (ParsedDict)data["countries"];
+        var countries_filtered = countries.Where(pair 
+            => ((ParsedDict)pair.Value).TryGetValue("raw_development", out var raw_development)
+               && (double)raw_development > 0
+            ).ToDictionary();
+        data["countries"] = countries_filtered;
+    }
+}

ParadoxSaveParser.WebAPI/SaveDataFilters/data_filtering_EU4.txt

@@ -0,0 +1,43 @@
+countries
+	filter:
+		always: exists (has raw_development && raw_development != 0)
+		optional: is player (was_player == yes)
+	exclude:
+		flags
+		hidden_flags
+		variables
+		estate
+		active_agenda
+		power_projection
+		ai
+		history
+		navy
+		army
+		mercenary_company
+		active_relations
+		border_pct
+		border_sit
+		border_provinces
+		neighbours
+		home_neighbours
+		core_neighbours
+		inflation_history
+		opinion_cache
+		owned_provinces
+		controlled_provinces
+		core_provinces
+		claim_provinces
+		leader
+	query:
+		countries.(---.~|REB.~|PIR.~|NAT.~|*.(flags.~|hidden_flags.~|variables.~|estate.~|active_agenda.~|power_projection.~|ai.~|history.~|navy.~|army.~|mercenary_company.~|active_relations.~|border_pct.~|border_sit.~|border_provinces.~|neighbours.~|home_neighbours.~|core_neighbours.~|inflation_history.~|opinion_cache.~|owned_provinces.~|controlled_provinces.~|core_provinces.~|claim_provinces.~|leader.~|*))
+
+active_war
+	filter:
+		optional: only player wars
+previous_war
+	filter:
+		optional: only player wars
+		always: not fictive (has losses and lasts long)
+income_statistics
+nation_size_statistics
+inflation_statistics

ParadoxSaveParser.WebAPI/SaveFileMetadata.cs

@@ -1,37 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace ParadoxSaveParser.WebAPI;
-
-public enum SaveFileProcessingStatus
-{
-    Initialized,
-    Uploading,
-    Uploaded,
-    Parsing,
-    SavingResults,
-    Done
-}
-
-public enum Game
-{
-    Unknown,
-    EU4
-}
-
-public class SaveFileMetadata
-{
-    private static readonly JsonSerializerOptions _jsonOptions = new() { WriteIndented = true };
-    public required string id { get; init; }
-
-    [JsonConverter(typeof(JsonStringEnumConverter))]
-    public required Game game { get; init; }
-
-    [JsonConverter(typeof(JsonStringEnumConverter))]
-    public required SaveFileProcessingStatus status { get; set; }
-
-    public void SaveToFile()
-    {
-        using var metaFile = File.OpenWrite(PathHelper.GetMetaFilePath(id));
-        JsonSerializer.Serialize(metaFile, this, _jsonOptions);
-    }
-}

ParadoxSaveParser.sln

@@ -7,11 +7,14 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "SolutionFolder", "SolutionFolder", "{F1D312F1-0620-4E35-8D78-9A2808CDE12C}"
 	ProjectSection(SolutionItems) = preProject
 		.gitignore = .gitignore
-		TODO.txt = TODO.txt
+		TODO.md = TODO.md
+		README.md = README.md
 	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ParadoxSaveParser.Lib.Tests", "ParadoxSaveParser.Lib.Tests\ParadoxSaveParser.Lib.Tests.csproj", "{23F4BE1B-3043-4821-9F65-74FF5F57FA59}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ParadoxSaveParser.CLI", "ParadoxSaveParser.CLI\ParadoxSaveParser.CLI.csproj", "{2D4448A6-390D-47F3-9BB7-6266669719DE}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -30,5 +33,9 @@ Global
 		{23F4BE1B-3043-4821-9F65-74FF5F57FA59}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{23F4BE1B-3043-4821-9F65-74FF5F57FA59}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{23F4BE1B-3043-4821-9F65-74FF5F57FA59}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2D4448A6-390D-47F3-9BB7-6266669719DE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2D4448A6-390D-47F3-9BB7-6266669719DE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2D4448A6-390D-47F3-9BB7-6266669719DE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2D4448A6-390D-47F3-9BB7-6266669719DE}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

README.md

@@ -0,0 +1,18 @@
+# Paradox Save Parser
+Yet another save files parser. 
+
+## Supported games:
+- EU4
+
+## Project structure
+- **[ParadoxSaveParser.Lib](./ParadoxSaveParser.Lib)** - 
+    Parser itself
+- **[ParadoxSaveParser.Lib.Tests](./ParadoxSaveParser.Lib.Tests)** - 
+    Tests for parser
+- **[ParadoxSaveParser.CLI](./ParadoxSaveParser.CLI)** - 
+    Command line tool to parse save files. Can be used in interactive mode.
+- **[ParadoxSaveParser.WebAPI](./ParadoxSaveParser.WebAPI)** - 
+    Backend for my save file analytics website (TODO: add repo link).
+
+## Building
+1. Install protobuf compiler https://protobuf.dev/installation/

TODO.md

@@ -0,0 +1,4 @@
+## WebAPI.SaveParsingOperation:
+	Save parsed data in protobuf
+	Re-parse if saved data was parsed with another query
+    Implement automatic database cleanup

TODO.txt

@@ -1,11 +0,0 @@
-Main:
-	Add temporary files deletion
-
-ParseSaveHandler:
-	Make this method run as background task instead of POST query
-	Add debug log
-	Save parsed in protobuf
-	Re-parse if saved data was parsed with another query
-	
-Parser:
-	Optimize it (5 sec per query isn't good)