using ZB.MOM.WW.OtOpcUa.Core.Abstractions;

namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Sql.Common;

/// <summary>The AtTime rules, applied to one requested time and its stored neighbours.</summary>
public static class AtTimeEvaluator
{
    /// <summary>
    ///     Applies the AtTime rules to one requested time <paramref name="t"/> (the result is stamped <c>t</c>):
    ///     <list type="bullet">
    ///       <item><c>prev</c> at exactly <c>t</c> ⇒ the stored value and status, unchanged.</item>
    ///       <item>No <c>prev</c> ⇒ <c>BadNoData</c>, null value.</item>
    ///       <item><c>prev</c> Bad (incl. an <c>Empty</c> outage marker) ⇒ <c>t</c> lies inside an outage: null value
    ///         carrying <c>prev</c>'s Bad status code (info bits stripped) — never better than its source.</item>
    ///       <item><c>prev</c> usable and <c>next</c> Bad ⇒ <c>prev</c>'s value held (stepped, NOT interpolated into the
    ///         outage) with <c>UncertainDataSubNormal</c> + Interpolated bits.</item>
    ///       <item>Double/Int64 with a usable <c>next</c> ⇒ linear interpolation (Int64 rounded to the nearest integer,
    ///         ties away from zero, keeping the type); status <c>Good</c> + Interpolated when both neighbours are Good,
    ///         else <c>UncertainDataSubNormal</c> + Interpolated.</item>
    ///       <item>Boolean/String/DateTime, or no <c>next</c> (after the last sample) ⇒ stepped: <c>prev</c>'s value with
    ///         <c>prev</c>'s status code + Interpolated bits — except that a time later than now that is stepped from the
    ///         last sample is <c>UncertainDataSubNormal</c> + Interpolated.</item>
    ///     </list>
    /// </summary>
    /// <param name="t">Requested time.</param>
    /// <param name="prev">The stored sample at or before <paramref name="t"/>, if any.</param>
    /// <param name="next">The stored sample after <paramref name="t"/>, if any.</param>
    /// <param name="serverTime">Server timestamp for the result.</param>
    /// <param name="now">The current time (for the beyond-now rule).</param>
    /// <returns>The value at <paramref name="t"/>.</returns>
    public static DataValueSnapshot Evaluate(DateTime t, StoredSample? prev, StoredSample? next, DateTime serverTime, DateTime now)
    {
        if (prev is not { } p)
            return new DataValueSnapshot(null, HistorianStatusCodes.BadNoData, t, serverTime);
        if (p.TimeUtc == t)
            return new DataValueSnapshot(p.Value.ToObject(), p.Status, t, serverTime);

        // Inside an outage: report the outage's own Bad code, never an upgraded Uncertain.
        if (!p.IsUsable)
            return new DataValueSnapshot(null, p.Status & StatusBits.CodeBitsMask, t, serverTime);

        // Usable previous, Bad next: hold the previous value up to the outage; do not interpolate into it.
        if (next is { IsUsable: false })
            return new DataValueSnapshot(p.Value.ToObject(),
                HistorianInfoBits.WithInterpolated(HistorianStatusCodes.UncertainDataSubNormal), t, serverTime);

        if (next is { } n && p.Value.Kind is HistorianValueKind.Double or HistorianValueKind.Int64
                          && n.Value.TryGetDouble(out var nv))
        {
            var fraction = (double)(t.Ticks - p.TimeUtc.Ticks) / (n.TimeUtc.Ticks - p.TimeUtc.Ticks);
            var v = p.Value.Number + (nv - p.Value.Number) * fraction;
            // Each arm boxed on its own: `cond ? (long)x : v` is a DOUBLE expression in C# (the long widens), which returned
            // every interpolated Int64 as a Double until #693.
            object value = p.Value.Kind == HistorianValueKind.Int64
                ? (object)(long)Math.Round(v, MidpointRounding.AwayFromZero)
                : v;
            var status = p.IsGood && n.IsGood ? HistorianStatusCodes.Good : HistorianStatusCodes.UncertainDataSubNormal;
            return new DataValueSnapshot(value, HistorianInfoBits.WithInterpolated(status), t, serverTime);
        }

        // Beyond the last sample AND beyond now: the value is held into the future, so it is not known to be Good.
        if (next is null && t > now)
            return new DataValueSnapshot(p.Value.ToObject(),
                HistorianInfoBits.WithInterpolated(HistorianStatusCodes.UncertainDataSubNormal), t, serverTime);

        // Stepped (non-numeric kind, or after the last sample): hold the previous value and its status.
        return new DataValueSnapshot(p.Value.ToObject(), HistorianInfoBits.WithInterpolated(p.Status), t, serverTime);
    }
}