ParadoxSaveParser/ParadoxSaveParser.WebAPI/Program.Responses.cs

using System.IO.Compression;
using System.Linq;
using System.Net;
using DTLib.Extensions;

namespace ParadoxSaveParser.WebAPI;

public partial class Program
{
    // ReSharper disable once NotAccessedPositionalProperty.Global
    public record ErrorMessage(string errorMessage);

    private static async Task<HttpStatusCode> ReturnResponse(HttpListenerContext ctx, HttpStatusCode statusCode,
        object response)
    {
        await JsonSerializer.SerializeAsync(ctx.Response.OutputStream, response, response.GetType(),
            JsonSerializerOptions.Default, _mainCancel.Token);
        ctx.Response.StatusCode = (int)statusCode;
        return statusCode;
    }

    private static async Task<HttpStatusCode> ReturnResponse(HttpListenerContext ctx, HttpStatusCode statusCode,
        string response)
    {
        await ctx.Response.OutputStream.WriteAsync(response.ToBytes(), _mainCancel.Token);
        ctx.Response.StatusCode = (int)statusCode;
        return statusCode;
    }

    private static async Task<HttpStatusCode> UploadSaveHandler(HttpListenerContext ctx)
    {
        string? contentType = ctx.Request.Headers.GetValues("Content-Type")?.FirstOrDefault();
        if (contentType != "application/octet-stream")
            return await ReturnResponse(ctx, HttpStatusCode.BadRequest,
                new ErrorMessage($"Invalid request Content-Type: '{contentType}'"));

        string saveId = Guid.NewGuid().ToString();
        IOPath metaFilePath = PathHelper.GetMetaFilePath(saveId);
        if (File.Exists(metaFilePath))
            return await ReturnResponse(ctx, HttpStatusCode.InternalServerError,
                new ErrorMessage($"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 ReturnResponse(ctx, HttpStatusCode.InternalServerError,
                new ErrorMessage($"Guid collision! Can't create metadata with id {saveId}"));

        meta.status = SaveFileProcessingStatus.Uploading;
        IOPath 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 ReturnResponse(ctx, HttpStatusCode.OK, saveId);
    }

    private static (SaveFileMetadata? meta, ErrorMessage? errorMesage) GetMetaFromRequestId(HttpListenerContext ctx,
        string requestParamName)
    {
        var ids = ctx.Request.QueryString.GetValues(requestParamName);
        string? id = ids?.FirstOrDefault();
        if (string.IsNullOrEmpty(id))
            return (null, new ErrorMessage($"No request parameter '{requestParamName}' provided"));

        if (!_saveMetadataStorage.TryGetValue(id, out var meta))
            return (null, new ErrorMessage($"Save with {id} not found"));

        return (meta, null);
    }

    private static async Task<HttpStatusCode> GetSaveStatusHandler(HttpListenerContext ctx)
    {
        var (meta, errorMessage) = GetMetaFromRequestId(ctx, "id");
        if (errorMessage is not null)
            return await ReturnResponse(ctx, HttpStatusCode.InternalServerError, errorMessage);

        return await ReturnResponse(ctx, HttpStatusCode.OK, meta!);
    }

    private static async Task<HttpStatusCode> ParseSaveEU4Handler(HttpListenerContext ctx)
    {
        var (meta, errorMessage) = GetMetaFromRequestId(ctx, "id");
        if (errorMessage is not null)
            return await ReturnResponse(ctx, HttpStatusCode.InternalServerError, errorMessage);

        //TODO: get actual query
        string searchQuery = "";
        
        try
        {
            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 ReturnResponse(ctx, HttpStatusCode.BadRequest,
                    new ErrorMessage("Invalid save format: no 'gamestate' file found"));

            string extractedGamestatePath = PathHelper.GetSaveFilePath(meta.id) + ".gamestate";
            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;
            IOPath 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 ReturnResponse(ctx, HttpStatusCode.BadRequest,
                new ErrorMessage(errorMesage));
        }

        return await ReturnResponse(ctx, HttpStatusCode.OK, meta);
    }
}