edjournal/JournalStream.cs

using System;
using System.Linq;
using System.Collections.Generic;
using System.IO;

namespace EDJournal {
    public class JournalStream {
        private PlayerJournal journal = null;
        private FileSystemWatcher watcher = null;

        private Dictionary<string, StreamReader> streams = new Dictionary<string, StreamReader>();

        public delegate void NewJournalEntryDelegate(Entry entry);

        public event NewJournalEntryDelegate NewJournalEntry;

        public PlayerJournal Journal {
            get => journal;
            set => journal = value;
        }

        public JournalStream() {
        }

        public JournalStream(PlayerJournal journal) {
            this.journal = journal;
            Open();
        }

        private void AddFileToStreams(string path, bool seekend = false) {
            if (!streams.ContainsKey(path) && JournalFile.VerifyFile(path)) {
                var filestream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                streams[path] = new StreamReader(filestream);

                if (seekend) {
                    streams[path].BaseStream.Seek(0, SeekOrigin.End);
                }
            }
        }

        public void Open() {
            if (watcher != null) {
                return;
            }

            if (journal.Files.Count > 0) {
                JournalFile lastfile = journal.GetLastFile();
                /* add last file to stream */
                AddFileToStreams(lastfile.FullPath, true);
            }

            watcher = new FileSystemWatcher(journal.Location);

            watcher.NotifyFilter = NotifyFilters.FileName |
                NotifyFilters.LastWrite |
                NotifyFilters.Size;

            watcher.Changed += Watcher_Changed;
            watcher.Created += Watcher_Created;

            watcher.Filter = "*.log";
            watcher.EnableRaisingEvents = true;
        }

        public void Close() {
            if (watcher != null) {
                watcher.EnableRaisingEvents = false;
            }
            watcher = null;
            streams.Clear();
        }

        private void Watcher_Created(object sender, FileSystemEventArgs e) {
            AddFileToStreams(e.FullPath);
        }

        private void Watcher_Changed(object sender, FileSystemEventArgs e) {
            AddFileToStreams(e.FullPath);

            var stream = streams[e.FullPath];
            if (stream == null) {
                return;
            }

            string line;

            while ((line = stream.ReadLine()) != null) {
                try {
                    Entry entry = Entry.Parse(line);
                    NewJournalEntry?.Invoke(entry);
                } catch (Exception) {
                }
            }
        }
    }
}