Program.cs

using System.IO.Compression;
using System.Net;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;

internal static class Program
{
    private const string DefaultBaseUrl = "http://127.0.0.1:7071";
    private const string DefaultRoutePrefix = "api";

    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        WriteIndented = true,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
    };

    public static async Task<int> Main(string[] args)
    {
        try
        {
            var parsed = CliArgs.Parse(args);
            var command = parsed.Command ?? "execute";

            return command switch
            {
                "execute" => await ExecuteAsync(parsed),
                "get-title-token" => await GetTitleTokenAsync(parsed),
                "login-custom-id" => await LoginCustomIdAsync(parsed),
                "help" or "--help" or "-h" => PrintHelpAndReturn(),
                _ => ExitWithError($"Unknown command: {command}")
            };
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"[playfab-mini-client] {ex.Message}");
            return 1;
        }
    }

    private static int PrintHelpAndReturn()
    {
        Console.WriteLine("""
PlayFabMiniClient

Commands:
  execute            Executes local CloudScript/ExecuteFunction endpoint.
  get-title-token    Gets a title entity token using --title-id and --dev-secret-key.
  login-custom-id    Logs into PlayFab Client API and returns entity token + entity key.

Common Execute Options:
  --function <name>                  Function name to invoke. Required.
  --parameter-json <json>            FunctionParameter JSON. Default: {}
  --base-url <url>                   Local host base URL. Default: http://127.0.0.1:7071
  --route-prefix <prefix>            Route prefix used by local functions host. Default: api
  --title-id <id>                    PlayFab title ID (required for PlayFab API calls)
  --dev-secret-key <key>             PlayFab secret key (required for get-title-token and --auth title)
  --cloud-name <name>                PlayFab cloud segment for host (<title>.<cloud>.playfabapi.com)
  --entity-token <token>             X-EntityToken header value
  --entity-id <id>                   ExecuteFunctionRequest.Entity.Id
  --entity-type <type>               ExecuteFunctionRequest.Entity.Type
  --auth <none|title|player-custom-id>  Auth mode. Default: none
  --custom-id <id>                   Required when --auth player-custom-id
  --create-account <true|false>      LoginWithCustomID CreateAccount. Default: true
  --gzip-body                         Gzip request body and set Content-Encoding: gzip
  --accept-gzip <true|false>         Send Accept-Encoding: gzip header. Default: true
  --expect-http-status <code>        Assert HTTP status code. Default: 200
  --expect-function-result-json <json> Assert data.FunctionResult exact JSON equality
  --output <path>                    Write raw response body to file

Required args for PlayFab auth/API calls:
  --title-id
  --dev-secret-key (title token only)
""");
        return 0;
    }

    private static async Task<int> ExecuteAsync(CliArgs args)
    {
        var functionName = args.Get("function");
        if (string.IsNullOrWhiteSpace(functionName))
        {
            return ExitWithError("Missing --function");
        }

        var baseUrl = args.Get("base-url") ?? DefaultBaseUrl;
        var routePrefix = args.Get("route-prefix") ?? DefaultRoutePrefix;
        var parameterJson = args.Get("parameter-json") ?? "{}";
        var authMode = (args.Get("auth") ?? "none").Trim().ToLowerInvariant();
        var expectHttpStatus = args.GetInt("expect-http-status") ?? 200;
        var expectResultJson = args.Get("expect-function-result-json");
        var outputPath = args.Get("output");
        var titleId = args.Get("title-id");
        var devSecretKey = args.Get("dev-secret-key");
        var cloudName = args.Get("cloud-name");

        var acceptGzip = args.GetBool("accept-gzip", defaultValue: true);
        var gzipBody = args.HasFlag("gzip-body");

        var entityToken = args.Get("entity-token");
        var entityId = args.Get("entity-id");
        var entityType = args.Get("entity-type");

        using var http = CreateHttpClient();

        if (authMode == "title")
        {
            titleId = RequireOption(titleId, "title-id", "--auth title");
            devSecretKey = RequireOption(devSecretKey, "dev-secret-key", "--auth title");
            entityToken = await FetchTitleEntityTokenAsync(http, titleId, devSecretKey, cloudName);
        }
        else if (authMode == "player-custom-id")
        {
            var customId = args.Get("custom-id");
            if (string.IsNullOrWhiteSpace(customId))
            {
                return ExitWithError("--custom-id is required when --auth player-custom-id");
            }

            titleId = RequireOption(titleId, "title-id", "--auth player-custom-id");
            var createAccount = args.GetBool("create-account", defaultValue: true);
            var login = await LoginWithCustomIdInternalAsync(http, titleId, cloudName, customId, createAccount);
            entityToken = login.EntityToken;
            entityId = login.Entity?.Id;
            entityType = login.Entity?.Type;
        }
        else if (authMode != "none")
        {
            return ExitWithError("--auth must be one of: none, title, player-custom-id");
        }

        var executePayload = new ExecuteFunctionRequest
        {
            FunctionName = functionName,
            FunctionParameter = ParseJsonToElement(parameterJson),
            Entity = string.IsNullOrWhiteSpace(entityId) || string.IsNullOrWhiteSpace(entityType)
                ? null
                : new EntityKey { Id = entityId, Type = entityType }
        };

        var endpoint = BuildLocalExecuteFunctionEndpoint(baseUrl, routePrefix);
        var payloadBytes = JsonSerializer.SerializeToUtf8Bytes(executePayload, JsonOptions);

        using var request = new HttpRequestMessage(HttpMethod.Post, endpoint);

        if (acceptGzip)
        {
            request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
        }

        if (!string.IsNullOrWhiteSpace(entityToken))
        {
            request.Headers.TryAddWithoutValidation("X-EntityToken", entityToken);
        }

        if (gzipBody)
        {
            payloadBytes = Gzip(payloadBytes);
            request.Content = new ByteArrayContent(payloadBytes);
            request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            request.Content.Headers.ContentEncoding.Add("gzip");
        }
        else
        {
            request.Content = new ByteArrayContent(payloadBytes);
            request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
        }

        using var response = await http.SendAsync(request);
        var rawBody = await response.Content.ReadAsStringAsync();

        if (!string.IsNullOrWhiteSpace(outputPath))
        {
            Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(outputPath))!);
            await File.WriteAllTextAsync(outputPath, rawBody, Encoding.UTF8);
        }

        if ((int)response.StatusCode != expectHttpStatus)
        {
            Console.Error.WriteLine(rawBody);
            return ExitWithError($"HTTP status assertion failed. Expected {expectHttpStatus}, got {(int)response.StatusCode}");
        }

        Console.WriteLine(rawBody);

        if (!string.IsNullOrWhiteSpace(expectResultJson))
        {
            var expectedNode = JsonNode.Parse(expectResultJson);
            var envelope = JsonSerializer.Deserialize<PlayFabEnvelope<ExecuteFunctionResult>>(rawBody, JsonOptions)
                ?? throw new InvalidOperationException("Failed to deserialize ExecuteFunction response envelope.");

            var actualNode = envelope.Data?.FunctionResult is null
                ? null
                : JsonNode.Parse(envelope.Data.FunctionResult.Value.GetRawText());

            if (!JsonNode.DeepEquals(expectedNode, actualNode))
            {
                return ExitWithError("FunctionResult assertion failed (JSON not equal).");
            }
        }

        return 0;
    }

    private static async Task<int> GetTitleTokenAsync(CliArgs args)
    {
        var titleId = RequireOption(args.Get("title-id"), "title-id", "get-title-token");
        var devSecretKey = RequireOption(args.Get("dev-secret-key"), "dev-secret-key", "get-title-token");
        var cloudName = args.Get("cloud-name");

        using var http = CreateHttpClient();
        var token = await FetchTitleEntityTokenAsync(http, titleId, devSecretKey, cloudName);

        var asJson = args.GetBool("json", defaultValue: false);
        if (asJson)
        {
            Console.WriteLine(JsonSerializer.Serialize(new { entityToken = token }, JsonOptions));
        }
        else
        {
            Console.WriteLine(token);
        }

        return 0;
    }

    private static async Task<int> LoginCustomIdAsync(CliArgs args)
    {
        var titleId = RequireOption(args.Get("title-id"), "title-id", "login-custom-id");
        var cloudName = args.Get("cloud-name");
        var customId = args.Get("custom-id");
        if (string.IsNullOrWhiteSpace(customId))
        {
            return ExitWithError("Missing --custom-id");
        }

        var createAccount = args.GetBool("create-account", defaultValue: true);

        using var http = CreateHttpClient();
        var login = await LoginWithCustomIdInternalAsync(http, titleId, cloudName, customId, createAccount);

        Console.WriteLine(JsonSerializer.Serialize(login, JsonOptions));
        return 0;
    }

    private static HttpClient CreateHttpClient()
    {
        var handler = new HttpClientHandler
        {
            AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
        };

        return new HttpClient(handler)
        {
            Timeout = TimeSpan.FromSeconds(60)
        };
    }

    private static string BuildLocalExecuteFunctionEndpoint(string baseUrl, string routePrefix)
    {
        var trimmedBase = baseUrl.TrimEnd('/');
        var trimmedPrefix = routePrefix.Trim('/');
        return string.IsNullOrWhiteSpace(trimmedPrefix)
            ? $"{trimmedBase}/CloudScript/ExecuteFunction"
            : $"{trimmedBase}/{trimmedPrefix}/CloudScript/ExecuteFunction";
    }

    private static JsonElement ParseJsonToElement(string json)
    {
        using var doc = JsonDocument.Parse(json);
        return doc.RootElement.Clone();
    }

    private static byte[] Gzip(byte[] bytes)
    {
        using var output = new MemoryStream();
        using (var gzip = new GZipStream(output, CompressionLevel.Fastest, leaveOpen: true))
        {
            gzip.Write(bytes, 0, bytes.Length);
        }

        return output.ToArray();
    }

    private static async Task<string> FetchTitleEntityTokenAsync(HttpClient http, string titleId, string devSecretKey, string? cloudName)
    {
        var endpoint = BuildPlayFabEndpoint(titleId, cloudName, "/Authentication/GetEntityToken");
        var body = "{}";

        using var request = new HttpRequestMessage(HttpMethod.Post, endpoint)
        {
            Content = new StringContent(body, Encoding.UTF8, "application/json")
        };
        request.Headers.TryAddWithoutValidation("X-SecretKey", devSecretKey);

        using var response = await http.SendAsync(request);
        var content = await response.Content.ReadAsStringAsync();

        var envelope = JsonSerializer.Deserialize<PlayFabEnvelope<GetEntityTokenData>>(content, JsonOptions)
            ?? throw new InvalidOperationException("Could not deserialize GetEntityToken response.");

        if (envelope.Data?.EntityToken is null)
        {
            throw new InvalidOperationException($"GetEntityToken failed. Status={envelope.Status}, Code={envelope.Code}, Body={content}");
        }

        return envelope.Data.EntityToken;
    }

    private static async Task<LoginCustomIdResult> LoginWithCustomIdInternalAsync(HttpClient http, string titleId, string? cloudName, string customId, bool createAccount)
    {
        var endpoint = BuildPlayFabEndpoint(titleId, cloudName, "/Client/LoginWithCustomID");

        var loginRequest = new
        {
            TitleId = titleId,
            CustomId = customId,
            CreateAccount = createAccount,
            InfoRequestParameters = new { GetPlayerProfile = true }
        };

        using var request = new HttpRequestMessage(HttpMethod.Post, endpoint)
        {
            Content = new StringContent(JsonSerializer.Serialize(loginRequest, JsonOptions), Encoding.UTF8, "application/json")
        };

        using var response = await http.SendAsync(request);
        var content = await response.Content.ReadAsStringAsync();

        var envelope = JsonSerializer.Deserialize<PlayFabEnvelope<LoginWithCustomIdData>>(content, JsonOptions)
            ?? throw new InvalidOperationException("Could not deserialize LoginWithCustomID response.");

        if (envelope.Data?.EntityToken?.EntityToken is null)
        {
            throw new InvalidOperationException($"LoginWithCustomID failed. Status={envelope.Status}, Code={envelope.Code}, Body={content}");
        }

        return new LoginCustomIdResult
        {
            PlayFabId = envelope.Data.PlayFabId,
            SessionTicket = envelope.Data.SessionTicket,
            EntityToken = envelope.Data.EntityToken.EntityToken,
            Entity = envelope.Data.EntityToken.Entity
        };
    }

    private static string BuildPlayFabEndpoint(string titleId, string? cloudName, string endpoint)
    {
        var hostBuilder = new StringBuilder();
        hostBuilder.Append(titleId).Append('.');
        if (!string.IsNullOrWhiteSpace(cloudName))
        {
            hostBuilder.Append(cloudName).Append('.');
        }
        hostBuilder.Append("playfabapi.com");

        return $"https://{hostBuilder}{endpoint}";
    }

    private static int ExitWithError(string message)
    {
        Console.Error.WriteLine($"[playfab-mini-client] {message}");
        return 1;
    }

    private static string RequireOption(string? value, string optionName, string context)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            throw new InvalidOperationException($"Missing --{optionName} for {context}.");
        }

        return value;
    }
}

