// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// Copyright (C) LibreHardwareMonitor and Contributors.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using LibreHardwareMonitor.Hardware;
using LibreHardwareMonitor.Hardware.Storage;
using LibreHardwareMonitor.Windows.WinUI.Services;
using LibreHardwareMonitor.Windows.WinUI.Utilities;
using Microsoft.UI.Dispatching;
using Microsoft.UI.Xaml;
using Windows.UI;

namespace LibreHardwareMonitor.Windows.WinUI.ViewModels;

public sealed class MainWindowViewModel : ViewModelBase, IDisposable
{
    private static readonly TimeSpan[] LoggingIntervals =
    [
        TimeSpan.FromSeconds(1),
        TimeSpan.FromSeconds(2),
        TimeSpan.FromSeconds(5),
        TimeSpan.FromSeconds(10),
        TimeSpan.FromSeconds(30),
        TimeSpan.FromMinutes(1),
        TimeSpan.FromMinutes(2),
        TimeSpan.FromMinutes(5),
        TimeSpan.FromMinutes(10),
        TimeSpan.FromMinutes(30),
        TimeSpan.FromHours(1),
        TimeSpan.FromHours(2),
        TimeSpan.FromHours(6)
    ];

    private static readonly TimeSpan[] UpdateIntervals =
    [
        TimeSpan.FromMilliseconds(250),
        TimeSpan.FromMilliseconds(500),
        TimeSpan.FromSeconds(1),
        TimeSpan.FromSeconds(2),
        TimeSpan.FromSeconds(5),
        TimeSpan.FromSeconds(10)
    ];

    private static readonly TimeSpan[] SensorValuesTimeWindows =
    [
        TimeSpan.FromSeconds(30),
        TimeSpan.FromMinutes(1),
        TimeSpan.FromMinutes(2),
        TimeSpan.FromMinutes(5),
        TimeSpan.FromMinutes(10),
        TimeSpan.FromMinutes(30),
        TimeSpan.FromHours(1),
        TimeSpan.FromHours(2),
        TimeSpan.FromHours(6),
        TimeSpan.FromHours(12),
        TimeSpan.FromHours(24)
    ];

    private const int DefaultPlotTimeWindowIndex = 2;
    private static readonly TimeSpan MaximumPlotPointRetention = TimeSpan.FromHours(24);
    private static readonly TimeSpan MaximumSyntheticPlotPointRetention = TimeSpan.FromMinutes(5);

    private static readonly TimeSpan?[] PlotTimeWindows =
    [
        null,
        TimeSpan.FromMinutes(5),
        TimeSpan.FromMinutes(10),
        TimeSpan.FromMinutes(20),
        TimeSpan.FromMinutes(30),
        TimeSpan.FromMinutes(45),
        TimeSpan.FromHours(1),
        TimeSpan.FromMinutes(90),
        TimeSpan.FromHours(2),
        TimeSpan.FromHours(3),
        TimeSpan.FromHours(6),
        TimeSpan.FromHours(12),
        TimeSpan.FromHours(24)
    ];

    private static readonly Color[] PlotColors =
    [
        Color.FromArgb(255, 0x00, 0x78, 0xD4),
        Color.FromArgb(255, 0xE8, 0x11, 0x23),
        Color.FromArgb(255, 0x10, 0x7C, 0x10),
        Color.FromArgb(255, 0xF7, 0x63, 0x0C),
        Color.FromArgb(255, 0x88, 0x17, 0x98),
        Color.FromArgb(255, 0x00, 0xB7, 0xC3),
        Color.FromArgb(255, 0x49, 0x8B, 0x00),
        Color.FromArgb(255, 0xA8, 0x00, 0x00)
    ];

    private readonly HardwareMonitorService _hardwareMonitor;
    private readonly DispatcherQueue _dispatcherQueue;
    private readonly Logger _logger;
    private readonly Dictionary<string, PlotSeriesViewModel> _plotSeriesByIdentifier = new();
    private readonly RemoteWebServer _remoteWebServer;
    private readonly StartupService _startupService = new();
    private readonly WinUiStartupTrace? _startupTrace;
    private AppThemeMode _themeMode;
    private int _loggingIntervalIndex;
    private PlotLocation _plotLocation;
    private bool _plotStackedAxes;
    private double _plotStrokeThickness;
    private bool _plotTimeAxisZoomEnabled;
    private int _plotTimeWindowIndex;
    private bool _plotValueAxesZoomEnabled;
    private SensorTreeItemViewModel? _selectedItem;
    private int _sensorValuesTimeWindowIndex;
    private bool _showHiddenSensors;
    private bool _showMaxColumn;
    private bool _showMinColumn;
    private bool _showPlotAxisLabels;
    private bool _showPlot;
    private bool _showValueColumn;
    private bool _throttleAtaUpdate;
    private bool _isHardwareLoading = true;
    private bool _isStarted;
    private bool _isStarting;
    private int _rootUpdateQueued;
    private string _statusText = "";
    private TemperatureUnit _temperatureUnit;
    private int _updateIntervalIndex;

    public MainWindowViewModel(AppSettings settings) : this(settings, null)
    {
    }

