public class DeliveryLogReader
    {
        private readonly string _logPath;
        private readonly Regex _regexDelivered;
        private readonly Regex _regexBounced;
        private readonly Regex _regexReason;

        public DeliveryLogReader(string logPath)
        {
            _logPath = logPath;
            _regexDelivered = new Regex(@"^(?<timeStamp>\d{2}:\d{2}:\d{2}\.\d{3}) \[(?<sessionId>\d+)\] Delivery for (?<from>\S+) to (?<to>\S+) has completed \(Delivered\)", RegexOptions.Compiled);
            _regexBounced = new Regex(@"^(?<timeStamp>\d{2}:\d{2}:\d{2}\.\d{3}) \[(?<sessionId>\d+)\] Delivery for (?<from>\S+) to (?<to>\S+) has bounced\. Reason: (Remote host said: )?(?<reason>.+)$", RegexOptions.Compiled);
            _regexReason = new Regex(@"^(?<code>\d{3}) (?<subCode>[\d\.]+)? ?(?<reasonDetail>.+)$", RegexOptions.Compiled);
        }

        public void ReadDeliveryLogs()
        {
            var files = Directory.GetFiles(_logPath);
            foreach (var file in files)
            {
                var fileName = Path.GetFileName(file);
                if (fileName.EndsWith("-delivery.log"))
                {
                    Log.Information("Parsing delivery log file: {fileName}", fileName);

                    var results = new DeliveryLogReaderResults();

                    var date = fileName.Substring(0, 10);

                    foreach (var line in File.ReadLines(file))
                    {
                        ProcessDelivered(date, line, results);
                        ProcessBounced(date, line, results);
                    }

                    ReportResults(results);
                }
            }
        }

        private void ProcessDelivered(string date, string line, DeliveryLogReaderResults results)
        {
            var match = _regexDelivered.Match(line);
            if (match.Success)
            {
                var groups = match.Groups;
                results.AddDeliveredResult(date, groups["timeStamp"].Value, groups["sessionId"].Value, groups["from"].Value, groups["to"].Value);
            }
        }

        private void ProcessBounced(string date, string line, DeliveryLogReaderResults results)
        {
            var match = _regexBounced.Match(line);
            if (match.Success)
            {
                var groups = match.Groups;
                var reasonMatch = _regexReason.Match(groups["reason"].Value);

                if (reasonMatch.Success)
                {
                    var reasonGroups = reasonMatch.Groups;
                    results.AddBouncedResult(date, groups["timeStamp"].Value, groups["sessionId"].Value, groups["from"].Value, groups["to"].Value, reasonGroups["code"].Value, reasonGroups["subCode"].Value, reasonGroups["reasonDetail"].Value);
                }
                else
                {
                    results.AddBouncedResult(date, groups["timeStamp"].Value, groups["sessionId"].Value, groups["from"].Value, groups["to"].Value, null, null, groups["reason"].Value);

                }
            }
        }

        private void ReportResults(DeliveryLogReaderResults results)
        {
            foreach (var r in results.BouncedMessages)
            {
                Log.Information("{from} -> {to} bounced: {code} {subCode} {reason}", r.From, r.To, r.Code, r.ExtendedCode, r.Reason);
            }
            var countOfCode = results.BouncedMessages
                .GroupBy(r => r.Code)
                .Select(g => new 
                    { Code = g.Key, Count = g.Count() })
                .OrderByDescending(g => g.Count);

            foreach (var code in countOfCode)
            {
                Log.Information("Code: {code} seen {count} times", code.Code, code.Count);
            }
        }