internal sealed class CliArgs
{
    private readonly Dictionary<string, string?> _options;

    public string? Command { get; }

    private CliArgs(string? command, Dictionary<string, string?> options)
    {
        Command = command;
        _options = options;
    }

    public static CliArgs Parse(string[] args)
    {
        string? command = null;
        var options = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

        for (var i = 0; i < args.Length; i++)
        {
            var token = args[i];

            if (!token.StartsWith("--", StringComparison.Ordinal))
            {
                if (command is null)
                {
                    command = token;
                }
                else
                {
                    throw new InvalidOperationException($"Unexpected positional argument: {token}");
                }
                continue;
            }

            var withoutPrefix = token[2..];
            var eqIndex = withoutPrefix.IndexOf('=');

            if (eqIndex >= 0)
            {
                var key = withoutPrefix[..eqIndex];
                var value = withoutPrefix[(eqIndex + 1)..];
                options[key] = value;
                continue;
            }

            if (i + 1 < args.Length && !args[i + 1].StartsWith("--", StringComparison.Ordinal))
            {
                options[withoutPrefix] = args[i + 1];
                i++;
            }
            else
            {
                options[withoutPrefix] = "true";
            }
        }

        return new CliArgs(command, options);
    }

    public string? Get(string key)
    {
        return _options.TryGetValue(key, out var value) ? value : null;
    }

