using Opc.Ua;
using Opc.Ua.Server;
using Shouldly;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;

namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Conformance;

/// <summary>
///     Drives the pinned OPC UA SDK's own Part 13 aggregate calculators (<c>Opc.Ua.Server</c> — the classes the SDK's
///     <c>AggregateManager</c> registers) in-process over a sample set, so our processed reads can be compared with the
///     reference implementation bucket by bucket (#677). The calculators run under the server's default
///     <see cref="AggregateConfiguration"/> (TreatUncertainAsBad = false, PercentDataBad = PercentDataGood = 100,
///     UseSlopedExtrapolation = false), sloped interpolation, source timestamps.
/// </summary>
/// <remarks>
///     Shared (source-linked) by <c>Sql.Common.Tests</c> and both SQL backends' integration suites.
/// </remarks>
public static class SdkAggregateOracle
{
    /// <summary>One processed value: value (double / int / null), full status code, timestamp.</summary>
    public readonly record struct Result(object? Value, uint StatusCode, DateTime Timestamp);

    /// <summary>The server-default aggregate configuration (what <c>AggregateManager.GetDefaultConfiguration</c> returns).</summary>
    public static AggregateConfiguration DefaultConfiguration => new()
    {
        TreatUncertainAsBad = false,
        PercentDataBad = 100,
        PercentDataGood = 100,
        UseSlopedExtrapolation = false,
        UseServerCapabilitiesDefaults = false,
    };

    /// <summary>Runs the SDK calculator for <paramref name="aggregate"/> over <paramref name="samples"/>.</summary>
    /// <param name="aggregate">The aggregate.</param>
    /// <param name="start">Request start (later than <paramref name="end"/> for a reverse read).</param>
    /// <param name="end">Request end.</param>
    /// <param name="interval">Processing interval.</param>
    /// <param name="samples">Every stored sample of the tag, any order (sorted here).</param>
    /// <returns>The SDK's processed values, in the order it returns them.</returns>
    public static IReadOnlyList<Result> Run(HistoryAggregateType aggregate, DateTime start, DateTime end, TimeSpan interval,
        IEnumerable<(DateTime Time, HistorianValue Value, uint Status)> samples)
    {
        var id = AggregateId(aggregate);
        var ms = interval.TotalMilliseconds;
        var cfg = DefaultConfiguration;
        IAggregateCalculator calc = aggregate switch
        {
            HistoryAggregateType.Average or HistoryAggregateType.TimeAverage or HistoryAggregateType.TimeAverage2
                or HistoryAggregateType.Total or HistoryAggregateType.Total2 =>
                new AverageAggregateCalculator(id, start, end, ms, false, cfg, null),
            HistoryAggregateType.Minimum or HistoryAggregateType.Maximum or HistoryAggregateType.Range
                or HistoryAggregateType.MinimumActualTime or HistoryAggregateType.MaximumActualTime =>
                new MinMaxAggregateCalculator(id, start, end, ms, false, cfg, null),
            HistoryAggregateType.Count => new CountAggregateCalculator(id, start, end, ms, false, cfg, null),
            HistoryAggregateType.PercentGood or HistoryAggregateType.PercentBad =>
                new StatusAggregateCalculator(id, start, end, ms, false, cfg, null),
            HistoryAggregateType.Start or HistoryAggregateType.End or HistoryAggregateType.Delta =>
                new StartEndAggregateCalculator(id, start, end, ms, false, cfg, null),
            HistoryAggregateType.Interpolative => new AggregateCalculator(id, start, end, ms, false, cfg, null),
            _ => throw new ArgumentOutOfRangeException(nameof(aggregate), aggregate, "no SDK calculator mapped"),
        };

        // The SDK expects values in the direction of the read: ascending forward, descending reverse.
        var ordered = samples.OrderBy(s => s.Time).ToList();
        if (end < start) ordered.Reverse();
        foreach (var s in ordered) calc.QueueRawValue(ToDataValue(s.Time, s.Value, s.Status));

        var results = new List<Result>();
        for (var guard = 0; guard < 100_000; guard++)
        {
            var dv = calc.GetProcessedValue(true);
            if (dv is null) break;
            results.Add(new Result(dv.Value, dv.StatusCode.Code, DateTime.SpecifyKind(dv.SourceTimestamp, DateTimeKind.Utc)));
        }
        return results;
    }

