path: root/Software/Visual_Studio/FSE/Modules/Tango.FSE.PPCConsole/ViewModels/MonitoringViewVM.cs

using LiveCharts;
using RealTimeGraphX.DataPoints;
using RealTimeGraphX.WPF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using Tango.Core.Commands;
using Tango.Core.Helpers;
using Tango.FSE.Common;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Graphs;
using Tango.FSE.Common.Performance;
using Tango.PPC.Shared.Information;
using Tango.SystemInfo;
using static Tango.SharedUI.Controls.NavigationControl;

namespace Tango.FSE.PPCConsole.ViewModels
{
    /// <summary>
    /// Represents the PPC monitoring view model.
    /// </summary>
    /// <seealso cref="Tango.FSE.Common.FSEViewModel" />
    /// <seealso cref="Tango.SharedUI.Controls.NavigationControl.INavigationViewModel" />
    public class MonitoringViewVM : FSEViewModel, INavigationViewModel
    {
        #region Properties

        /// <summary>
        /// Gets or sets the CPU real-time graph controller.
        /// </summary>
        public WpfGraphController<DateTimeDataPoint, DoubleDataPoint> CPUController { get; set; }

        /// <summary>
        /// Gets or sets the RAM real-time controller.
        /// </summary>
        public WpfGraphController<DateTimeDataPoint, DoubleDataPoint> RAMController { get; set; }

        /// <summary>
        /// Gets or sets the disk space point label (Live Charts).
        /// </summary>
        public Func<ChartPoint, string> DiskSpacePointLabel { get; set; }

        private InformationPackage _systemInfo;
        /// <summary>
        /// Gets or sets the system information package.
        /// </summary>
        public InformationPackage SystemInfo
        {
            get { return _systemInfo; }
            set { _systemInfo = value; RaisePropertyChangedAuto(); }
        }

        private SystemObjectsCollection _selectedSystemObjectCollection;
        /// <summary>
        /// Gets or sets the selected system object collection.
        /// </summary>
        public SystemObjectsCollection SelectedSystemObjectCollection
        {
            get { return _selectedSystemObjectCollection; }
            set { _selectedSystemObjectCollection = value; RaisePropertyChangedAuto(); }
        }

        private bool _fetchingSystemInfo;
        /// <summary>
        /// Gets or sets a value indicating whether the view model is currently busy with fetching the remote system information.
        /// </summary>
        public bool FetchingSystemInfo
        {
            get { return _fetchingSystemInfo; }
            set { _fetchingSystemInfo = value; RaisePropertyChangedAuto(); }
        }

        private double _usedDiskSpace;
        /// <summary>
        /// Gets or sets the PPC used disk space.
        /// </summary>
        public double UsedDiskSpace
        {
            get { return _usedDiskSpace; }
            set
            {
                if (_usedDiskSpace != value)
                {
                    _usedDiskSpace = value;
                    RaisePropertyChangedAuto();
                }
            }
        }

        private double _availableDiskSpace;
        /// <summary>
        /// Gets or sets the PPC available disk space.
        /// </summary>
        public double AvailableDiskSpace
        {
            get { return _availableDiskSpace; }
            set
            {
                if (_availableDiskSpace != value)
                {
                    _availableDiskSpace = value;
                    RaisePropertyChangedAuto();
                }
            }
        }

        #endregion

        #region Commands

        /// <summary>
        /// Performs disk space optimization.
        /// </summary>
        public RelayCommand PerformDiskSpaceOptimizationCommand { get; set; }

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="MonitoringViewVM"/> class.
        /// </summary>
        public MonitoringViewVM()
        {
            CPUController = CreateController(CreateSeries("Total", GraphHelper.GraphColor.White), CreateSeries("Application", GraphHelper.GraphColor.Red));
            RAMController = CreateController(CreateSeries("Total", GraphHelper.GraphColor.White), CreateSeries("Application", GraphHelper.GraphColor.Yellow));
            UsedDiskSpace = 1000 * 40;
            AvailableDiskSpace = 1000 * 60;
            DiskSpacePointLabel = (point) =>
            {
                return $"{(point.Y / 1000d).ToString("0.0")} GB";
            };

            PerformDiskSpaceOptimizationCommand = new RelayCommand(PerformDiskSpaceOptimization);
        }

        #endregion

        #region Override Methods

        public override void OnApplicationStarted()
        {
            base.OnApplicationStarted();
            PerformanceProvider.PerformancePackageAvailable += PerformanceProvider_PerformancePackageAvailable;
            MachineProvider.MachineDisconnected += MachineProvider_MachineDisconnected;
            MachineProvider.MachineConnected += MachineProvider_MachineConnected;
        }

