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

/// <summary>
///     Every OPC UA status this backend emits, as named constants (inline literals are invisible to
///     <c>StatusCodeParityTests</c>). Values mirror <c>Opc.Ua.StatusCodes</c>.
/// </summary>
internal static class SqlHistorianStatusCodes
{
    public const uint Good = 0x00000000u;
    public const uint GoodEntryInserted = 0x00A20000u;
    public const uint GoodEntryReplaced = 0x00A30000u;
    public const uint BadNoData = 0x809B0000u;
    public const uint BadEntryExists = 0x809F0000u;
    public const uint BadNoEntryExists = 0x80A00000u;
    public const uint BadInvalidTimestamp = 0x80230000u;
    public const uint BadAggregateInvalidInputs = 0x80D60000u;
    public const uint UncertainDataSubNormal = 0x40A40000u;

    /// <summary>Stored for a non-finite Double (NaN / ±Infinity) that arrived with a non-Bad status.</summary>
    public const uint BadOutOfRange = 0x803C0000u;
}

/// <summary>
///     Bit masks over a 32-bit OPC UA status code (Part 4 §7.39). These are masks, not emitted codes, so their
///     names deliberately avoid the Good/Bad/Uncertain prefix the status-code parity scan keys on.
/// </summary>
internal static class StatusBits
{
    /// <summary>Severity + sub-code (top 16 bits) of a status, i.e. the code without info bits.</summary>
    public const uint CodeBitsMask = 0xFFFF0000u;

    /// <summary>The two severity bits (Good = 00, Uncertain = 01, Bad = 10).</summary>
    public const uint SeverityMask = 0xC0000000u;

    /// <summary>The severity bit set on every Bad code.</summary>
    public const uint SeverityBadBit = 0x80000000u;

    /// <summary>The two historian info bits (Calculated, Interpolated) in the low bits of the info field.</summary>
    public const uint HistorianBitsMask = 0x3u;

    /// <summary>True when <paramref name="status"/> has Bad severity.</summary>
    /// <param name="status">A status code.</param>
    /// <returns>Whether the Bad severity bit is set.</returns>
    public static bool IsBad(uint status) => (status & SeverityBadBit) != 0;

    /// <summary>True when <paramref name="status"/> has Good severity.</summary>
    /// <param name="status">A status code.</param>
    /// <returns>Whether both severity bits are clear.</returns>
    public static bool IsGood(uint status) => (status & SeverityMask) == 0;
}

/// <summary>Part 4 §7.39 historian info bits OR-ed onto a status code.</summary>
internal static class HistorianInfoBits
{
    /// <summary>InfoType = DataValue.</summary>
    public const uint InfoTypeDataValue = 0x00000400u;

    /// <summary>The value was produced by an aggregate calculation.</summary>
    public const uint HistorianCalculated = 0x1u;

    /// <summary>The value was interpolated.</summary>
    public const uint HistorianInterpolated = 0x2u;

    /// <summary>
    ///     Marks <paramref name="status"/> as a Calculated data value. Any historian bits the status already carries
    ///     (e.g. a stored Interpolated sample) are cleared first, so the result is never both.
    /// </summary>
    /// <param name="status">Base status code.</param>
    /// <returns>Status with InfoType and Calculated bits set.</returns>
    public static uint WithCalculated(uint status) =>
        (status & ~StatusBits.HistorianBitsMask) | InfoTypeDataValue | HistorianCalculated;

    /// <summary>
    ///     Marks <paramref name="status"/> as an Interpolated data value. Any historian bits the status already
    ///     carries (e.g. a stored Calculated sample) are cleared first, so the result is never both.
    /// </summary>
    /// <param name="status">Base status code.</param>
    /// <returns>Status with InfoType and Interpolated bits set.</returns>
    public static uint WithInterpolated(uint status) =>
        (status & ~StatusBits.HistorianBitsMask) | InfoTypeDataValue | HistorianInterpolated;
}