    /// <summary>
    ///     Asserts our snapshots equal the SDK's: same count, same timestamps, same status code bits (severity + sub-code)
    ///     and Partial bit (and optionally the Calculated / Interpolated bits), same value (doubles to 1e-9; ints exactly;
    ///     null on a Bad status). A failure lists every differing interval side by side.
    /// </summary>
    /// <param name="ours">Our processed values.</param>
    /// <param name="sdk">The SDK's.</param>
    /// <param name="label">Context for failure messages.</param>
    /// <param name="compareCalculatedInterpolatedBits">Also compare the Calculated / Interpolated aggregate bits.</param>
    /// <param name="compareCodeBits">Compare the severity + sub-code (false only for a documented status divergence).</param>
    /// <param name="compareValues">Compare the values (false only for a documented value divergence).</param>
    /// <param name="compareTimestamps">Compare the timestamps (false only for a documented timestamp divergence).</param>
    /// <param name="comparePartialBit">Compare the Partial bit (false only for a documented divergence).</param>
    public static void ShouldMatch(IReadOnlyList<DataValueSnapshot> ours, IReadOnlyList<Result> sdk, string label,
        bool compareCalculatedInterpolatedBits = true, bool compareCodeBits = true, bool compareValues = true,
        bool compareTimestamps = true, bool comparePartialBit = true)
    {
        var problems = new List<string>();
        if (ours.Count != sdk.Count) problems.Add($"interval count: ours {ours.Count}, sdk {sdk.Count}");
        for (var i = 0; i < Math.Min(ours.Count, sdk.Count); i++)
        {
            var o = ours[i];
            var s = sdk[i];
            var bitMask = (comparePartialBit ? 0x4u : 0u) | (compareCodeBits ? 0xFFFF0000u : 0u)
                          | (compareCalculatedInterpolatedBits ? 0x3u : 0u);
            var same = (!compareTimestamps || o.SourceTimestampUtc == s.Timestamp)
                       && (o.StatusCode & bitMask) == (s.StatusCode & bitMask);
            if (!compareValues || (!compareCodeBits && StatusCode.IsBad(s.StatusCode)))
            {
                // Values not compared (or the SDK answered Bad under a status this comparison does not check).
            }
            else if (same && !StatusCode.IsBad(s.StatusCode))
            {
                same = s.Value switch
                {
                    null => o.Value is null,
                    int n => o.Value is not null && Convert.ToInt32(o.Value) == n,
                    _ => o.Value is not null && Math.Abs(Convert.ToDouble(o.Value) - Convert.ToDouble(s.Value)) <= 1e-9,
                };
            }
            else if (same && compareCodeBits) same = o.Value is null;
            if (!same)
                problems.Add($"[{i}] ours {o.SourceTimestampUtc:HH:mm:ss.fffffff} {o.Value ?? "null"} 0x{o.StatusCode:X8}" +
                             $" | sdk {s.Timestamp:HH:mm:ss.fffffff} {s.Value ?? "null"} 0x{s.StatusCode:X8}");
        }
        problems.ShouldBeEmpty($"{label} differs from the SDK:\n" + string.Join("\n", problems));
    }

    private static DataValue ToDataValue(DateTime t, HistorianValue v, uint status) => new()
    {
        WrappedValue = v.Kind switch
        {
            HistorianValueKind.Empty => Variant.Null,
            HistorianValueKind.Int64 => new Variant(v.Integer),
            HistorianValueKind.Boolean => new Variant(v.Number != 0),
            HistorianValueKind.String => new Variant(v.Text),
            _ => new Variant(v.Number),
        },
        StatusCode = status,
        SourceTimestamp = t,
        ServerTimestamp = t,
    };

    private static NodeId AggregateId(HistoryAggregateType a) => a switch
    {
        HistoryAggregateType.Average => ObjectIds.AggregateFunction_Average,
        HistoryAggregateType.Minimum => ObjectIds.AggregateFunction_Minimum,
        HistoryAggregateType.Maximum => ObjectIds.AggregateFunction_Maximum,
        HistoryAggregateType.Range => ObjectIds.AggregateFunction_Range,
        HistoryAggregateType.MinimumActualTime => ObjectIds.AggregateFunction_MinimumActualTime,
        HistoryAggregateType.MaximumActualTime => ObjectIds.AggregateFunction_MaximumActualTime,
        HistoryAggregateType.Count => ObjectIds.AggregateFunction_Count,
        HistoryAggregateType.PercentGood => ObjectIds.AggregateFunction_PercentGood,
        HistoryAggregateType.PercentBad => ObjectIds.AggregateFunction_PercentBad,
        HistoryAggregateType.Start => ObjectIds.AggregateFunction_Start,
        HistoryAggregateType.End => ObjectIds.AggregateFunction_End,
        HistoryAggregateType.Delta => ObjectIds.AggregateFunction_Delta,
        HistoryAggregateType.TimeAverage => ObjectIds.AggregateFunction_TimeAverage,
        HistoryAggregateType.TimeAverage2 => ObjectIds.AggregateFunction_TimeAverage2,
        HistoryAggregateType.Total => ObjectIds.AggregateFunction_Total,
        HistoryAggregateType.Total2 => ObjectIds.AggregateFunction_Total2,
        HistoryAggregateType.Interpolative => ObjectIds.AggregateFunction_Interpolative,
        _ => throw new ArgumentOutOfRangeException(nameof(a), a, "no SDK aggregate id mapped"),
    };
}