    public bool HasFlag(string key)
    {
        return GetBool(key, defaultValue: false);
    }

    public bool GetBool(string key, bool defaultValue)
    {
        var value = Get(key);
        if (value is null)
        {
            return defaultValue;
        }

        if (bool.TryParse(value, out var parsed))
        {
            return parsed;
        }

        if (value == "1")
        {
            return true;
        }

        if (value == "0")
        {
            return false;
        }

        throw new InvalidOperationException($"Option --{key} must be a boolean (true/false).");
    }

    public int? GetInt(string key)
    {
        var value = Get(key);
        if (value is null)
        {
            return null;
        }

        if (int.TryParse(value, out var parsed))
        {
            return parsed;
        }

        throw new InvalidOperationException($"Option --{key} must be an integer.");
    }
}

internal sealed class EntityKey
{
    public string? Id { get; set; }
    public string? Type { get; set; }
}

internal sealed class ExecuteFunctionRequest
{
    public EntityKey? Entity { get; set; }
    public string? FunctionName { get; set; }
    public JsonElement FunctionParameter { get; set; }
    public bool? GeneratePlayStreamEvent { get; set; }
}

internal sealed class ExecuteFunctionResult
{
    public int ExecutionTimeMilliseconds { get; set; }
    public string? FunctionName { get; set; }
    public JsonElement? FunctionResult { get; set; }
    public bool? FunctionResultTooLarge { get; set; }
}

internal sealed class PlayFabEnvelope<T>
{
    [JsonPropertyName("code")]
    public int Code { get; set; }

    [JsonPropertyName("status")]
    public string? Status { get; set; }

    [JsonPropertyName("data")]
    public T? Data { get; set; }

    [JsonPropertyName("error")]
    public string? Error { get; set; }

    [JsonPropertyName("errorMessage")]
    public string? ErrorMessage { get; set; }
}

internal sealed class GetEntityTokenData
{
    public string? EntityToken { get; set; }
}

internal sealed class LoginWithCustomIdData
{
    public string? PlayFabId { get; set; }
    public string? SessionTicket { get; set; }
    public EntityTokenResult? EntityToken { get; set; }
}

internal sealed class EntityTokenResult
{
    public string? EntityToken { get; set; }
    public EntityKey? Entity { get; set; }
}

internal sealed class LoginCustomIdResult
{
    public string? PlayFabId { get; set; }
    public string? SessionTicket { get; set; }
    public string? EntityToken { get; set; }
    public EntityKey? Entity { get; set; }
}