/*
 
  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);
    }
  }
}