ParadoxSaveParser/ParadoxSaveParser.WebAPI/Program.cs

global using System;
global using System.IO;
global using System.Collections.Generic;
global using System.Text;
global using System.Text.Json;
global using System.Threading.Tasks;
global using DTLib.Demystifier;
global using ParadoxSaveParser.Lib;
using System.Collections.Concurrent;
using System.IO.Compression;
using System.Linq;
using System.Text.Encodings.Web;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace ParadoxSaveParser.WebAPI;

public class Program
{
    private static ConcurrentDictionary<string, SaveFileMetadata> _saveMetadataStorage = new();
    private static WebApplication _app = null!;

    private static JsonSerializerOptions _saveSerializerOptions = new()
    {
        WriteIndented = false,
        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
        MaxDepth = 1024,
    };

    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        _app = builder.Build();

        Directory.CreateDirectory(PathHelper.DATA_DIR);
        Directory.CreateDirectory(PathHelper.SAVES_DIR);
        foreach (var metaFilePath in Directory.GetFiles(PathHelper.SAVES_DIR, "*.meta.json", SearchOption.TopDirectoryOnly))
        {
            using var metaFile = File.Open(metaFilePath, FileMode.Open, FileAccess.Read);
            var meta = JsonSerializer.Deserialize<SaveFileMetadata>(metaFile) ?? throw new NullReferenceException(metaFilePath);
            if (meta.status != SaveFileProcessingStatus.Done)
            {
                _app.Logger.Log(LogLevel.Warning, "metadata file '{metaFilePath}' status has invalid status {status}", metaFilePath, meta.status);
            }

            if(!_saveMetadataStorage.TryAdd(meta.id, meta))
                throw new Exception("Guid collision!");
        }
        
        _app.UseHttpsRedirection();
        _app.MapGet("/getSaveStatus", GetSaveStatusHandler);
        _app.MapPost("/uploadSave/eu4", UploadSaveHandler);
        _app.MapPost("/parseSave/eu4", ParseSaveEU4Handler);
        _app.Run();
    }

    private static async Task UploadSaveHandler(HttpContext httpContext)
    {
        var remoteFile = httpContext.Request.Form.Files.FirstOrDefault();
        if (remoteFile is null || !remoteFile.FileName.EndsWith(".eu4"))
        {
            throw new BadHttpRequestException($"Invalid file format: {remoteFile?.FileName}",
                StatusCodes.Status400BadRequest);
        }

        string saveId = Guid.NewGuid().ToString();
        string metaFilePath = PathHelper.GetMetaFilePath(saveId);
        if (File.Exists(metaFilePath))
        {
            httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
            throw new BadHttpRequestException($"Guid collision! file {metaFilePath} already exists.", StatusCodes.Status500InternalServerError);
        }

        var meta = new SaveFileMetadata { id = saveId, game = Game.EU4, status = SaveFileProcessingStatus.Initialized, };
        if (!_saveMetadataStorage.TryAdd(saveId, meta))
        {
            throw new BadHttpRequestException($"Guid collision! Can't create metadata with id {saveId}", StatusCodes.Status500InternalServerError);
        }

        meta.status = SaveFileProcessingStatus.Uploading;
        string saveFilePath = PathHelper.GetSaveFilePath(meta.id);
        await using var saveFile = File.Open(saveFilePath, FileMode.CreateNew, FileAccess.ReadWrite);
        await using var remoteStream = remoteFile.OpenReadStream();
        await remoteStream.CopyToAsync(saveFile);
        meta.status = SaveFileProcessingStatus.Uploaded;
        
        await httpContext.Response.WriteAsJsonAsync(meta);
    }

    private static SaveFileMetadata GetMetaFromRequestId(HttpContext httpContext, string requestParamName)
    {
        httpContext.Request.Query.TryGetValue(requestParamName, out var ids);
        string? id = ids.FirstOrDefault();
        if (string.IsNullOrEmpty(id))
        {
            throw new BadHttpRequestException($"No request parameter '{requestParamName}' provided", 
                StatusCodes.Status400BadRequest);
        }

        if (!_saveMetadataStorage.TryGetValue(id, out var meta))
        {
            throw new BadHttpRequestException($"Save with {id} not found", 
                StatusCodes.Status400BadRequest);
        }

        return meta;
    }
    
    private static async Task GetSaveStatusHandler(HttpContext httpContext)
    {
        var meta = GetMetaFromRequestId(httpContext, "id");
        await httpContext.Response.WriteAsJsonAsync(meta);
    }

    private static async Task ParseSaveEU4Handler(HttpContext httpContext)
    {
        var meta = GetMetaFromRequestId(httpContext, "id");
        if (meta.status == SaveFileProcessingStatus.Error)
        {
            httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
            await httpContext.Response.WriteAsJsonAsync(meta);
            return;
        }
        
        try
        {
            if (meta.status != SaveFileProcessingStatus.Uploaded)
                throw new Exception($"Invalid save processing status: {meta.status}");

            using var zipArchive = ZipFile.Open(PathHelper.GetSaveFilePath(meta.id), 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");
            string extractedGamestatePath = PathHelper.GetSaveFilePath(meta.id) + ".gamestate";
            zipEntry.ExtractToFile(extractedGamestatePath);
            var gamestateStream = File.Open(extractedGamestatePath, FileMode.Open, FileAccess.Read);

            meta.status = SaveFileProcessingStatus.Parsing;
            var parser = new Parser(gamestateStream);
            var result = parser.Parse();

            meta.status = SaveFileProcessingStatus.SavingResults;
            string resultFilePath = PathHelper.GetParsedSaveFilePath(meta.id);
            await using var resultFile = File.Open(resultFilePath, FileMode.CreateNew, FileAccess.Write);
            await JsonSerializer.SerializeAsync(resultFile, result, _saveSerializerOptions);
            meta.status = SaveFileProcessingStatus.Done;
            meta.SaveToFile();
        }
        catch (Exception ex)
        {
            meta.status = SaveFileProcessingStatus.Error;
            string errorMesage = ex.ToStringDemystified();
            meta.errorMesage = errorMesage;
            httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
            _app.Logger.Log(LogLevel.Error, "ParseSaveEU4 Error: {errorMesage}", errorMesage);
        }

        await httpContext.Response.WriteAsJsonAsync(meta);
    }
}