DreamineLogPanelViewModel.cs

이 파일의 문서화 페이지로 가기

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Threading;
using Dreamine.Logging.Interfaces;
using Dreamine.Logging.Models;
using Dreamine.Logging.Wpf.Services;
 
namespace Dreamine.Logging.Wpf.ViewModels
{
    public sealed class DreamineLogPanelViewModel : INotifyPropertyChanged, IDisposable
    {
        public const int DefaultDisplayCapacity = 1000;

        private readonly IDreamineLogStore _logStore;
        private readonly BatchedDispatcher<DreamineLogEntry?> _uiDispatcher;
        private readonly int _displayCapacity;
        private DreamineLogEntry? _selectedEntry;
        private bool _autoScroll = true;
        private bool _disposed;

        public event PropertyChangedEventHandler? PropertyChanged;

        public event EventHandler<DreamineLogEntry>? EntryAppended;

        public ObservableCollection<DreamineLogEntry> Entries { get; } = new LogEntryCollection();

        public bool AutoScroll
        {
            get => _autoScroll;
            set
            {
                if (_autoScroll == value)
                {
                    return;
                }
 
                _autoScroll = value;
                OnPropertyChanged();
            }
        }

        public DreamineLogEntry? SelectedEntry
        {
            get => _selectedEntry;
            set
            {
                if (ReferenceEquals(_selectedEntry, value))
                {
                    return;
                }
 
                _selectedEntry = value;
                OnPropertyChanged();
                OnPropertyChanged(nameof(SelectedDetailText));
            }
        }

        public string SelectedDetailText => SelectedEntry?.DisplayText ?? string.Empty;

        public DreamineLogPanelViewModel(
            IDreamineLogStore logStore,
            ILogUiDispatcher dispatcher)
            : this(logStore, dispatcher, DefaultDisplayCapacity)
        {
        }

        public DreamineLogPanelViewModel(
            IDreamineLogStore logStore,
            ILogUiDispatcher dispatcher,
            int displayCapacity)
        {
            _logStore = logStore ?? throw new ArgumentNullException(nameof(logStore));
            ArgumentNullException.ThrowIfNull(dispatcher);
 
            _displayCapacity = displayCapacity > 0 ? displayCapacity : DefaultDisplayCapacity;
 
            _uiDispatcher = new BatchedDispatcher<DreamineLogEntry?>(
                dispatcher.Dispatcher,
                OnEntriesBatch,
                DispatcherPriority.Background);
 
            // Seed with whatever the store already has, capped to display capacity.
            var existing = _logStore.GetEntries();
            var skip = Math.Max(0, existing.Count - _displayCapacity);
            for (var i = skip; i < existing.Count; i++)
            {
                Entries.Add(existing[i]);
            }
 
            _logStore.LogAdded += OnLogAdded;
        }

        public void Clear()
        {
            _logStore.Clear();
 
            // Sentinel: null indicates "clear" within the batch stream.
            _uiDispatcher.Enqueue(null);
        }

        public void Dispose()
        {
            if (_disposed)
            {
                return;
            }
 
            _disposed = true;
            _logStore.LogAdded -= OnLogAdded;
        }

        private void OnLogAdded(object? sender, DreamineLogEntry entry)
        {
            if (_disposed)
            {
                return;
            }
 
            // Producer side: any thread. Just enqueue.
            _uiDispatcher.Enqueue(entry);
        }

        private void OnEntriesBatch(IReadOnlyList<DreamineLogEntry?> batch)
        {
            // UI thread.
            if (_disposed)
            {
                return;
            }
 
            DreamineLogEntry? lastAppended = null;
 
            foreach (var entry in batch)
            {
                if (entry is null)
                {
                    // Clear sentinel.
                    Entries.Clear();
                    SelectedEntry = null;
                    lastAppended = null;
                    continue;
                }
 
                Entries.Add(entry);
                lastAppended = entry;
            }
 
            // Enforce display cap. Trim from the front in one reset notification.
            var overflow = Entries.Count - _displayCapacity;
            if (overflow > 0 && Entries is LogEntryCollection logEntries)
            {
                logEntries.TrimStart(overflow);
            }
 
            if (lastAppended is not null)
            {
                if (_autoScroll)
                {
                    SelectedEntry = lastAppended;
                }
 
                EntryAppended?.Invoke(this, lastAppended);
            }
        }

        private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        private sealed class LogEntryCollection : ObservableCollection<DreamineLogEntry>
        {
            public void TrimStart(int count)
            {
                if (count <= 0)
                {
                    return;
                }
 
                int removeCount = Math.Min(count, Items.Count);
                for (var i = 0; i < removeCount; i++)
                {
                    Items.RemoveAt(0);
                }
 
                OnPropertyChanged(new PropertyChangedEventArgs(nameof(Count)));
                OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
            }
        }
    }
}