    internal MainWindowViewModel(AppSettings settings, WinUiStartupTrace? startupTrace)
    {
        Settings = settings;
        _startupTrace = startupTrace;
        _startupTrace?.Mark("MainWindowViewModel.Constructor.Begin");
        _dispatcherQueue = DispatcherQueue.GetForCurrentThread();
        _hardwareMonitor = new HardwareMonitorService(settings);
        _logger = new Logger(_hardwareMonitor.Computer);
        _remoteWebServer = new RemoteWebServer(
            () => RootItems.FirstOrDefault(),
            _hardwareMonitor.Computer,
            _hardwareMonitor.SensorReadLock,
            settings.GetValue("listenerIp", "?"),
            settings.GetValue("listenerPort", 8085),
            settings.GetValue("authenticationEnabled", false),
            settings.GetValue("authenticationUserName", ""),
            settings.GetValue("authenticationPassword", ""));
        _hardwareMonitor.TreeRebuilt += HardwareMonitor_TreeRebuilt;

        _themeMode = ParseThemeMode(settings.GetValue("theme", "auto"));
        _showHiddenSensors = settings.GetValue("hiddenMenuItem", false);
        _showValueColumn = settings.GetValue("valueMenuItem", true);
        _showMinColumn = settings.GetValue("minMenuItem", false);
        _showMaxColumn = settings.GetValue("maxMenuItem", true);
        _showPlot = settings.GetValue("plotMenuItem", false);
        _plotLocation = (PlotLocation)Math.Clamp(settings.GetValue("plotLocation", 0), 0, 2);
        _plotStrokeThickness = Math.Clamp(settings.GetValue("plotStroke", 1) + 1, 1, 4);
        _plotStackedAxes = settings.GetValue("stackedAxes", true);
        _showPlotAxisLabels = settings.GetValue("showAxesLabels", true);
        _plotTimeAxisZoomEnabled = settings.GetValue("timeAxisEnableZoom", true);
        _plotValueAxesZoomEnabled = settings.GetValue("yAxesEnableZoom", true);
        int plotTimeWindowDefault = GetPlotTimeWindowIndex(settings.GetValue("plotPanel.MaxTimeSpan", 10.0f * 60));
        _plotTimeWindowIndex = Math.Clamp(settings.GetValue("plotTimeWindow", plotTimeWindowDefault), 0, PlotTimeWindows.Length - 1);
        _temperatureUnit = (TemperatureUnit)Math.Clamp(settings.GetValue("TemperatureUnit", 0), 0, 1);
        _updateIntervalIndex = Math.Clamp(settings.GetValue("updateIntervalMenuItem", 2), 0, UpdateIntervals.Length - 1);
        _loggingIntervalIndex = Math.Clamp(settings.GetValue("loggingInterval", 0), 0, LoggingIntervals.Length - 1);
        _sensorValuesTimeWindowIndex = Math.Clamp(settings.GetValue("sensorValuesTimeWindow", 10), 0, SensorValuesTimeWindows.Length - 1);
        _throttleAtaUpdate = settings.GetValue("throttleAtaUpdateMenuItem", false);
        StorageDevice.ThrottleInterval = _throttleAtaUpdate ? TimeSpan.FromSeconds(30) : TimeSpan.Zero;
        _logger.LoggingInterval = LoggingIntervals[_loggingIntervalIndex];
        _logger.FileRotationMethod = (LoggerFileRotation)Math.Clamp(settings.GetValue("logger.fileRotation", 0), 0, 1);
        _startupTrace?.Mark("MainWindowViewModel.Constructor.Complete");
    }

    public event EventHandler? PlotInvalidated;

    public event EventHandler? GadgetSensorsChanged;

    public event EventHandler? TraySensorsChanged;

    public Visibility MaxColumnVisibility => ShowMaxColumn ? Visibility.Visible : Visibility.Collapsed;

    public Visibility MinColumnVisibility => ShowMinColumn ? Visibility.Visible : Visibility.Collapsed;

    public ObservableCollection<PlotSeriesViewModel> PlotSeries { get; } = [];

    public bool IsPlotWindowVisible => ShowPlot && PlotLocation == PlotLocation.Window;

    public Visibility PlotVisibility => ShowPlot && PlotLocation != PlotLocation.Window ? Visibility.Visible : Visibility.Collapsed;

    public ObservableCollection<SensorTreeItemViewModel> RootItems { get; } = [];

    public SensorTreeItemViewModel? SelectedItem
    {
        get => _selectedItem;
        set => SetProperty(ref _selectedItem, value);
    }

    public AppSettings Settings { get; }

    public string StatusText
    {
        get => _statusText;
        private set => SetProperty(ref _statusText, value);
    }

    public AppThemeMode ThemeMode
    {
        get => _themeMode;
        set
        {
            if (!SetProperty(ref _themeMode, value))
                return;

            Settings.SetValue("theme", FormatThemeMode(value));
        }
    }

    public TimeSpan UpdateInterval => UpdateIntervals[UpdateIntervalIndex];

    public Visibility ValueColumnVisibility => ShowValueColumn ? Visibility.Visible : Visibility.Collapsed;

