/*

   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) 2009-2011 Michael Möller <mmoeller@openhardwaremonitor.org>

 */

 using System;

 using System.Runtime.InteropServices;

 namespace OpenHardwareMonitor.Hardware.CPU {

   internal class CPULoad {

     [StructLayout(LayoutKind.Sequential)]

     protected struct SystemProcessorPerformanceInformation {

       public long IdleTime;

       public long KernelTime;

       public long UserTime;

       public long Reserved0;

       public long Reserved1;

       public ulong Reserved2;

     }

     protected enum SystemInformationClass {

       SystemBasicInformation = 0,

       SystemCpuInformation = 1,

       SystemPerformanceInformation = 2,

       SystemTimeOfDayInformation = 3,

       SystemProcessInformation = 5,

       SystemProcessorPerformanceInformation = 8

     }

     private readonly CPUID[][] cpuid;

     private long[] idleTimes;

     private long[] totalTimes;

     private float totalLoad;

     private readonly float[] coreLoads;

     private readonly bool available;

     private static bool GetTimes(out long[] idle, out long[] total) {      

       SystemProcessorPerformanceInformation[] informations = new

         SystemProcessorPerformanceInformation[64];

       int size = Marshal.SizeOf(typeof(SystemProcessorPerformanceInformation));

       idle = null;

       total = null;

       IntPtr returnLength;

       if (NativeMethods.NtQuerySystemInformation(

         SystemInformationClass.SystemProcessorPerformanceInformation,

         informations, informations.Length * size, out returnLength) != 0)

         return false;

       idle = new long[(int)returnLength / size];

       total = new long[(int)returnLength / size];

       for (int i = 0; i < idle.Length; i++) {

         idle[i] = informations[i].IdleTime;

         total[i] = informations[i].KernelTime + informations[i].UserTime;

       }

       return true;

     }

     public CPULoad(CPUID[][] cpuid) {

       this.cpuid = cpuid;

       this.coreLoads = new float[cpuid.Length];         

       this.totalLoad = 0;

       try {

         GetTimes(out idleTimes, out totalTimes);

       } catch (Exception) {

         this.idleTimes = null;

         this.totalTimes = null;

       }

       if (idleTimes != null)

         available = true;

     }

     public bool IsAvailable {

       get { return available; }

     }

     public float GetTotalLoad() {

       return totalLoad;

     }

     public float GetCoreLoad(int core) {

       return coreLoads[core];

     }

     public void Update() {

       if (this.idleTimes == null)

         return;

       long[] newIdleTimes;

       long[] newTotalTimes;

       if (!GetTimes(out newIdleTimes, out newTotalTimes))

         return;

       for (int i = 0; i < Math.Min(newTotalTimes.Length, totalTimes.Length); i++) 

         if (newTotalTimes[i] - this.totalTimes[i] < 100000)

           return;

       if (newIdleTimes == null || newTotalTimes == null)

         return;

       float total = 0;

       int count = 0;

       for (int i = 0; i < cpuid.Length; i++) {

         float value = 0;

         for (int j = 0; j < cpuid[i].Length; j++) {

           long index = cpuid[i][j].Thread;

           if (index < newIdleTimes.Length && index < totalTimes.Length) {

             float idle = 

               (float)(newIdleTimes[index] - this.idleTimes[index]) /

               (float)(newTotalTimes[index] - this.totalTimes[index]);

             value += idle;

             total += idle;

             count++;

           }

         }

         value = 1.0f - value / cpuid[i].Length;

         value = value < 0 ? 0 : value;

         coreLoads[i] = value * 100;

       }

       if (count > 0) {

         total = 1.0f - total / count;

         total = total < 0 ? 0 : total;

       } else {

         total = 0;

       }

       this.totalLoad = total * 100;

       this.totalTimes = newTotalTimes;

       this.idleTimes = newIdleTimes;

     }

     protected static class NativeMethods {

       [DllImport("ntdll.dll")]

       public static extern int NtQuerySystemInformation(

         SystemInformationClass informationClass,

         [Out] SystemProcessorPerformanceInformation[] informations,

         int structSize, out IntPtr returnLength);

     }

   }

 }