ExtendedDeviceIdentification.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using OSDP.Net.Messages;
using OSDP.Net.Messages.SecureChannel;
 
namespace OSDP.Net.Model.ReplyData
{
    public class ExtendedDeviceIdentification : PayloadData
    {
        private readonly List<ExtendedIdEntry> _entries;

        public ExtendedDeviceIdentification(IEnumerable<ExtendedIdEntry> entries)
        {
            _entries = entries?.ToList() ?? new List<ExtendedIdEntry>();
        }

        public IReadOnlyList<ExtendedIdEntry> Entries => _entries;

        public IEnumerable<ExtendedIdEntry> UnknownEntries => _entries.Where(e => !e.IsKnown);

        public string Manufacturer => GetFirstValue(ExtendedIdTag.Manufacturer);

        public string ProductName => GetFirstValue(ExtendedIdTag.ProductName);

        public string SerialNumber => GetFirstValue(ExtendedIdTag.SerialNumber);

        public IEnumerable<string> FirmwareVersions => GetValues(ExtendedIdTag.FirmwareVersion);

        public string HardwareDescription => GetFirstValue(ExtendedIdTag.HardwareDescription);

        public string Url => GetFirstValue(ExtendedIdTag.Url);

        public string ConfigurationReference => GetFirstValue(ExtendedIdTag.ConfigurationReference);

        public override byte Code => (byte)ReplyType.ExtendedPdIdReport;

        public override ReadOnlySpan<byte> SecurityControlBlock()
        {
            return SecurityBlock.ReplyMessageWithDataSecurity;
        }

        public static ExtendedDeviceIdentification ParseData(ReadOnlySpan<byte> data)
        {
            // Check if data starts with a multipart message header (6 bytes minimum)
            // If so, skip the header and parse only the TLV data
            ReadOnlySpan<byte> tlvData = data;
 
            if (data.Length >= 6)
            {
                // Check if this looks like a a multi-part message header by validating a structure
                ushort offset = (ushort)(data[2] | (data[3] << 8));
                ushort lengthOfFragment = (ushort)(data[4] | (data[5] << 8));
 
                // If the multipart header is present and valid, skip it
                if (data.Length == 6 + lengthOfFragment && offset == 0)
                {
                    tlvData = data.Slice(6);
                }
            }
 
            var entries = new List<ExtendedIdEntry>();
            int parseOffset = 0;
 
            while (parseOffset < tlvData.Length)
            {
                var entry = ExtendedIdEntry.ParseData(tlvData.Slice(parseOffset), out int bytesConsumed);
                if (entry == null || bytesConsumed == 0)
                {
                    if (parseOffset < tlvData.Length)
                    {
                        throw new Exception($"Failed to parse TLV entry at offset {parseOffset}, {tlvData.Length - parseOffset} bytes remaining");
                    }
                    break;
                }
 
                entries.Add(entry);
                parseOffset += bytesConsumed;
            }
 
            return new ExtendedDeviceIdentification(entries);
        }

        public override byte[] BuildData()
        {
            // Build the TLV entries
            var tlvData = new List<byte>();
            foreach (var entry in _entries)
            {
                tlvData.AddRange(entry.BuildData());
            }
 
            // Extended ID Report must be sent as a multipart message format:
            // 2 bytes: Whole Message Length (little-endian)
            // 2 bytes: Offset (little-endian)
            // 2 bytes: Length of Fragment (little-endian)
            // N bytes: Data (the TLV stream)
            var wholeMessageLength = (ushort)tlvData.Count;
            var result = new List<byte>
            {
                // Whole Message Length (LSB, MSB)
                (byte)(wholeMessageLength & 0xFF),
                (byte)((wholeMessageLength >> 8) & 0xFF),
 
                // Offset (LSB, MSB) - always 0 for single fragment
                0x00,
                0x00,
 
                // Length of Fragment (LSB, MSB) - same as a whole message for a single fragment
                (byte)(wholeMessageLength & 0xFF),
                (byte)((wholeMessageLength >> 8) & 0xFF)
            };
 
            // Add the TLV data
            result.AddRange(tlvData);
 
            return result.ToArray();
        }

        public override string ToString()
        {
            var build = new StringBuilder();
 
            if (Manufacturer != null)
            {
                build.AppendLine($"    Manufacturer: {Manufacturer}");
            }
 
            if (ProductName != null)
            {
                build.AppendLine($"    Product Name: {ProductName}");
            }
 
            if (SerialNumber != null)
            {
                build.AppendLine($"   Serial Number: {SerialNumber}");
            }
 
            var firmwareVersions = FirmwareVersions.ToList();
            for (int i = 0; i < firmwareVersions.Count; i++)
            {
                var label = i == 0 ? "Firmware Version" : $"Firmware Version {i + 1}";
                build.AppendLine($"{label,16}: {firmwareVersions[i]}");
            }
 
            if (HardwareDescription != null)
            {
                build.AppendLine($"        Hardware: {HardwareDescription}");
            }
 
            if (Url != null)
            {
                build.AppendLine($"             URL: {Url}");
            }
 
            if (ConfigurationReference != null)
            {
                build.AppendLine($"   Configuration: {ConfigurationReference}");
            }
 
            // Display any unknown/undefined tags
            var unknownEntries = UnknownEntries.ToList();
            if (unknownEntries.Any())
            {
                foreach (var entry in unknownEntries)
                {
                    build.AppendLine($"  Unknown Tag {entry.TagByte}: {entry.Value}");
                }
            }
 
            return build.ToString();
        }
 
        private string GetFirstValue(ExtendedIdTag tag)
        {
            return _entries.FirstOrDefault(e => e.Tag == tag)?.Value;
        }
 
        private IEnumerable<string> GetValues(ExtendedIdTag tag)
        {
            return _entries.Where(e => e.Tag == tag).Select(e => e.Value);
        }
    }
}