ScadaBridge/src/ZB.MOM.WW.ScadaBridge.CLI/Commands/DeployCommands.cs

using System.CommandLine;
using System.CommandLine.Parsing;
using System.Text.Json;
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;

namespace ZB.MOM.WW.ScadaBridge.CLI.Commands;

public static class DeployCommands
{
    /// <summary>
    /// Builds the <c>deploy</c> command group with all sub-commands.
    /// </summary>
    /// <param name="urlOption">Global management URL option.</param>
    /// <param name="formatOption">Global output format option.</param>
    /// <param name="usernameOption">Global username option.</param>
    /// <param name="passwordOption">Global password option.</param>
    /// <returns>The configured <c>deploy</c> <see cref="Command"/> with all sub-commands attached.</returns>
    public static Command Build(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var command = new Command("deploy") { Description = "Deployment operations" };

        command.Add(BuildInstance(urlOption, formatOption, usernameOption, passwordOption));
        command.Add(BuildSite(urlOption, formatOption, usernameOption, passwordOption));
        command.Add(BuildArtifacts(urlOption, formatOption, usernameOption, passwordOption));
        command.Add(BuildStatus(urlOption, formatOption, usernameOption, passwordOption));

        return command;
    }

    private static Command BuildInstance(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var idOption = new Option<int>("--id") { Description = "Instance ID", Required = true };
        var cmd = new Command("instance") { Description = "Deploy a single instance" };
        cmd.Add(idOption);
        cmd.SetAction(async (ParseResult result) =>
        {
            var id = result.GetValue(idOption);
            return await CommandHelpers.ExecuteCommandAsync(
                result, urlOption, formatOption, usernameOption, passwordOption, new MgmtDeployInstanceCommand(id));
        });
        return cmd;
    }

    /// <summary>
    /// Builds <c>deploy site</c> — bulk-deploy every instance at one site.
    ///
    /// <para>
    /// Sits under <c>deploy</c> alongside <c>deploy instance</c> and
    /// <c>deploy artifacts</c>, naming the SCOPE of the deploy as the verb, which
    /// is the convention the group already follows. Note it is deliberately NOT
    /// fleet-wide when <c>--site-id</c> is omitted (the pattern <c>deploy
    /// artifacts</c> uses): a bulk instance deploy is far more consequential than
    /// an artifact push, so the target site is required rather than defaulted.
    /// </para>
    /// </summary>
    private static Command BuildSite(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var siteIdOption = new Option<int>("--site-id") { Description = "Target site ID", Required = true };
        // A flag, not a value option: absent means the default (skip unchanged
        // instances), present means redeploy them. Disabled instances are skipped
        // either way — force is not an override for that.
        var forceOption = new Option<bool>("--force")
        {
            Description =
                "Redeploy instances whose config is unchanged (default: skip them — a redeploy " +
                "resets static overrides and native alarm state at the site)",
        };
        var cmd = new Command("site") { Description = "Deploy every deployable instance at a site" };
        cmd.Add(siteIdOption);
        cmd.Add(forceOption);
        cmd.SetAction(async (ParseResult result) =>
        {
            var siteId = result.GetValue(siteIdOption);
            var force = result.GetValue(forceOption);
            return await CommandHelpers.ExecuteCommandAsync(
                result, urlOption, formatOption, usernameOption, passwordOption,
                new MgmtDeploySiteCommand(siteId, force),
                // A bulk deploy is N instance round-trips; the default 30 s client
                // timeout would abandon the request while the server is still
                // applying. Matches the server-side long-running Ask window.
                timeout: BulkDeployTimeout,
                onSuccess: json => HandleSiteDeploymentResponse(json, CommandHelpers.ResolveFormat(result, formatOption, CliConfig.Load())));
        });
        return cmd;
    }

    /// <summary>
    /// The server owns the bounded overall bulk deadline; do not abandon it with a shorter client timer.
    /// </summary>
    internal static readonly TimeSpan BulkDeployTimeout = Timeout.InfiniteTimeSpan;

