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

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

/// <summary>
/// Builds the <c>cached-call</c> command group with sub-commands for retrying and
/// discarding parked cached-call operations. Both sub-commands relay to the existing
/// Deployer-gated <see cref="RetryParkedMessageCommand"/> /
/// <see cref="DiscardParkedMessageCommand"/> management commands via the central
/// <c>SiteCallAuditActor</c> → site relay.
/// </summary>
public static class CachedCallCommands
{
    // Options are static so the parsed values can be read back from both SetAction
    // and the internal BuildRetryCommand / BuildDiscardCommand helpers (used by tests).
    // A single shared instance per option is safe: retry and discard are sibling
    // sub-commands and cannot be invoked simultaneously.
    private static readonly Option<string> SiteIdOption =
        new("--site-id") { Description = "Site identifier of the parked operation", Required = true };
    private static readonly Option<string> MessageIdOption =
        new("--tracked-operation-id") { Description = "Tracked operation ID (MessageId) of the parked cached call", Required = true };

    /// <summary>
    /// Builds the <c>cached-call</c> command group.
    /// </summary>
    /// <param name="urlOption">Global <c>--url</c> option for the management API endpoint.</param>
    /// <param name="formatOption">Global <c>--format</c> option for output format.</param>
    /// <param name="usernameOption">Global <c>--username</c> option for authentication.</param>
    /// <param name="passwordOption">Global <c>--password</c> option for authentication.</param>
    /// <returns>The configured <c>cached-call</c> command with <c>retry</c> and <c>discard</c> sub-commands.</returns>
    public static Command Build(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var command = new Command("cached-call") { Description = "Manage parked cached-call operations (ExternalSystem.CachedCall / Database.CachedWrite)" };

        command.Add(BuildRetry(urlOption, formatOption, usernameOption, passwordOption));
        command.Add(BuildDiscard(urlOption, formatOption, usernameOption, passwordOption));

        return command;
    }

    private static Command BuildRetry(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var cmd = new Command("retry") { Description = "Retry a parked cached-call operation" };
        cmd.Add(SiteIdOption);
        cmd.Add(MessageIdOption);
        cmd.SetAction(async (ParseResult result) =>
        {
            return await CommandHelpers.ExecuteCommandAsync(
                result, urlOption, formatOption, usernameOption, passwordOption,
                BuildRetryCommand(result));
        });
        return cmd;
    }

    private static Command BuildDiscard(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
    {
        var cmd = new Command("discard") { Description = "Discard a parked cached-call operation" };
        cmd.Add(SiteIdOption);
        cmd.Add(MessageIdOption);
        cmd.SetAction(async (ParseResult result) =>
        {
            return await CommandHelpers.ExecuteCommandAsync(
                result, urlOption, formatOption, usernameOption, passwordOption,
                BuildDiscardCommand(result));
        });
        return cmd;
    }

    /// <summary>
    /// Builds a <see cref="RetryParkedMessageCommand"/> from a parsed <c>cached-call retry</c>
    /// invocation. Exposed internally so command-construction tests can assert field mapping
    /// without triggering the HTTP call.
    /// </summary>
    /// <param name="result">The parsed command-line result from the <c>cached-call retry</c> invocation.</param>
    /// <returns>A <see cref="RetryParkedMessageCommand"/> populated from the parsed result.</returns>
    internal static RetryParkedMessageCommand BuildRetryCommand(ParseResult result)
    {
        var siteId = result.GetValue(SiteIdOption)!;
        var messageId = result.GetValue(MessageIdOption)!;
        return new RetryParkedMessageCommand(siteId, messageId);
    }

    /// <summary>
    /// Builds a <see cref="DiscardParkedMessageCommand"/> from a parsed <c>cached-call discard</c>
    /// invocation. Exposed internally so command-construction tests can assert field mapping
    /// without triggering the HTTP call.
    /// </summary>
    /// <param name="result">The parsed command-line result from the <c>cached-call discard</c> invocation.</param>
    /// <returns>A <see cref="DiscardParkedMessageCommand"/> populated from the parsed result.</returns>
    internal static DiscardParkedMessageCommand BuildDiscardCommand(ParseResult result)
    {
        var siteId = result.GetValue(SiteIdOption)!;
        var messageId = result.GetValue(MessageIdOption)!;
        return new DiscardParkedMessageCommand(siteId, messageId);
    }
}