using ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport;

namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip;

/// <summary>
///     Maps libplctag / CIP General Status codes to OPC UA StatusCodes. Mirrors the shape of
///     <c>ModbusDriver.MapModbusExceptionToStatus</c> so Admin UI status displays stay
///     uniform across drivers.
/// </summary>
/// <remarks>
///     <para>Coverage: the CIP general-status values an AB PLC actually returns during normal
///     driver operation. Full CIP Volume 1 Appendix B lists 50+ codes; the ones here are the
///     ones that move the driver's status needle:</para>
///     <list type="bullet">
///         <item>0x00 success — OPC UA <c>Good (0)</c>.</item>
///         <item>0x04 path segment error / 0x05 path destination unknown — <c>BadNodeIdUnknown</c>
///             (tag doesn't exist).</item>
///         <item>0x06 partial data transfer — <c>GoodMoreData</c> (fragmented read underway).</item>
///         <item>0x08 service not supported — <c>BadNotSupported</c> (e.g. write on a safety
///             partition tag from a non-safety task).</item>
///         <item>0x0A / 0x13 attribute-list error / insufficient data — <c>BadOutOfRange</c>
///             (type mismatch or truncated buffer).</item>
///         <item>0x0B already in requested mode — benign, treated as <c>Good</c>.</item>
///         <item>0x0E attribute not settable — <c>BadNotWritable</c>.</item>
///         <item>0x10 device state conflict — <c>BadDeviceFailure</c> (program-mode protected
///             writes during download / test-mode transitions).</item>
///         <item>0x16 object does not exist — <c>BadNodeIdUnknown</c>.</item>
///         <item>0x1E embedded service error — unwrap to the extended status when possible.</item>
///         <item>Transport <see cref="AbStatus"/> errors — mapped per-member by
///             <see cref="MapStatus(AbStatus)"/>: timeout, not-found, not-allowed, and
///             out-of-bounds get their specific OPC UA codes; the remaining transport errors
///             fold into <c>BadCommunicationError</c>.</item>
///     </list>
/// </remarks>
public static class AbCipStatusMapper
{
    public const uint Good = 0u;
    public const uint GoodMoreData = 0x00A60000u;
    public const uint BadInternalError = 0x80020000u;
    public const uint BadNodeIdUnknown = 0x80340000u;
    public const uint BadNotWritable = 0x803B0000u;
    public const uint BadOutOfRange = 0x803C0000u;
    public const uint BadNotSupported = 0x803D0000u;
    public const uint BadDeviceFailure = 0x808B0000u;
    public const uint BadCommunicationError = 0x80050000u;
    public const uint BadTimeout = 0x800A0000u;
    public const uint BadTypeMismatch = 0x80740000u;

    /// <summary>Map a CIP general-status byte to an OPC UA StatusCode.</summary>
    /// <param name="status">The CIP general-status byte value.</param>
    /// <returns>The mapped OPC UA StatusCode value.</returns>
    public static uint MapCipGeneralStatus(byte status) => status switch
    {
        0x00 => Good,
        0x04 or 0x05 => BadNodeIdUnknown,
        0x06 => GoodMoreData,
        0x08 => BadNotSupported,
        0x0A or 0x13 => BadOutOfRange,
        0x0B => Good,
        0x0E => BadNotWritable,
        0x10 => BadDeviceFailure,
        0x16 => BadNodeIdUnknown,
        _ => BadInternalError,
    };

    /// <summary>
    ///     Map a transport status code to an OPC UA StatusCode. The integer is
    ///     <see cref="IAbCipTagRuntime.GetStatus"/>, i.e. the underlying value of <see cref="AbStatus"/>.
    /// </summary>
    /// <param name="status">The <see cref="AbStatus"/> as an integer.</param>
    /// <returns>The mapped OPC UA StatusCode value.</returns>
    public static uint MapStatus(int status) => MapStatus((AbStatus)status);

    /// <summary>
    ///     Map an <see cref="AbStatus"/> to an OPC UA StatusCode. Timeout, not-found, not-allowed and
    ///     out-of-bounds get their specific codes; the remaining transport errors fold into
    ///     <see cref="BadCommunicationError"/>.
    /// </summary>
    /// <param name="status">The transport status.</param>
    /// <returns>The mapped OPC UA StatusCode value.</returns>
    public static uint MapStatus(AbStatus status) => status switch
    {
        AbStatus.Ok => Good,
        AbStatus.Pending => GoodMoreData,
        AbStatus.Timeout => BadTimeout,
        AbStatus.NotFound => BadNodeIdUnknown,
        AbStatus.NotAllowed => BadNotWritable,
        AbStatus.OutOfBounds or AbStatus.TooLarge or AbStatus.TooSmall => BadOutOfRange,
        AbStatus.Unsupported => BadNotSupported,
        AbStatus.TypeMismatch => BadTypeMismatch,
        AbStatus.DeviceStateConflict => BadDeviceFailure,
        _ => BadCommunicationError, // BadConnection, BadReply, Partial, Abort
    };

    /// <summary>
    ///     Status for an exception thrown while creating / reading a tag: a transport exception maps
    ///     through its <see cref="AbStatus"/> (so a tag the controller does not have reads
    ///     <see cref="BadNodeIdUnknown"/>, not a comms error); anything else is
    ///     <see cref="BadCommunicationError"/>.
    /// </summary>
    /// <param name="ex">The exception.</param>
    /// <returns>The OPC UA status code.</returns>
    public static uint MapException(Exception ex) =>
        ex is AbTransportException ate ? MapStatus(ate.Status) : BadCommunicationError;
}