    public bool AuthWebServer
    {
        get => _remoteWebServer.AuthEnabled;
        set
        {
            if (_remoteWebServer.AuthEnabled == value)
                return;

            _remoteWebServer.AuthEnabled = value;
            Settings.SetValue("authenticationEnabled", value);
            RestartWebServerIfRunning();
            OnPropertyChanged();
        }
    }

    public string AuthWebServerUserName
    {
        get => _remoteWebServer.UserName;
        set
        {
            if (_remoteWebServer.UserName == value)
                return;

            _remoteWebServer.UserName = value;
            Settings.SetValue("authenticationUserName", value);
            RestartWebServerIfRunning();
            OnPropertyChanged();
        }
    }

    public LoggerFileRotation FileRotationMethod
    {
        get => _logger.FileRotationMethod;
        set
        {
            if (_logger.FileRotationMethod == value)
                return;

            _logger.FileRotationMethod = value;
            Settings.SetValue("logger.fileRotation", (int)value);
            OnPropertyChanged();
        }
    }

    public bool ForceDriveWakeup
    {
        get => _hardwareMonitor.ForceDriveWakeup;
        set
        {
            if (_hardwareMonitor.ForceDriveWakeup == value)
                return;

            _hardwareMonitor.ForceDriveWakeup = value;
            OnPropertyChanged();
        }
    }

