using CliFx.Attributes;
using CliFx.Infrastructure;
using ZB.MOM.WW.OtOpcUa.Client.CLI.Helpers;
using ZB.MOM.WW.OtOpcUa.Client.Shared;

namespace ZB.MOM.WW.OtOpcUa.Client.CLI.Commands;

[Command("alarms", Description = "Subscribe to alarm events")]
public class AlarmsCommand : CommandBase
{
    /// <summary>
    /// Creates the alarm-monitoring command used to stream OPC UA condition events to the terminal.
    /// </summary>
    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
    public AlarmsCommand(IOpcUaClientServiceFactory factory) : base(factory)
    {
    }

    /// <summary>
    /// Gets the optional source node whose alarm events should be monitored instead of the server root.
    /// </summary>
    [CommandOption("node", 'n', Description = "Node ID to monitor for events (default: Server node)")]
    public string? NodeId { get; init; }

    /// <summary>
    /// Gets the publishing interval, in milliseconds, for the alarm subscription.
    /// </summary>
    [CommandOption("interval", 'i', Description = "Publishing interval in milliseconds")]
    public int Interval { get; init; } = 1000;

    /// <summary>
    /// Gets a value indicating whether retained alarm conditions should be refreshed immediately after subscribing.
    /// </summary>
    [CommandOption("refresh", Description = "Request a ConditionRefresh after subscribing")]
    public bool Refresh { get; init; }

    /// <summary>
    /// Connects to the server, subscribes to alarm events, and streams operator-facing alarm state changes to the console.
    /// </summary>
    /// <param name="console">The CLI console used for output and cancellation handling.</param>
    public override async ValueTask ExecuteAsync(IConsole console)
    {
        ConfigureLogging();
        IOpcUaClientService? service = null;
        try
        {
            var ct = console.RegisterCancellationHandler();
            (service, _) = await CreateServiceAndConnectAsync(ct);

            var sourceNodeId = NodeIdParser.Parse(NodeId);

            service.AlarmEvent += (_, e) =>
            {
                console.Output.WriteLine($"[{e.Time:O}] ALARM  {e.SourceName}");
                console.Output.WriteLine($"  Condition: {e.ConditionName}");
                var activeStr = e.ActiveState ? "Active" : "Inactive";
                var ackedStr = e.AckedState ? "Acknowledged" : "Unacknowledged";
                console.Output.WriteLine($"  State:     {activeStr}, {ackedStr}");
                console.Output.WriteLine($"  Severity:  {e.Severity}");
                if (!string.IsNullOrEmpty(e.Message))
                    console.Output.WriteLine($"  Message:   {e.Message}");
                console.Output.WriteLine($"  Retain:    {e.Retain}");
                console.Output.WriteLine();
            };

            await service.SubscribeAlarmsAsync(sourceNodeId, Interval, ct);
            await console.Output.WriteLineAsync(
                $"Subscribed to alarm events (interval: {Interval}ms). Press Ctrl+C to stop.");

            if (Refresh)
                try
                {
                    await service.RequestConditionRefreshAsync(ct);
                    await console.Output.WriteLineAsync("Condition refresh requested.");
                }
                catch (Exception ex)
                {
                    await console.Output.WriteLineAsync($"Condition refresh not supported: {ex.Message}");
                }

            // Wait until cancellation
            try
            {
                await Task.Delay(Timeout.Infinite, ct);
            }
            catch (OperationCanceledException)
            {
                // Expected on Ctrl+C
            }

            await service.UnsubscribeAlarmsAsync();
            await console.Output.WriteLineAsync("Unsubscribed.");
        }
        finally
        {
            if (service != null)
            {
                await service.DisconnectAsync();
                service.Dispose();
            }
        }
    }
}