using System.Buffers.Binary;
using System.Collections;

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

/// <summary>
///     Encodes a whole-array write (review 07 U10): <c>count</c> elements at the element type's wire width,
///     little-endian, exactly the layout a Logix atomic array holds and the read path decodes. Shared by both
///     runtimes so the bytes on the wire are transport-independent.
/// </summary>
/// <remarks>
///     <para><b>Element values CONVERT, they are not exact-matched.</b> ScadaBridge (and any OPC UA client that
///     round-trips what it read) writes CLR lists such as <c>int[]</c> to an INT array — the read path itself
///     publishes INT/SINT elements as <c>int</c> — so each element goes through the same <see cref="Convert"/> the
///     scalar path uses. A value that does not fit is an <see cref="OverflowException"/> (BadOutOfRange) and one that
///     cannot convert a <see cref="FormatException"/> / <see cref="InvalidCastException"/> (BadTypeMismatch), all
///     thrown before any byte is sent.</para>
///     <para>BOOL arrays (bit-packed DWORDs — a byte-per-element encode would clobber neighbour bits), STRING arrays
///     (structures) and structure arrays are not encodable here; the driver refuses them <c>BadNotSupported</c>
///     before a runtime exists.</para>
/// </remarks>
internal static class AbCipArrayCodec
{
    /// <summary>Wire width of one element of an encodable array type, or <c>null</c> when the type is not encodable.</summary>
    /// <param name="type">The element type.</param>
    /// <returns>The element width in bytes, or <c>null</c>.</returns>
    public static int? ElementWidth(AbCipDataType type) => type switch
    {
        AbCipDataType.SInt or AbCipDataType.USInt => 1,
        AbCipDataType.Int or AbCipDataType.UInt => 2,
        AbCipDataType.DInt or AbCipDataType.UDInt or AbCipDataType.Real or AbCipDataType.Dt => 4,
        AbCipDataType.LInt or AbCipDataType.ULInt or AbCipDataType.LReal => 8,
        _ => null,
    };

    /// <summary>
    ///     The elements of an array write value, or <c>null</c> when the value is not a list (a scalar, a string, null).
    ///     Any non-string <see cref="IEnumerable"/> is accepted — <c>int[]</c>, <c>short[]</c>, <c>List&lt;object&gt;</c> …
    /// </summary>
    /// <param name="value">The client's write value.</param>
    /// <returns>The elements, or <c>null</c>.</returns>
    public static object?[]? Elements(object? value) => value switch
    {
        null or string => null,
        IEnumerable list => [.. list.Cast<object?>()],
        _ => null,
    };

    /// <summary>Encodes <paramref name="values"/> as <paramref name="type"/> elements.</summary>
    /// <param name="type">The element type (must have an <see cref="ElementWidth"/>).</param>
    /// <param name="values">The element values; their count is the element count.</param>
    /// <returns>The little-endian wire bytes, <c>values.Count × ElementWidth(type)</c> long.</returns>
    /// <exception cref="NotSupportedException">The type is not encodable.</exception>
    public static byte[] Encode(AbCipDataType type, IReadOnlyList<object?> values)
    {
        var width = ElementWidth(type)
            ?? throw new NotSupportedException($"Array writes of {type} elements are not supported.");
        var buffer = new byte[values.Count * width];
        for (var i = 0; i < values.Count; i++)
        {
            var v = values[i];
            var span = buffer.AsSpan(i * width, width);
            switch (type)
            {
                case AbCipDataType.SInt: span[0] = unchecked((byte)Convert.ToSByte(v)); break;
                case AbCipDataType.USInt: span[0] = Convert.ToByte(v); break;
                case AbCipDataType.Int: BinaryPrimitives.WriteInt16LittleEndian(span, Convert.ToInt16(v)); break;
                case AbCipDataType.UInt: BinaryPrimitives.WriteUInt16LittleEndian(span, Convert.ToUInt16(v)); break;
                case AbCipDataType.DInt:
                case AbCipDataType.Dt: BinaryPrimitives.WriteInt32LittleEndian(span, Convert.ToInt32(v)); break;
                case AbCipDataType.UDInt: BinaryPrimitives.WriteUInt32LittleEndian(span, Convert.ToUInt32(v)); break;
                case AbCipDataType.LInt: BinaryPrimitives.WriteInt64LittleEndian(span, Convert.ToInt64(v)); break;
                case AbCipDataType.ULInt: BinaryPrimitives.WriteUInt64LittleEndian(span, Convert.ToUInt64(v)); break;
                case AbCipDataType.Real: BinaryPrimitives.WriteSingleLittleEndian(span, Convert.ToSingle(v)); break;
                case AbCipDataType.LReal: BinaryPrimitives.WriteDoubleLittleEndian(span, Convert.ToDouble(v)); break;
            }
        }
        return buffer;
    }
}