    public bool IsBatteryEnabled
    {
        get => _hardwareMonitor.IsBatteryEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsBatteryEnabled, v => _hardwareMonitor.IsBatteryEnabled = v);
    }

    public bool IsControllerEnabled
    {
        get => _hardwareMonitor.IsControllerEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsControllerEnabled, v => _hardwareMonitor.IsControllerEnabled = v);
    }

    public bool IsCpuEnabled
    {
        get => _hardwareMonitor.IsCpuEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsCpuEnabled, v => _hardwareMonitor.IsCpuEnabled = v);
    }

    public bool IsGpuEnabled
    {
        get => _hardwareMonitor.IsGpuEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsGpuEnabled, v => _hardwareMonitor.IsGpuEnabled = v);
    }

    public bool IsMemoryEnabled
    {
        get => _hardwareMonitor.IsMemoryEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsMemoryEnabled, v => _hardwareMonitor.IsMemoryEnabled = v);
    }

    public bool IsMotherboardEnabled
    {
        get => _hardwareMonitor.IsMotherboardEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsMotherboardEnabled, v => _hardwareMonitor.IsMotherboardEnabled = v);
    }

    public bool IsNetworkEnabled
    {
        get => _hardwareMonitor.IsNetworkEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsNetworkEnabled, v => _hardwareMonitor.IsNetworkEnabled = v);
    }

    public bool IsPowerMonitorEnabled
    {
        get => _hardwareMonitor.IsPowerMonitorEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsPowerMonitorEnabled, v => _hardwareMonitor.IsPowerMonitorEnabled = v);
    }

    public bool IsPsuEnabled
    {
        get => _hardwareMonitor.IsPsuEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsPsuEnabled, v => _hardwareMonitor.IsPsuEnabled = v);
    }

    public bool IsStorageEnabled
    {
        get => _hardwareMonitor.IsStorageEnabled;
        set => SetHardwareFlag(value, _hardwareMonitor.IsStorageEnabled, v => _hardwareMonitor.IsStorageEnabled = v);
    }

    public int LoggingIntervalIndex
    {
        get => _loggingIntervalIndex;
        set
        {
            value = Math.Clamp(value, 0, LoggingIntervals.Length - 1);
            if (!SetProperty(ref _loggingIntervalIndex, value))
                return;

            Settings.SetValue("loggingInterval", value);
            _logger.LoggingInterval = LoggingIntervals[value];
        }
    }

    public string ListenerIp
    {
        get => _remoteWebServer.ListenerIp;
        set
        {
            if (_remoteWebServer.ListenerIp == value)
                return;

            _remoteWebServer.ListenerIp = value;
            Settings.SetValue("listenerIp", value);
            RestartWebServerIfRunning();
            OnPropertyChanged();
            OnPropertyChanged(nameof(WebServerUrl));
        }
    }

    public int ListenerPort
    {
        get => _remoteWebServer.ListenerPort;
        set
        {
            value = Math.Clamp(value, 1, 65535);
            if (_remoteWebServer.ListenerPort == value)
                return;

            _remoteWebServer.ListenerPort = value;
            Settings.SetValue("listenerPort", value);
            RestartWebServerIfRunning();
            OnPropertyChanged();
            OnPropertyChanged(nameof(WebServerUrl));
        }
    }

    public bool LogSensors
    {
        get => Settings.GetValue("logSensorsMenuItem", false);
        set
        {
            if (LogSensors == value)
                return;

            Settings.SetValue("logSensorsMenuItem", value);
            OnPropertyChanged();
        }
    }

    public bool ShowGadget
    {
        get => Settings.GetValue("gadgetMenuItem", false);
        set => SetBooleanSetting("gadgetMenuItem", value);
    }

    public bool RunWebServer
    {
        get => !IsWebServerUnavailable && Settings.GetValue("runWebServerMenuItem", false);
        set
        {
            if (IsWebServerUnavailable || RunWebServer == value)
                return;

            if (value)
            {
                if (!_remoteWebServer.Start())
                {
                    Settings.SetValue("runWebServerMenuItem", false);
                    StatusText = "Remote web server failed to start.";
                    OnPropertyChanged();
                    return;
                }
            }
            else
            {
                _remoteWebServer.Stop();
            }

            Settings.SetValue("runWebServerMenuItem", value);
            OnPropertyChanged();
            UpdateStatus();
        }
    }

    public int SensorValuesTimeWindowIndex
    {
        get => _sensorValuesTimeWindowIndex;
        set
        {
            value = Math.Clamp(value, 0, SensorValuesTimeWindows.Length - 1);
            if (!SetProperty(ref _sensorValuesTimeWindowIndex, value))
                return;

            Settings.SetValue("sensorValuesTimeWindow", value);
            ApplySensorValuesTimeWindow();
        }
    }

    public bool MinimizeOnClose
    {
        get => Settings.GetValue("minCloseMenuItem", false);
        set => SetBooleanSetting("minCloseMenuItem", value);
    }

    public bool MinimizeToTray
    {
        get => Settings.GetValue("minTrayMenuItem", true);
        set => SetBooleanSetting("minTrayMenuItem", value);
    }

    public PlotLocation PlotLocation
    {
        get => _plotLocation;
        set
        {
            if (!SetProperty(ref _plotLocation, value))
                return;

            Settings.SetValue("plotLocation", (int)value);
            NotifyPlotLayoutChanged();
            PlotInvalidated?.Invoke(this, EventArgs.Empty);
        }
    }

    public int PlotGridColumn => PlotLocation == PlotLocation.Right ? 1 : 0;

    public int PlotGridColumnSpan => PlotLocation == PlotLocation.Bottom ? 2 : 1;

    public int PlotGridRow => PlotLocation == PlotLocation.Bottom ? 1 : 0;

    public int PlotGridRowSpan => PlotLocation == PlotLocation.Right ? 2 : 1;

    public bool PlotStackedAxes
    {
        get => _plotStackedAxes;
        set
        {
            if (!SetProperty(ref _plotStackedAxes, value))
                return;

            Settings.SetValue("stackedAxes", value);
            PlotInvalidated?.Invoke(this, EventArgs.Empty);
        }
    }

    public double PlotStrokeThickness
    {
        get => _plotStrokeThickness;
        set
        {
            value = Math.Clamp(value, 1, 4);
            if (!SetProperty(ref _plotStrokeThickness, value))
                return;

            Settings.SetValue("plotStroke", (int)value - 1);
            PlotInvalidated?.Invoke(this, EventArgs.Empty);
        }
    }

    public TimeSpan? PlotTimeWindow => PlotTimeWindows[PlotTimeWindowIndex];

    public bool PlotTimeAxisZoomEnabled
    {
        get => _plotTimeAxisZoomEnabled;
        set
        {
            if (!SetProperty(ref _plotTimeAxisZoomEnabled, value))
                return;

            Settings.SetValue("timeAxisEnableZoom", value);
        }
    }

    public int PlotTimeWindowIndex
    {
        get => _plotTimeWindowIndex;
        set
        {
            value = Math.Clamp(value, 0, PlotTimeWindows.Length - 1);
            if (!SetProperty(ref _plotTimeWindowIndex, value))
                return;

            Settings.SetValue("plotTimeWindow", value);
            Settings.SetValue("plotPanel.MinTimeSpan", 0.0f);
            Settings.SetValue("plotPanel.MaxTimeSpan", PlotTimeWindow.HasValue ? (float)PlotTimeWindow.Value.TotalSeconds : float.NaN);
            OnPropertyChanged(nameof(PlotTimeWindow));
            PlotInvalidated?.Invoke(this, EventArgs.Empty);
        }
    }

    public bool PlotValueAxesZoomEnabled
    {
        get => _plotValueAxesZoomEnabled;
        set
        {
            if (!SetProperty(ref _plotValueAxesZoomEnabled, value))
                return;

            Settings.SetValue("yAxesEnableZoom", value);
        }
    }

    public bool ShowHiddenSensors
    {
        get => _showHiddenSensors;
        set
        {
            if (!SetProperty(ref _showHiddenSensors, value))
                return;

            Settings.SetValue("hiddenMenuItem", value);
            RootItems.FirstOrDefault()?.SetShowHiddenSensors(value);
        }
    }

    public bool ShowMaxColumn
    {
        get => _showMaxColumn;
        set
        {
            if (!SetProperty(ref _showMaxColumn, value))
                return;

            Settings.SetValue("maxMenuItem", value);
            NotifyColumnVisibilityChanged();
        }
    }

    public bool ShowMinColumn
    {
        get => _showMinColumn;
        set
        {
            if (!SetProperty(ref _showMinColumn, value))
                return;

            Settings.SetValue("minMenuItem", value);
            NotifyColumnVisibilityChanged();
        }
    }

    public bool ShowPlotAxisLabels
    {
        get => _showPlotAxisLabels;
        set
        {
            if (!SetProperty(ref _showPlotAxisLabels, value))
                return;

            Settings.SetValue("showAxesLabels", value);
            PlotInvalidated?.Invoke(this, EventArgs.Empty);
        }
    }

    public bool ShowPlot
    {
        get => _showPlot;
        set
        {
            if (!SetProperty(ref _showPlot, value))
                return;

            Settings.SetValue("plotMenuItem", value);
            OnPropertyChanged(nameof(PlotVisibility));
            OnPropertyChanged(nameof(IsPlotWindowVisible));
            NotifyPlotLayoutChanged();
            PlotInvalidated?.Invoke(this, EventArgs.Empty);
        }
    }

    public bool ShowValueColumn
    {
        get => _showValueColumn;
        set
        {
            if (!SetProperty(ref _showValueColumn, value))
                return;

            Settings.SetValue("valueMenuItem", value);
            NotifyColumnVisibilityChanged();
        }
    }

    public bool StartMinimized
    {
        get => Settings.GetValue("startMinMenuItem", false);
        set => SetBooleanSetting("startMinMenuItem", value);
    }

    public bool ThrottleAtaUpdate
    {
        get => _throttleAtaUpdate;
        set
        {
            if (!SetProperty(ref _throttleAtaUpdate, value))
                return;

            Settings.SetValue("throttleAtaUpdateMenuItem", value);
            StorageDevice.ThrottleInterval = value ? TimeSpan.FromSeconds(30) : TimeSpan.Zero;
        }
    }

    public bool IsWebServerUnavailable => _remoteWebServer.PlatformNotSupported;

    public bool IsHardwareInteractionEnabled => !IsHardwareLoading;

    public bool IsHardwareLoading
    {
        get => _isHardwareLoading;
        private set
        {
            if (!SetProperty(ref _isHardwareLoading, value))
                return;

            OnPropertyChanged(nameof(HardwareLoadingVisibility));
            OnPropertyChanged(nameof(IsHardwareInteractionEnabled));
        }
    }

    public Visibility HardwareLoadingVisibility => IsHardwareLoading ? Visibility.Visible : Visibility.Collapsed;

    public string WebServerUrl
    {
        get
        {
            string host = ListenerIp is "?" or "+" or "*" or "0.0.0.0" ? "localhost" : ListenerIp;
            return $"http://{host}:{ListenerPort}/";
        }
    }

    public bool RunOnStartup
    {
        get => _startupService.IsAvailable && _startupService.Startup;
        set
        {
            if (!_startupService.IsAvailable || RunOnStartup == value)
                return;

            try
            {
                _startupService.Startup = value;
                OnPropertyChanged();
            }
            catch (InvalidOperationException)
            {
                OnPropertyChanged();
            }
        }
    }

    public int SensorGridColumnSpan => ShowPlot && PlotLocation == PlotLocation.Right ? 1 : 2;

    public int SensorGridRowSpan => ShowPlot && PlotLocation == PlotLocation.Bottom ? 1 : 2;

    public TemperatureUnit TemperatureUnit
    {
        get => _temperatureUnit;
        set
        {
            if (!SetProperty(ref _temperatureUnit, value))
                return;

            Settings.SetValue("TemperatureUnit", (int)value);
            RootItems.FirstOrDefault()?.SetTemperatureUnit(value);
            PlotInvalidated?.Invoke(this, EventArgs.Empty);
        }
    }

    public int UpdateIntervalIndex
    {
        get => _updateIntervalIndex;
        set
        {
            value = Math.Clamp(value, 0, UpdateIntervals.Length - 1);
            if (!SetProperty(ref _updateIntervalIndex, value))
                return;

            Settings.SetValue("updateIntervalMenuItem", value);
            OnPropertyChanged(nameof(UpdateInterval));
        }
    }

    public void Dispose()
    {
        _hardwareMonitor.TreeRebuilt -= HardwareMonitor_TreeRebuilt;
        Settings.SetValue("listenerIp", ListenerIp);
        Settings.SetValue("listenerPort", ListenerPort);
        Settings.SetValue("authenticationEnabled", AuthWebServer);
        Settings.SetValue("authenticationUserName", AuthWebServerUserName);
        Settings.SetValue("authenticationPassword", _remoteWebServer.PasswordSHA256);
        _remoteWebServer.Quit();
        _hardwareMonitor.Dispose();
        Save();
    }

    public string GetReport()
    {
        return _hardwareMonitor.Computer.GetReport();
    }

    public void ResetHardware()
    {
        _hardwareMonitor.Reset();
        UpdateStatus();
    }

    public void ResetMinMax()
    {
        _hardwareMonitor.ResetMinMax();
        RootItems.FirstOrDefault()?.RefreshValues();
    }

    public void ResetPlot()
    {
        _hardwareMonitor.ClearSensorValues();
        _plotSeriesByIdentifier.Clear();
        PlotSeries.Clear();
        PlotInvalidated?.Invoke(this, EventArgs.Empty);
    }

    public void RefreshPlotSeries()
    {
        TrackPlotPoints();
        PlotInvalidated?.Invoke(this, EventArgs.Empty);
    }

    public void Save()
    {
        Settings.Save();
    }

    public void SetStatusText(string statusText)
    {
        StatusText = statusText;
    }

    public void SetAllExpanded(bool isExpanded)
    {
        RootItems.FirstOrDefault()?.SetAllExpanded(isExpanded);
    }

    public void SetAuthPassword(string plainPassword)
    {
        if (string.IsNullOrWhiteSpace(plainPassword))
            return;

        _remoteWebServer.SetPassword(plainPassword);
        Settings.SetValue("authenticationPassword", _remoteWebServer.PasswordSHA256);
        RestartWebServerIfRunning();
    }

    public bool IsSensorInGadget(SensorTreeItemViewModel item)
    {
        return item.Sensor != null && Settings.GetValue(GetSensorSettingName(item.Sensor, "gadget"), false);
    }

    public bool IsSensorInTray(SensorTreeItemViewModel item)
    {
        return item.Sensor != null && Settings.GetValue(GetSensorSettingName(item.Sensor, "tray"), false);
    }

    public IEnumerable<SensorTreeItemViewModel> GetGadgetSensorItems()
    {
        return RootItems.FirstOrDefault()?.EnumerateSensors().Where(IsSensorInGadget) ?? [];
    }

    public IEnumerable<SensorTreeItemViewModel> GetTraySensorItems()
    {
        return RootItems.FirstOrDefault()?.EnumerateSensors().Where(IsSensorInTray) ?? [];
    }

    public void SetSensorInGadget(SensorTreeItemViewModel item, bool value)
    {
        if (item.Sensor == null)
            return;

        SetSensorBooleanSetting(item.Sensor, "gadget", value);
        GadgetSensorsChanged?.Invoke(this, EventArgs.Empty);
    }

    public void SetSensorInTray(SensorTreeItemViewModel item, bool value)
    {
        if (item.Sensor == null)
            return;

        SetSensorBooleanSetting(item.Sensor, "tray", value);
        if (!value)
            Settings.Remove(GetSensorSettingName(item.Sensor, "traycolor"));
        TraySensorsChanged?.Invoke(this, EventArgs.Empty);
    }

    public void SetSensorPenColor(SensorTreeItemViewModel item, Color? color)
    {
        if (item.Sensor == null)
            return;

        item.PenColor = color;
        string identifier = item.Sensor.Identifier.ToString();
        if (_plotSeriesByIdentifier.TryGetValue(identifier, out PlotSeriesViewModel? series))
            series.Color = GetPlotColor(item);

        PlotInvalidated?.Invoke(this, EventArgs.Empty);
    }

    public async Task StartAsync()
    {
        if (_isStarted || _isStarting)
            return;

        _isStarting = true;
        try
        {
            IsHardwareLoading = true;
            _startupTrace?.Mark("MainWindowViewModel.StartAsync.Begin");
            StatusText = "Initializing hardware sensors...";
            await MeasureStartupAsync("MainWindowViewModel.HardwareMonitor.OpenAsync", () => _hardwareMonitor.OpenAsync(raiseTreeRebuilt: false));
            MeasureStartup("MainWindowViewModel.UpdateRoot", UpdateRoot, GetRootDetail);
            StatusText = "Reading sensor values...";
            await MeasureStartupAsync("MainWindowViewModel.InitialSensorValueUpdate", () => RefreshSensorValuesAsync(trackPlotPoints: true, logSensors: false));
            MeasureStartup("MainWindowViewModel.StartWebServerFromSettings", StartWebServerFromSettings);
            MeasureStartup("MainWindowViewModel.UpdateStatus", UpdateStatus, GetRootDetail);
            _isStarted = true;
            _startupTrace?.Mark("MainWindowViewModel.StartAsync.Complete", GetRootDetail());
        }
        finally
        {
            IsHardwareLoading = false;
            _startupTrace?.Mark("MainWindowViewModel.HardwareLoadingComplete", GetRootDetail());
            _isStarting = false;
        }
    }

    public async Task UpdateAsync()
    {
        if (!_isStarted)
            return;

        await RefreshSensorValuesAsync(trackPlotPoints: true, logSensors: LogSensors);
    }

    private async Task RefreshSensorValuesAsync(bool trackPlotPoints, bool logSensors)
    {
        await _hardwareMonitor.UpdateAsync();

        SensorTreeItemViewModel? root = RootItems.FirstOrDefault();
        root?.RefreshValues();
        if (trackPlotPoints)
            TrackPlotPoints();

        if (logSensors)
            _logger.Log();

        UpdateStatus();
    }

    private void HardwareMonitor_TreeRebuilt(object? sender, EventArgs e)
    {
        if (_dispatcherQueue.HasThreadAccess)
        {
            UpdateRoot();
            UpdateStatus();
            return;
        }

        if (Interlocked.Exchange(ref _rootUpdateQueued, 1) == 1)
            return;

        if (!_dispatcherQueue.TryEnqueue(() =>
        {
            try
            {
                UpdateRoot();
                UpdateStatus();
            }
            finally
            {
                Interlocked.Exchange(ref _rootUpdateQueued, 0);
            }
        }))
        {
            Interlocked.Exchange(ref _rootUpdateQueued, 0);
        }
    }

    private void ApplySensorValuesTimeWindow()
    {
        TimeSpan timeWindow = SensorValuesTimeWindows[SensorValuesTimeWindowIndex];
        SensorVisitor visitor = new(sensor => sensor.ValuesTimeWindow = timeWindow);
        visitor.VisitComputer(_hardwareMonitor.Computer);
    }

    private string GetRootDetail()
    {
        int hardwareCount = _hardwareMonitor.Computer.Hardware.Count;
        int sensorCount = RootItems.FirstOrDefault()?.EnumerateSensors().Count() ?? 0;
        return $"{hardwareCount} hardware device(s), {sensorCount} sensor(s)";
    }

    private void MeasureStartup(string phase, Action action)
    {
        if (_startupTrace is not { IsComplete: false })
        {
            action();
            return;
        }

        _startupTrace.Measure(phase, action);
    }

    private void MeasureStartup(string phase, Action action, Func<string> getDetail)
    {
        if (_startupTrace is not { IsComplete: false })
        {
            action();
            return;
        }

        _startupTrace.Measure(phase, action, getDetail);
    }

    private T MeasureStartup<T>(string phase, Func<T> action)
    {
        if (_startupTrace is not { IsComplete: false })
            return action();

        return _startupTrace.Measure(phase, action);
    }

    private async Task MeasureStartupAsync(string phase, Func<Task> action)
    {
        if (_startupTrace is not { IsComplete: false })
        {
            await action();
            return;
        }

        await _startupTrace.MeasureAsync(phase, action);
    }

    private void NotifyColumnVisibilityChanged()
    {
        OnPropertyChanged(nameof(ValueColumnVisibility));
        OnPropertyChanged(nameof(MinColumnVisibility));
        OnPropertyChanged(nameof(MaxColumnVisibility));
        RootItems.FirstOrDefault()?.SetColumnVisibility(ShowValueColumn, ShowMinColumn, ShowMaxColumn);
    }

    private void NotifyPlotLayoutChanged()
    {
        OnPropertyChanged(nameof(PlotVisibility));
        OnPropertyChanged(nameof(IsPlotWindowVisible));
        OnPropertyChanged(nameof(PlotGridRow));
        OnPropertyChanged(nameof(PlotGridColumn));
        OnPropertyChanged(nameof(PlotGridRowSpan));
        OnPropertyChanged(nameof(PlotGridColumnSpan));
        OnPropertyChanged(nameof(SensorGridRowSpan));
        OnPropertyChanged(nameof(SensorGridColumnSpan));
    }

    private void SetBooleanSetting(string settingName, bool value)
    {
        if (Settings.GetValue(settingName, false) == value)
            return;

        Settings.SetValue(settingName, value);
        OnPropertyChanged();
    }

    private void SetSensorBooleanSetting(ISensor sensor, string suffix, bool value)
    {
        string settingName = GetSensorSettingName(sensor, suffix);
        if (value)
            Settings.SetValue(settingName, true);
        else
            Settings.Remove(settingName);
    }

    private static string GetSensorSettingName(ISensor sensor, string suffix)
    {
        return new Identifier(sensor.Identifier, suffix).ToString();
    }

    private void SetHardwareFlag(bool value, bool currentValue, Action<bool> setValue)
    {
        if (currentValue == value)
            return;

        setValue(value);
        UpdateRoot();
        OnPropertyChanged();
    }

    private void TrackPlotPoints()
    {
        SensorTreeItemViewModel? root = RootItems.FirstOrDefault();
        if (root == null)
            return;

        DateTime now = DateTime.UtcNow;
        HashSet<string> selectedIdentifiers = new();
        foreach (SensorTreeItemViewModel sensorItem in root.EnumerateSensors().Where(sensorItem => sensorItem.Plot && sensorItem.Sensor != null))
        {
            ISensor sensor = sensorItem.Sensor!;
            string identifier = sensor.Identifier.ToString();
            selectedIdentifiers.Add(identifier);

            if (!_plotSeriesByIdentifier.TryGetValue(identifier, out PlotSeriesViewModel? series))
            {
                series = new PlotSeriesViewModel(
                    identifier,
                    sensor.Hardware.Name,
                    sensor.Name,
                    sensor.SensorType,
                    SensorFormatter.GetPlotUnit(sensor.SensorType, TemperatureUnit),
                    GetPlotColor(sensorItem));
                _plotSeriesByIdentifier[identifier] = series;
                PlotSeries.Add(series);
            }
            else
            {
                series.UpdateMetadata(sensor.Hardware.Name, sensor.Name, sensor.SensorType, SensorFormatter.GetPlotUnit(sensor.SensorType, TemperatureUnit));

                // Only honor an explicit user pen color for an existing series; keep the auto-assigned color stable.
                // (Recomputing it from the live series count made existing lines shift/collide colors every tick.)
                if (sensorItem.PenColor.HasValue)
                    series.Color = sensorItem.PenColor.Value;
            }

            List<PlotPointViewModel> points = [];
            foreach (SensorValue sensorValue in sensor.Values.OrderBy(value => value.Time))
            {
                double? displayedValue = SensorFormatter.GetPlotValue(sensor, sensorValue.Value, TemperatureUnit);
                if (displayedValue is not { } pointValue || !double.IsFinite(pointValue))
                    continue;

                points.Add(new PlotPointViewModel(sensorValue.Time, pointValue));
            }

            DateTime? latestHistoryTimestamp = points.Count > 0 ? points[^1].Timestamp : null;
            foreach (PlotPointViewModel existingPoint in series.Points)
            {
                if (now - existingPoint.Timestamp > MaximumSyntheticPlotPointRetention)
                    continue;

                if (!latestHistoryTimestamp.HasValue || existingPoint.Timestamp > latestHistoryTimestamp.Value)
                    points.Add(existingPoint);
            }

            double? currentValue = SensorFormatter.GetPlotValue(sensor, TemperatureUnit);
            if (currentValue is { } currentPointValue && double.IsFinite(currentPointValue))
                points.Add(new PlotPointViewModel(now, currentPointValue));

            DateTime cutoff = now - MaximumPlotPointRetention;
            points = points
                .Where(point => point.Timestamp >= cutoff)
                .GroupBy(point => point.Timestamp.Ticks)
                .Select(group => group.Last())
                .OrderBy(point => point.Timestamp)
                .ToList();

            if (points.Count == 0 && currentValue is { } fallbackPointValue && double.IsFinite(fallbackPointValue))
            {
                points.Add(new PlotPointViewModel(now, fallbackPointValue));
            }

            series.ReplacePoints(points);
        }

        foreach (string identifier in _plotSeriesByIdentifier.Keys.Where(identifier => !selectedIdentifiers.Contains(identifier)).ToArray())
        {
            PlotSeriesViewModel series = _plotSeriesByIdentifier[identifier];
            _plotSeriesByIdentifier.Remove(identifier);
            PlotSeries.Remove(series);
        }
    }

    private void UpdateRoot()
    {
        MeasureStartup("MainWindowViewModel.RootItems.Clear", RootItems.Clear);
        SensorTreeItemViewModel root = MeasureStartup("MainWindowViewModel.GetHardwareRoot", () => _hardwareMonitor.Root);
        MeasureStartup("MainWindowViewModel.ConfigureRoot", () => root.Configure(TemperatureUnit, ShowHiddenSensors, ShowValueColumn, ShowMinColumn, ShowMaxColumn), GetRootDetail);
        MeasureStartup("MainWindowViewModel.RootItems.Add", () => RootItems.Add(root), GetRootDetail);
        MeasureStartup("MainWindowViewModel.ApplySensorValuesTimeWindow", ApplySensorValuesTimeWindow, GetRootDetail);
    }

    private void UpdateStatus()
    {
        int hardwareCount = _hardwareMonitor.Computer.Hardware.Count;
        int sensorCount = RootItems.FirstOrDefault()?.EnumerateSensors().Count() ?? 0;
        string webServerStatus = RunWebServer ? $", web server {WebServerUrl}" : "";
        StatusText = $"{hardwareCount} hardware devices, {sensorCount} sensors, update every {FormatInterval(UpdateInterval)}{webServerStatus}";
    }

    private Color GetPlotColor(SensorTreeItemViewModel sensorItem)
    {
        return sensorItem.PenColor ?? PlotColors[_plotSeriesByIdentifier.Count % PlotColors.Length];
    }

    private void RestartWebServerIfRunning()
    {
        if (!RunWebServer)
            return;

        _remoteWebServer.Stop();
        if (!_remoteWebServer.Start())
        {
            Settings.SetValue("runWebServerMenuItem", false);
            StatusText = "Remote web server failed to restart.";
        }

        OnPropertyChanged(nameof(RunWebServer));
        UpdateStatus();
    }

    private void StartWebServerFromSettings()
    {
        if (IsWebServerUnavailable || !Settings.GetValue("runWebServerMenuItem", false))
            return;

        if (!_remoteWebServer.Start())
        {
            Settings.SetValue("runWebServerMenuItem", false);
            StatusText = "Remote web server failed to start.";
        }

        OnPropertyChanged(nameof(RunWebServer));
    }

    private static AppThemeMode ParseThemeMode(string value)
    {
        return value.ToLowerInvariant() switch
        {
            "light" => AppThemeMode.Light,
            "dark" => AppThemeMode.Dark,
            "black" => AppThemeMode.Black,
            _ => AppThemeMode.Auto
        };
    }

    private static string FormatThemeMode(AppThemeMode themeMode)
    {
        return themeMode switch
        {
            AppThemeMode.Light => "light",
            AppThemeMode.Dark => "dark",
            AppThemeMode.Black => "black",
            _ => "auto"
        };
    }

    private static int GetPlotTimeWindowIndex(float maxSeconds)
    {
        if (!float.IsFinite(maxSeconds))
            return 0;

        int bestIndex = DefaultPlotTimeWindowIndex;
        double bestDistance = double.MaxValue;
        for (int i = 1; i < PlotTimeWindows.Length; i++)
        {
            TimeSpan? timeWindow = PlotTimeWindows[i];
            if (!timeWindow.HasValue)
                continue;

            double distance = Math.Abs(timeWindow.Value.TotalSeconds - maxSeconds);
            if (distance < bestDistance)
            {
                bestDistance = distance;
                bestIndex = i;
            }
        }

        return bestIndex;
    }

    private static string FormatInterval(TimeSpan interval)
    {
        if (interval.TotalMilliseconds < 1000)
            return $"{interval.TotalMilliseconds:F0}ms";
        if (interval.TotalSeconds < 60)
            return $"{interval.TotalSeconds:F0}s";
        if (interval.TotalMinutes < 60)
            return $"{interval.TotalMinutes:F0}min";
        return $"{interval.TotalHours:F0}h";
    }
}