using HMI.Simple.Util;
using log4net;
using System;
using System.Diagnostics;
using System.Management;
using System.Timers;
using System.Xml.Linq;

namespace WPFProject
{
    public class RunTimeState
    {
        public float cpuRate { get; set; }
        public double remRate { get; set; }

        public float totalCpuRate { get; set; }
        public double totalRemRate { get; set; }
    }

    public class ResourceListener
    {
        public event EventHandler<RunTimeState> RefreshEvent;
        private Timer timer;
        private System.Threading.CancellationTokenSource _can;

        private static ResourceListener instance;
        public static ResourceListener Instance
        {
            get
            {

                if (instance == null)
                {
                    instance = new ResourceListener();
                }
                return instance;
            }
        }
        private ILog log = LogManager.GetLogger("ResourceListener");

        // CPU占用
        private PerformanceCounter totalCpuCounter;

        private PerformanceCounter cpuCounter;

        private ResourceListener()
        {
            totalCpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
            cpuCounter = new PerformanceCounter("Process", "% Processor Time", Process.GetCurrentProcess().ProcessName, true);
        }

        public void Start()
        {
            _can = new System.Threading.CancellationTokenSource();
            Refresh();
            timer = new Timer();
            timer.AutoReset = false;
            timer.Interval = 30000;
            timer.Elapsed += Timer_Elapsed;
            timer.Enabled = true;
        }

        private void Refresh()
        {
            try
            {
                var _cpuCount = Environment.ProcessorCount;
                ObjectQuery wql = new ObjectQuery("SELECT * FROM Win32_OperatingSystem");
                ManagementObjectSearcher searcher = new ManagementObjectSearcher(wql);

                string prcName = Process.GetCurrentProcess().ProcessName;
                var counter_Exec = new PerformanceCounter("Process", "Working Set - Private", prcName);
                ulong dWsp_Exec = (ulong)(counter_Exec.RawValue / 1024);

                var totalCpuRate = totalCpuCounter.NextValue();
                var cpuRate = cpuCounter.NextValue() / _cpuCount;

                foreach (ManagementObject obj in searcher.Get())
                {
                    ulong totalVisibleMemorySize = (ulong)obj["TotalVisibleMemorySize"];
                    ulong freePhysicalMemory = (ulong)obj["FreePhysicalMemory"];

                    ulong usedMemory = totalVisibleMemorySize - freePhysicalMemory;
                    string info = $"\r\n总内存: {totalVisibleMemorySize / 1024} MB\r\n";

                    info += $"已使用内存: {usedMemory / 1024} MB\r\n";
                    double usagePercent = usedMemory * 100d / totalVisibleMemorySize;
                    info += $"内存占用率: {usagePercent:F2}%\r\n";

                    info += $"应用占用内存: {dWsp_Exec / 1024} MB\r\n";
                    double appPercent = dWsp_Exec * 100d / totalVisibleMemorySize;
                    info += $"应用内存占用率: {appPercent:F2}%";
                    RefreshEvent?.Invoke(this, new RunTimeState
                    {
                        cpuRate = cpuRate,
                        remRate = appPercent,
                        totalCpuRate = totalCpuRate,
                        totalRemRate = usagePercent
                    });
                    log.Info(info);
                    //if (usagePercent > 80)
                    //{
                    //    AlarmUtil.CreateAlarm("App", "内存占用过高，超80%", out _);
                    //}
                }
            }
            catch (Exception ex)
            {
                log.Error("Refresh Resource Error.", ex);
            }
        }

        private void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                timer.Enabled = false;
                _can.Token.ThrowIfCancellationRequested();
                Refresh();
                timer.Enabled = true;
            }
            catch
            {

            }
        }

        public void Stop()
        {
            _can?.Cancel();
            _can?.Dispose();
            instance = null;
        }
    }
}