    /// <summary>
    /// Renders a deployment summary and turns its <c>failureCount</c> into the exit code:
    /// 0 when every site/instance succeeded, 1 when any failed. Shared by <c>deploy site</c>
    /// and both artifact-deploy commands (<c>deploy artifacts</c>, <c>site deploy-artifacts</c>),
    /// whose summaries all carry <c>failureCount</c> — a per-site failure is a successful HTTP
    /// call, so without this the process exited 0 and scripts could not detect it.
    /// </summary>
    /// <param name="json">The JSON response body from the management API.</param>
    /// <param name="format">The output format (e.g. json or table).</param>
    /// <param name="summaryName">Display name for the summary, used in the invalid-response error.</param>
    /// <returns>0 when nothing failed; 1 when any failure was reported or the summary was invalid.</returns>
    internal static int HandleSiteDeploymentResponse(string json, string format, string summaryName = "site deployment")
    {
        CommandHelpers.HandleResponse(new ManagementResponse(200, json, null, null), format);
        try
        {
            using var payload = JsonDocument.Parse(json);
            if (payload.RootElement.TryGetProperty("failureCount", out var failures)
                && failures.TryGetInt32(out var count) && count >= 0)
                return count == 0 ? 0 : 1;
        }
        catch (JsonException) { }
        OutputFormatter.WriteError($"The server returned an invalid {summaryName} summary.", "INVALID_RESPONSE");
        return 1;
    }

    private static Command BuildArtifacts(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var siteIdOption = new Option<int?>("--site-id") { Description = "Target site ID (all sites if omitted)" };
        var cmd = new Command("artifacts") { Description = "Deploy artifacts to site(s)" };
        cmd.Add(siteIdOption);
        cmd.SetAction(async (ParseResult result) =>
        {
            var siteId = result.GetValue(siteIdOption);
            return await CommandHelpers.ExecuteCommandAsync(
                result, urlOption, formatOption, usernameOption, passwordOption, new MgmtDeployArtifactsCommand(siteId),
                onSuccess: json => HandleSiteDeploymentResponse(
                    json, CommandHelpers.ResolveFormat(result, formatOption, CliConfig.Load()), "artifact deployment"));
        });
        return cmd;
    }

    private static Command BuildStatus(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var instanceIdOption = new Option<int?>("--instance-id") { Description = "Filter by instance ID" };
        // The valid set is named in the help text rather than enforced with
        // AcceptOnlyFromAmong: that check is case-SENSITIVE, and the server has
        // always accepted `--status success`. The server rejects an unrecognised
        // value with the same list (register row 88) and is the authoritative
        // check — HTTP API callers never pass through this option at all.
        var statusOption = new Option<string?>("--status")
        {
            Description = "Filter by status (Pending, InProgress, Success, Failed; case-insensitive)",
        };
        var pageOption = new Option<int>("--page") { Description = "Page number" };
        pageOption.DefaultValueFactory = _ => 1;
        var pageSizeOption = new Option<int>("--page-size") { Description = "Page size (1-1000; 0 or unset uses 50)" };
        pageSizeOption.DefaultValueFactory = _ => 50;

        var cmd = new Command("status") { Description = "Query deployment status" };
        cmd.Add(instanceIdOption);
        cmd.Add(statusOption);
        cmd.Add(pageOption);
        cmd.Add(pageSizeOption);
        cmd.SetAction(async (ParseResult result) =>
        {
            var instanceId = result.GetValue(instanceIdOption);
            var status = result.GetValue(statusOption);
            var page = result.GetValue(pageOption);
            var pageSize = result.GetValue(pageSizeOption);
            return await CommandHelpers.ExecuteCommandAsync(
                result, urlOption, formatOption, usernameOption, passwordOption,
                new QueryDeploymentsCommand(instanceId, status, page, pageSize),
                tableProjector: DeploymentStatusTableProjection.ProjectRows);
        });
        return cmd;
    }
}