LineQualityReport.cs

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace OSDP.Net.LineQuality
{
    public enum LineQualityVerdict
    {
        Untested,

        Pass,

        Marginal,

        Fail
    }

    public class CombinationResult
    {
        private readonly List<double> _responseTimesMs = new List<double>();
 
        internal CombinationResult(TestPattern pattern, int payloadLength)
        {
            Pattern = pattern;
            PayloadLength = payloadLength;
        }

        public TestPattern Pattern { get; }

        public int PayloadLength { get; }

        public int PacketsSent { get; internal set; }

        public int PacketsReceived { get; internal set; }

        public int Timeouts { get; internal set; }

        public int IntegrityErrors { get; internal set; }

        public int Naks { get; internal set; }

        public int PatternMismatches { get; internal set; }

        public int Failures => Timeouts + IntegrityErrors + Naks + PatternMismatches;

        public double SuccessRatePercent =>
            PacketsSent == 0 ? 0.0 : 100.0 * PacketsReceived / PacketsSent;

        public double MinResponseTimeMs => _responseTimesMs.Count == 0 ? 0.0 : _responseTimesMs.Min();

        public double MaxResponseTimeMs => _responseTimesMs.Count == 0 ? 0.0 : _responseTimesMs.Max();

        public double AverageResponseTimeMs => _responseTimesMs.Count == 0 ? 0.0 : _responseTimesMs.Average();
 
        internal void RecordResponseTime(double milliseconds) => _responseTimesMs.Add(milliseconds);
    }

    public class BaudRateResult
    {
        private readonly List<CombinationResult> _combinations = new List<CombinationResult>();
 
        internal BaudRateResult(int baudRate)
        {
            BaudRate = baudRate;
        }

        public int BaudRate { get; }

        public IReadOnlyList<CombinationResult> Combinations => _combinations;

        public string SkipReason { get; internal set; }

        public string FailureReason { get; internal set; }

        public bool WasTested => SkipReason == null && FailureReason == null && PacketsSent > 0;

        public int PacketsSent => _combinations.Sum(combination => combination.PacketsSent);

        public int PacketsReceived => _combinations.Sum(combination => combination.PacketsReceived);

        public int Timeouts => _combinations.Sum(combination => combination.Timeouts);

        public int IntegrityErrors => _combinations.Sum(combination => combination.IntegrityErrors);

        public int Naks => _combinations.Sum(combination => combination.Naks);

        public int PatternMismatches => _combinations.Sum(combination => combination.PatternMismatches);

        public int Failures => Timeouts + IntegrityErrors + Naks + PatternMismatches;

        public double SuccessRatePercent =>
            PacketsSent == 0 ? 0.0 : 100.0 * PacketsReceived / PacketsSent;

        public double MaxResponseTimeMs =>
            _combinations.Count == 0 ? 0.0 : _combinations.Max(combination => combination.MaxResponseTimeMs);

        public double AverageResponseTimeMs
        {
            get
            {
                int received = PacketsReceived;
                if (received == 0) return 0.0;
 
                double weighted = _combinations.Sum(combination =>
                    combination.AverageResponseTimeMs * combination.PacketsReceived);
                return weighted / received;
            }
        }

        public double DetectionLimitPercent => LineQualityProtocol.DetectionLimitPercent(PacketsSent);

        public LineQualityVerdict Verdict
        {
            get
            {
                // An incomplete rate change is a failure of the rate, even though it produced no
                // packets to count. Reporting it as merely "untested" would hide the finding.
                if (FailureReason != null) return LineQualityVerdict.Fail;
 
                if (!WasTested) return LineQualityVerdict.Untested;
 
                if (SuccessRatePercent < 99.0 || MaxResponseTimeMs > MaximumReplyDelayMs)
                {
                    return LineQualityVerdict.Fail;
                }
 
                if (Failures > 0 || MaxResponseTimeMs > MarginalReplyDelayMs)
                {
                    return LineQualityVerdict.Marginal;
                }
 
                return LineQualityVerdict.Pass;
            }
        }

        internal const double MaximumReplyDelayMs = 200.0;

        internal const double MarginalReplyDelayMs = 150.0;
 
        internal CombinationResult AddCombination(TestPattern pattern, int payloadLength)
        {
            var combination = new CombinationResult(pattern, payloadLength);
            _combinations.Add(combination);
            return combination;
        }
    }

    public class LineQualityReport
    {
        private readonly List<BaudRateResult> _baudRates = new List<BaudRateResult>();
 
        internal LineQualityReport(TestProfile profile, string connection, byte address)
        {
            Profile = profile;
            Connection = connection;
            Address = address;
            StartedUtc = DateTime.UtcNow;
        }

        public TestProfile Profile { get; }

        public string Connection { get; }

        public byte Address { get; }

        public DateTime StartedUtc { get; }

        public DateTime CompletedUtc { get; internal set; }

        public TimeSpan Duration => CompletedUtc - StartedUtc;

        public IReadOnlyList<BaudRateResult> BaudRates => _baudRates;

        public int IterationsPerCombination => LineQualityProtocol.IterationsPerCombination(Profile);

        public int? RecommendedBaudRate => _baudRates
            .Where(result => result.Verdict == LineQualityVerdict.Pass)
            .Select(result => (int?)result.BaudRate)
            .DefaultIfEmpty(null)
            .Max();

        public LineQualityVerdict OverallVerdict
        {
            get
            {
                // A rate that failed its transition counts here even though it produced no packets.
                var assessed = _baudRates
                    .Where(result => result.Verdict != LineQualityVerdict.Untested)
                    .ToArray();
 
                if (assessed.Length == 0) return LineQualityVerdict.Untested;
 
                if (assessed.Any(result => result.Verdict == LineQualityVerdict.Pass))
                {
                    return LineQualityVerdict.Pass;
                }
 
                return assessed.Any(result => result.Verdict == LineQualityVerdict.Marginal)
                    ? LineQualityVerdict.Marginal
                    : LineQualityVerdict.Fail;
            }
        }
 
        internal BaudRateResult AddBaudRate(int baudRate)
        {
            var result = new BaudRateResult(baudRate);
            _baudRates.Add(result);
            return result;
        }
    }
}