        public override void OnNavigatedTo()
        {
            base.OnNavigatedTo();

            if (MachineProvider.IsConnected && MachineProvider.ConnectionType.IsRemote())
            {
                LoadSystemInformation();
            }
        }

        #endregion

        #region Event Handlers

        private void MachineProvider_MachineConnected(object sender, Common.Connection.MachineConnectedEventArgs e)
        {
            CPUController.Clear();
            RAMController.Clear();
            AvailableDiskSpace = 0;
            UsedDiskSpace = 0;
            LoadSystemInformation();
        }

        private void MachineProvider_MachineDisconnected(object sender, Common.Connection.MachineDisconnectedEventArgs e)
        {
            SystemInfo = null;
        }

        private void PerformanceProvider_PerformancePackageAvailable(object sender, PerformancePackageEventArgs e)
        {
            List<DateTimeDataPoint> xx = new List<DateTimeDataPoint>()
            {
                DateTime.Now,
                DateTime.Now
            };

            //CPU
            CPUController.PushData(xx, new List<DoubleDataPoint>()
            {
                e.Package.CPU,
                e.Package.ApplicationCPU
            });

            //App RAM
            RAMController.Range.MaximumY = e.Package.MaxRAM;
            RAMController.PushData(xx, new List<DoubleDataPoint>()
            {
                e.Package.RAM,
                e.Package.ApplicationRAM
            });

            //Disk Space
            var usedDiskSpace = e.Package.DiskCapacity - e.Package.AvailableDiskSpace;
            var availableDiskSpace = e.Package.AvailableDiskSpace;

            if (Math.Abs(UsedDiskSpace - usedDiskSpace) > 10)
            {
                UsedDiskSpace = usedDiskSpace;
            }

            if (Math.Abs(AvailableDiskSpace - availableDiskSpace) > 10)
            {
                AvailableDiskSpace = availableDiskSpace;
            }
        }

        #endregion

        #region Private Methods

        private WpfGraphController<DateTimeDataPoint, DoubleDataPoint> CreateController(params WpfGraphDataSeries[] seriesCollection)
        {
            var controller = new WpfGraphController<DateTimeDataPoint, DoubleDataPoint>();

            foreach (var series in seriesCollection)
            {
                controller.DataSeriesCollection.Add(series);
            }

            controller.Range.AutoY = false;
            controller.Range.MaximumY = 100;
            controller.Range.MinimumY = 0;
            controller.Range.MaximumX = new DateTime(0).AddMinutes(1);

            controller.RefreshRate = TimeSpan.FromMilliseconds(100);

            return controller;
        }

        private WpfGraphDataSeries CreateSeries(String name, GraphHelper.GraphColor fill)
        {
            WpfGraphDataSeries series = new WpfGraphDataSeries();
            series.Name = name;
            series.Fill = GraphHelper.GetGraphBrush(fill);
            series.StrokeThickness = 1;
            series.Stroke = GraphHelper.GetGraphStrokeColor();
            return series;
        }

        private async void LoadSystemInformation()
        {
            if (!MachineProvider.ConnectionType.IsRemote()) return;

            if (SystemInfo == null && !FetchingSystemInfo)
            {
                try
                {
                    FetchingSystemInfo = true;
                    SystemInfo = await SystemInfoProvider.GetSystemInformationPackage();
                    SelectedSystemObjectCollection = SystemInfo.System.FirstOrDefault();
                }
                catch (Exception ex)
                {
                    FetchingSystemInfo = false;
                    LogManager.Log(ex, "Error retrieving system information from remote machine.");
                    NotificationProvider.PushErrorReportingSnackbar(ex, "PPC Module Error", "Error retrieving the remote machine PPC system information.");
                }
                finally
                {
                    FetchingSystemInfo = false;
                }
            }
        }

        private async void PerformDiskSpaceOptimization()
        {
            if (await NotificationProvider.ShowQuestion("The following stage will try to optimize the disk space on the remote machine panel PC. Do you wish to continue?", "RUN OPTIMIZATION", "NO"))
            {
                try
                {
                    using (NotificationProvider.PushTaskItem("Performing disk space optimization, please wait..."))
                    {
                        var response = await FileSystemProvider.PerformDiskSpaceOptimization();
                        await NotificationProvider.ShowSuccess($"Disk space optimization completed successfully.\n{FileHelper.GetFriendlyFileSize(response.DeletedBytes)} cleared!");
                    }
                }
                catch (Exception ex)
                {
                    await NotificationProvider.ShowError($"Error occurred while trying disk space optimization.\n{ex.FlattenMessage()}");
                }
            }
        }

        #endregion
    }
}