OSDPCaptureFileWriter.cs

using System;
using System.IO;
using System.Text.Json;
 
namespace OSDP.Net.Tracing;

public class OSDPCaptureFileWriter : IDisposable
{
    private readonly StreamWriter _writer;
    private readonly string _source;
    private bool _disposed;

    public OSDPCaptureFileWriter(string filePath, string source, bool append = true)
        : this(filePath, source, new FileSystemAdapter(), append)
    {
    }

    internal OSDPCaptureFileWriter(string filePath, string source, IFileSystem fileSystem, bool append = true)
    {
        if (string.IsNullOrEmpty(filePath))
            throw new ArgumentNullException(nameof(filePath));
        if (string.IsNullOrEmpty(source))
            throw new ArgumentNullException(nameof(source));
 
        var directory = fileSystem.GetDirectoryName(filePath);
        if (!string.IsNullOrEmpty(directory))
            fileSystem.CreateDirectory(directory);
 
        _source = source;
        _writer = fileSystem.CreateStreamWriter(filePath, append);
    }

    public void WritePacket(byte[] data, TraceDirection direction)
    {
        if (_disposed) throw new ObjectDisposedException(nameof(OSDPCaptureFileWriter));
        if (data == null) throw new ArgumentNullException(nameof(data));
 
        WritePacketInternal(data, direction, DateTime.UtcNow);
    }

    public void WritePacket(byte[] data, TraceDirection direction, DateTime timestamp)
    {
        if (_disposed) throw new ObjectDisposedException(nameof(OSDPCaptureFileWriter));
        if (data == null) throw new ArgumentNullException(nameof(data));
 
        WritePacketInternal(data, direction, timestamp);
    }

    public void WriteTrace(TraceEntry trace)
    {
        if (_disposed) throw new ObjectDisposedException(nameof(OSDPCaptureFileWriter));
 
        WritePacketInternal(trace.Data, trace.Direction, DateTime.UtcNow);
    }
 
    private void WritePacketInternal(byte[] data, TraceDirection direction, DateTime timestamp)
    {
        var unixTime = timestamp.Subtract(new DateTime(1970, 1, 1));
        long timeSec = (long)Math.Floor(unixTime.TotalSeconds);
        long timeNano = (unixTime.Ticks - timeSec * TimeSpan.TicksPerSecond) * 100L;
 
        string ioValue = direction switch
        {
            TraceDirection.Input => "input",
            TraceDirection.Output => "output",
            TraceDirection.Trace => "trace",
            _ => "unknown"
        };
 
        var entry = new
        {
            timeSec = timeSec.ToString("F0"),
            timeNano = timeNano.ToString("000000000"),
            io = ioValue,
            data = BitConverter.ToString(data),
            osdpTraceVersion = "1",
            osdpSource = _source
        };
 
        string json = JsonSerializer.Serialize(entry);
        _writer.WriteLine(json);
        _writer.Flush(); // Ensure data is written immediately for real-time monitoring
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                _writer?.Dispose();
            }
            _disposed = true;
        }
    }
}