RawCardData.cs

using System;
using System.Collections;
using System.Linq;
using System.Text;
using OSDP.Net.Messages;
using OSDP.Net.Messages.SecureChannel;
 
namespace OSDP.Net.Model.ReplyData;

public class RawCardData : PayloadData
{
    public RawCardData(byte readerNumber, FormatCode format, BitArray data)
    {
        ReaderNumber = readerNumber;
        FormatCode = format;
        Data = data;
        BitCount = (ushort)data.Count;
    }

    public byte ReaderNumber { get; }
    
    public FormatCode FormatCode { get; }
    
    public ushort BitCount { get; }
    
    public BitArray Data { get; }
    
    public override byte Code => (byte)ReplyType.RawReaderData;
    
    public override ReadOnlySpan<byte> SecurityControlBlock()
    {
        return SecurityBlock.ReplyMessageWithDataSecurity;
    }

    public static RawCardData ParseData(ReadOnlySpan<byte> data)
    {
        var dataArray = data.ToArray();
        if (dataArray.Length < 4)
        {
            throw new Exception("Invalid size for the data");
        }
 
        ushort bitCount = Message.ConvertBytesToUnsignedShort(new[] {dataArray[2], dataArray[3]});
        var cardData = new BitArray(dataArray.Skip(4).Take(dataArray.Length - 4).Reverse().ToArray());
        Reverse(cardData);
        cardData.Length = bitCount;
 
        return new RawCardData(dataArray[0], (FormatCode)dataArray[1], cardData);
    }

    public override string ToString()
    {
        var build = new StringBuilder();
        build.AppendLine($"Reader Number: {ReaderNumber}");
        build.AppendLine($"  Format Code: {Helpers.SplitCamelCase(FormatCode.ToString())}");
        build.AppendLine($"    Bit Count: {BitCount}");
        build.AppendLine($"  Binary Data: {FormatData(Data)}");
        build.AppendLine($"     Hex Data: {FormatHexData(Data)}");
        return build.ToString();
    }
 
    internal static string FormatData(BitArray bitArray)
    {
        var builder = new StringBuilder();
        foreach (bool bit in bitArray)
        {
            builder.Append(bit ? "1" : "0");
        }
 
        return builder.ToString();
    }

    internal static string FormatHexData(BitArray bitArray)
    {
        var bytes = new byte[(bitArray.Length + 7) / 8];
        for (int index = 0; index < bitArray.Length; index++)
        {
            if (bitArray[index])
            {
                bytes[index / 8] |= (byte)(0x80 >> (index % 8));
            }
        }
 
        return BitConverter.ToString(bytes).Replace("-", string.Empty);
    }
 
    private static void Reverse(BitArray array)
    {
        int length = array.Length;
        int mid = length / 2;
 
        for (int index = 0; index < mid; index++)
        {
            (array[index], array[length - index - 1]) = (array[length - index - 1], array[index]);
        }    
    }

    public override byte[] BuildData()
    {
        var length = 4 + (Data.Count + 7) / 8;
        var buffer = new byte[length];
        buffer[0] = ReaderNumber;
        buffer[1] = (byte)FormatCode;
        buffer[2] = (byte)(BitCount & 0xff);
        buffer[3] = (byte)((BitCount >> 8) & 0xff);
        Data.CopyTo(buffer, 4);
 
        for (int i = 4; i < length; i++)
        {
            // Source of this nifty little bitwise logic to reverse the bits:
            // http://igoro.com/archive/programming-job-interview-challenge/
 
            byte b = buffer[i];
            int c = (byte)((b >> 4) | ((b & 0xf) << 4));
            c = ((c & 0xcc) >> 2) | ((c & 0x33) << 2);
            c = ((c & 0xaa) >> 1) | ((c & 0x55) << 1);
            buffer[i] = (byte)c;
        }
 
        return buffer;
    }
}

public enum FormatCode
{
    NotSpecified = 0x0,
    Wiegand = 0x1
}