<
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Tango.Core.DI;
using Tango.PPC.Common.ThreadLoading;

namespace Tango.PPC.Events.EventsViews
{
    /// <summary>
    /// Interaction logic for ThreadBreakView.xaml
    /// </summary>
    public partial class ThreadBreakView : UserControl
    {
        public ThreadBreakView()
        {
            InitializeComponent();

            btnLoadThreadBreakW
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using Tango.BL;
using Tango.Core.Commands;
using Tango.PPC.Common;
using Tango.PPC.Common.OS;
using Tango.Settings;
using System.Data.Entity;
using Tango.PPC.Common.UWF;

namespace Tango.PPC.Technician.ViewModels
{
    public class SystemViewVM : PPCViewModel
    {
        private IOperationSystemManager _os;
        private IUnifiedWriteFilterManager _uwf;
        private Timer _statsTimer;
        private bool _resettingDevice;

        private float _cpu;
        public float CPU
        {
            get { return _cpu; }
            set { _cpu = value; RaisePropertyChangedAuto(); }
        }

        private long _ram;
        public long RAM
        {
            get { return _ram; }
            set { _ram = value; RaisePropertyChangedAuto(); }
        }

        private double _temperature;
        public double Temperature
        {
            get { return _temperature; }
            set { _temperature = value; RaisePropertyChangedAuto(); }
        }

        private TimeSpan _upTime;
        public TimeSpan UpTime
        {
            get { return _upTime; }
            set { _upTime = value; RaisePropertyChangedAuto(); }
        }

        private String _ipAddress;
        public String IPAddress
        {
            get { return _ipAddress; }
            set { _ipAddress = value; RaisePropertyChangedAuto(); }
        }

        private String _totalDyeTime;
        public String TotalDyeTime
        {
            get { return _totalDyeTime; }
            set { _totalDyeTime = value; RaisePropertyChangedAuto(); }
        }

        private String _totalDyeMeters;
        public String TotalDyeMeters
        {
            get { return _totalDyeMeters; }
            set { _totalDyeMeters = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand ResetDeviceCommand { get; set; }

        public RelayCommand RestartCommand { get; set; }

        public RelayCommand ShutdownCommand { get; set; }

        public RelayCommand FactoryResetCommand { get; set; }

        public RelayCommand ExitToExplorerCommand { get; set; }

        public SystemViewVM(IOperationSystemManager os, IUnifiedWriteFilterManager uwf)
        {
            _os = os;
            _uwf = uwf;

            CPU = 0;
            RAM = 0;

            RestartCommand = new RelayCommand(RestartSystem);
            ShutdownCommand = new RelayCommand(ShutdownSystem);
            FactoryResetCommand = new RelayCommand(FactoryReset);
            ExitToExplorerCommand = new RelayCommand(ExitToExplorer);
            ResetDeviceCommand = new RelayCommand(ResetDevice, () => !_resettingDevice);
        }

        private async void ResetDevice()
        {
            try
            {
                _resettingDevice = true;
                ResetDeviceCommand.RaiseCanExecuteChanged();
                await MachineProvider.MachineOperator.Reset();
                await NotificationProvider.ShowInfo("Embedded device has been reset successfully.");
            }
            catch (Exception ex)
            {
                await NotificationProvider.ShowError(ex.FlattenMessage());
            }
            finally
            {
                _resettingDevice = false;
                ResetDeviceCommand.RaiseCanExecuteChanged();
            }
        }

        private async void FactoryReset()
        {
            if (await NotificationProvider.ShowQuestion("Are you sure you want to reset this device back to factory settings?"))
            {
                Settings.ApplicationState = ApplicationStates.FactoryRestore;
                Settings.Save();
                try
                {
                    NotificationProvider.SetGlobalBusyMessage("Disabling write filter protection...");
                    await _uwf.Disable();
                    await Task.Delay(2000);
                    NotificationProvider.ReleaseGlobalBusyMessage();
                    await NavigationManager.NavigateTo(Common.Navigation.NavigationView.RestartingSystemView);
                    await Task.Delay(4000);
                    _os.Restart();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error executing factory reset.");
                    NotificationProvider.ReleaseGlobalBusyMessage();
                    await NotificationProvider.ShowError($"Error executing factory reset.\n{ex.FlattenMessage()}");
                }
                finally
                {
                    NotificationProvider.ReleaseGlobalBusyMessage();
                }
            }
        }

        private async void ShutdownSystem()
        {
            if (await NotificationProvider.ShowQuestion("Are you sure you want to shutdown the device?"))
            {
                _os.Shutdown();
            }
        }

        private async void RestartSystem()
        {
            if (await NotificationProvider.ShowQuestion("Are you sure you want to restart the device?"))
            {
                await NavigationManager.NavigateTo(Common.Navigation.NavigationView.RestartingSystemView);
                await Task.Delay(4000);
                _os.Restart();
            }
        }

        private async void ExitToExplorer()
        {
            if (await NotificationProvider.ShowQuestion("Close the application and start OS shell?"))
            {
                _os.OpenShell();
                ApplicationManager.ShutDown();
            }
        }

        public override void OnApplicationStarted()
        {
            _statsTimer = new Timer();
            _statsTimer.Interval = 2000;
            _statsTimer.Elapsed += _statsTimer_Elapsed;
            _statsTimer.Start();
        }

        private void _statsTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            if (IsVisible)
            {
                CPU = GetAppCPU();
                RAM = GetAppRam();
                //Temperature = GetTemperature();
                UpTime = DateTime.Now - ApplicationManager.StartUpDate;
            }
        }

        public float GetTotalCPU()
        {
            PerformanceCounter cpuCounter = new PerformanceCounter();
            cpuCounter.CategoryName = "Processor";
            cpuCounter.CounterName = "% Processor Time";
            cpuCounter.InstanceName = "_Total";

            // will always start at 0
            float firstValue = cpuCounter.NextValue();
            System.Threading.Thread.Sleep(1000);
            // now matches task manager reading
            float secondValue = cpuCounter.NextValue();

            return secondValue;
        }

        public float GetAppCPU()
        {
            PerformanceCounter cpuCounter = new PerformanceCounter();
            cpuCounter.CategoryName = "Process";
            cpuCounter.CounterName = "% Processor Time";
            cpuCounter.InstanceName = Process.GetCurrentProcess().ProcessName;

            // will always start at 0
            float firstValue = cpuCounter.NextValue();
            System.Threading.Thread.Sleep(1000);
            // now matches task manager reading
            float secondValue = cpuCounter.NextValue();

            return secondValue / Environment.ProcessorCount;
        }

        public long GetAppRam()
        {
            Process proc = Process.GetCurrentProcess();
            return proc.PrivateMemorySize64;
        }

        public double GetTemperature()
        {
            try
            {
                double cpuTemp = 0;
                List<double> avg = new List<double>();
                ManagementObjectSearcher mos = new ManagementObjectSearcher(@"root\WMI", "Select * From MSAcpi_ThermalZoneTemperature");

                foreach (System.Management.ManagementObject mo in mos.Get())
                {
                    cpuTemp = Convert.ToDouble(Convert.ToDouble(mo.GetPropertyValue("CurrentTemperature").ToString()) - 2732) / 10;
                    avg.Add(cpuTemp);
                }

                return avg.Average();
            }
            catch
            {
                return 0;
            }
        }

        public String GetIpv4Address()
        {
            try
            {
                var host = Dns.GetHostEntry(Dns.GetHostName());
                foreach (var ip in host.AddressList)
                {
                    if (ip.AddressFamily == AddressFamily.InterNetwork)
                    {
                        return ip.ToString();
                    }
                }
                return "N/A";
            }
            catch (Exception ex)
            {
                return "N/A";
            }
        }

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

            IPAddress = GetIpv4Address();

            try
            {
                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    var jobRuns = await db.JobRuns.Select(x => new { x.StartDate, x.EndDate, x.EndPosition }).ToListAsync();

                    TotalDyeTime = TimeSpan.FromHours(jobRuns.Select(x => x.EndDate - x.StartDate).Sum(x => x.TotalHours)).ToStringUnlimitedHours();

                    int meters = (int)jobRuns.Select(x => x.EndPosition).Sum();
                    TotalDyeMeters = $"{meters.ToString("N0")} meters";
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading machine counters.");
                TotalDyeTime = "error!";
                TotalDyeMeters = "error!";
            }
        }
    }
}