/*

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

 */

 using System;

 using System.Collections.Generic;

 using System.Drawing;

 using System.Text;

 using System.Windows.Forms;

 using System.Windows;

 using OpenHardwareMonitor.Hardware;

 using OpenHardwareMonitor.Utilities;

 using System.Runtime.InteropServices;

 static class NativeMethods

 {

     [System.Flags]

     public enum LoadLibraryFlags : uint

     {

         DONT_RESOLVE_DLL_REFERENCES = 0x00000001,

         LOAD_IGNORE_CODE_AUTHZ_LEVEL = 0x00000010,

         LOAD_LIBRARY_AS_DATAFILE = 0x00000002,

         LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE = 0x00000040,

         LOAD_LIBRARY_AS_IMAGE_RESOURCE = 0x00000020,

         LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008

     }

     [DllImport("kernel32.dll", SetLastError = true)]

     public static extern IntPtr LoadLibrary(string dllToLoad);

     [DllImport("kernel32.dll")]

     public static extern IntPtr LoadLibraryEx(string lpFileName, IntPtr hReservedNull, LoadLibraryFlags dwFlags);

     [DllImport("kernel32.dll", SetLastError = true)]

     public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);

     [DllImport("kernel32.dll", SetLastError = true)]

     public static extern bool FreeLibrary(IntPtr hModule);

 }

 /**

 Definitions taken from public Sound Graph APIs.

  */

 static class SoundGraph

 {

     const int WM_APP = 0x8000;

     public const int WM_DSP_PLUGIN_NOTIFY = WM_APP + 1121;

     /**DSPResult

     @brief	These enumeration values represent the returned result for iMON Display API function calls.\n

 			    All iMON Display API function calls return one of this result values.\n

 			    For meaning of each result, refer the comment of each line below*/

     public enum DSPResult : int

     {

 	    DSP_SUCCEEDED = 0,				//// Function Call Succeeded Without Error

 	    DSP_E_FAIL,						//// Unspecified Failure

 	    DSP_E_OUTOFMEMORY,				//// Failed to Allocate Necessary Memory

 	    DSP_E_INVALIDARG,				//// One or More Arguments Are Not Valid

 	    DSP_E_NOT_INITED,				//// API is Not Initialized

 	    DSP_E_POINTER,					//// Pointer is Not Valid

 	    DSP_S_INITED = 0x1000,			//// API is Initialized

 	    DSP_S_NOT_INITED,				//// API is Not Initialized

 	    DSP_S_IN_PLUGIN_MODE,			//// API Can Control iMON Display (Display Plug-in Mode)

 	    DSP_S_NOT_IN_PLUGIN_MODE,		//// API Can't Control iMON Display

     };

     /**DSPNInitResult

     @brief	These enumeration values represent the result status for requesting Display Plug-in Mode to iMON.\n

 			    iMON Display API notifies one of this result values to the caller application after requesting Display Plug-in Mode to iMON.\n

 			    For more information, refer the comment of each line below*/

     public enum DSPNInitResult : int

     {

 	    DSPN_SUCCEEDED = 0,				//// Display Plug-in Mode is Initialized Successfully

 	    DSPN_ERR_IN_USED = 0x0100,		//// Display Plug-in is Already Used by Other Application

 	    DSPN_ERR_HW_DISCONNECTED,		//// iMON HW is Not Connected

 	    DSPN_ERR_NOT_SUPPORTED_HW,		//// The Connected iMON HW doesn't Support Display Plug-in

 	    DSPN_ERR_PLUGIN_DISABLED,		//// Display Plug-in Mode Option is Disabled

 	    DSPN_ERR_IMON_NO_REPLY,			//// The Latest iMON is Not Installed or iMON Not Running

 	    DSPN_ERR_UNKNOWN = 0x0200,		//// Unknown Failure

     };

     /**DSPType

     @brief	These enumeration values represent display type.\n

 			    Currently iMON Display API supports VFD and LCD products.*/

     public enum DSPType : int

     {

 	    DSPN_DSP_NONE	= 0,

 	    DSPN_DSP_VFD	= 0x01,			//// VFD products

 	    DSPN_DSP_LCD	= 0x02,			//// LCD products

     };

     /**DSPNotifyCode

     @brief	These enumeration values represent the notification codes.\n

 			    iMON Display API will send or post message to the caller application.\n

 			    The caller application should assign the message and the winodw handle to receivce message with IMON_Display_Init fucntion.\n

 			    These enumeration values are used with WPARAM parameter of the message.\n 

 			    For more information, see the explanation of each notification code below*/

     public enum DSPNotifyCode : int

     {

 	    /**DSPNM_PLUGIN_SUCCEED

 	    @brief	When API succeeds to get the control for the display, API will post caller-specified message with DSPNM_PLUGIN_SUCCEED as WPARAM parameter.\n

 				    LPARAM represents DSPType. This value can be 0x01 (VFD), 0x02 (LCD) or 0x03 (VFD+LCD).*/

 	    DSPNM_PLUGIN_SUCCEED = 0,

 	    /**DSPNM_PLUGIN_FAILED

 	    @brief	When API fails to get the control for the display, API will post caller-specified message with DSPNM_PLUGIN_FAILED as WPARAM parameter.\n

 				    LPARAM represents error code with DSPNResult.*/

 	    DSPNM_PLUGIN_FAILED,

 	    /**DSPNM_IMON_RESTARTED

 	    @brief	When iMON starts, API will post caller-specified message with DSPNM_IMON_RESTARTED as WPARAM parameter.\n

 				    LPARAM represents DSPType. This value can be 0 (No Display), 0x01 (VFD), 0x02 (LCD) or 0x03 (VFD+LCD).*/

 	    DSPNM_IMON_RESTARTED,

 	    /**DSPNM_IMON_CLOSED

 	    @brief	When iMON closed, API will post caller-specified message with DSPNM_IMON_CLOSED as WPARAM parameter.\n

 				    LPARAM is not used.*/

 	    DSPNM_IMON_CLOSED,

 	    /**DSPNM_HW_CONNECTED

 	    @brief	When iMON HW newly connected, API will post caller-specified message with DSPNM_HW_CONNECTED as WPARAM parameter.\n

 				    LPARAM represents DSPType. This value can be 0 (No Display), 0x01 (VFD), 0x02 (LCD) or 0x03 (VFD+LCD).*/

 	    DSPNM_HW_CONNECTED,

 	    /**DSPNM_HW_DISCONNECTED

 	    @brief	When iMON HW disconnected, API will post caller-specified message with DSPNM_HW_DISCONNECTED as WPARAM parameter.\n

 				    LPARAM is DSPNResult value, DSPN_ERR_HW_DISCONNECTED.*/

 	    DSPNM_HW_DISCONNECTED,

 	    /**DSPNM_LCD_TEXT_SCROLL_DONE

 	    @brief	When iMON LCD finishes scrolling Text, API will post caller-specified message with DSPNM_LCD_TEXT_SCROLL_DONE as WPARAM parameter.\n

 				    The caller application may need to know when text scroll is finished, for sending next text.\n

 				    LPARAM is not used.*/

 	    DSPNM_LCD_TEXT_SCROLL_DONE = 0x1000,

     };

     /// Functions

     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]

     public delegate DSPResult IMON_Display_Uninit();

     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]

     public delegate DSPResult IMON_Display_Init(IntPtr hwndNoti, uint uMsgNotification);

     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]

     public delegate DSPResult IMON_Display_IsInited();

     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]

     public delegate DSPResult IMON_Display_IsPluginModeEnabled();

     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]

     public delegate DSPResult IMON_Display_SetVfdText(

         [MarshalAs(UnmanagedType.LPWStr)] string lpsz1stLine,

         [MarshalAs(UnmanagedType.LPWStr)] string lpsz2ndLine);

     //IMONDSPAPI DSPResult IMON_Display_SetVfdText(LPCTSTR lpsz1stLine, LPCTSTR lpsz2ndLine);

 }

 namespace OpenHardwareMonitor.GUI

 {

     public class SoundGraphDisplay : IDisposable

     {

         private IComputer computer;

         private PersistentSettings settings;

         private UnitManager unitManager;

         private List<SensorFrontView> list = new List<SensorFrontView>();

         //private bool mainIconEnabled = false;

         //private NotifyIconAdv mainIcon;

         IntPtr iSoundGraphDll;

         SoundGraph.IMON_Display_Uninit iIMON_Display_Uninit;

         SoundGraph.IMON_Display_Init iIMON_Display_Init;

         SoundGraph.IMON_Display_IsInited iIMON_Display_IsInited;

         SoundGraph.IMON_Display_IsPluginModeEnabled iIMON_Display_IsPluginModeEnabled;

         SoundGraph.IMON_Display_SetVfdText iIMON_Display_SetVfdText;

         public SoundGraphDisplay(IComputer computer, PersistentSettings settings,

           UnitManager unitManager)

         {

             this.computer = computer;

             this.settings = settings;

             this.unitManager = unitManager;

             computer.HardwareAdded += new HardwareEventHandler(HardwareAdded);

             computer.HardwareRemoved += new HardwareEventHandler(HardwareRemoved);

             //Try loading SoundGraph iMON Disaply DLL

             iSoundGraphDll = NativeMethods.LoadLibraryEx(@"iMONDisplay.dll", IntPtr.Zero, NativeMethods.LoadLibraryFlags.LOAD_WITH_ALTERED_SEARCH_PATH);

             int err=Marshal.GetLastWin32Error(); //If you 193  it means you need build for x86

             if (err == 193)

             {

                 Console.Write(@"iMON: Cannot load x86 DLL from x64 process.");

             }

             else if (err != 0)

             {

                 Console.Write(@"iMON: Error: %i - Failed to load iMONDisplay.dll", err);

             }

             else

             {

                 Console.Write(@"iMON: DLL loaded.");

                 //Gather our function pointers

                 //TODO: Check returned pointers for validity

                 IntPtr functionPointer = NativeMethods.GetProcAddress(iSoundGraphDll, "IMON_Display_Uninit");

                 iIMON_Display_Uninit = (SoundGraph.IMON_Display_Uninit)Marshal.GetDelegateForFunctionPointer(functionPointer, typeof(SoundGraph.IMON_Display_Uninit));

                 functionPointer = NativeMethods.GetProcAddress(iSoundGraphDll, "IMON_Display_Init");

                 iIMON_Display_Init = (SoundGraph.IMON_Display_Init)Marshal.GetDelegateForFunctionPointer(functionPointer, typeof(SoundGraph.IMON_Display_Init));

                 functionPointer = NativeMethods.GetProcAddress(iSoundGraphDll, "IMON_Display_IsInited");

                 iIMON_Display_IsInited = (SoundGraph.IMON_Display_IsInited)Marshal.GetDelegateForFunctionPointer(functionPointer, typeof(SoundGraph.IMON_Display_IsInited));

                 functionPointer = NativeMethods.GetProcAddress(iSoundGraphDll, "IMON_Display_IsPluginModeEnabled");

                 iIMON_Display_IsPluginModeEnabled = (SoundGraph.IMON_Display_IsPluginModeEnabled)Marshal.GetDelegateForFunctionPointer(functionPointer, typeof(SoundGraph.IMON_Display_IsPluginModeEnabled));

                 functionPointer = NativeMethods.GetProcAddress(iSoundGraphDll, "IMON_Display_SetVfdText");

                 iIMON_Display_SetVfdText = (SoundGraph.IMON_Display_SetVfdText)Marshal.GetDelegateForFunctionPointer(functionPointer, typeof(SoundGraph.IMON_Display_SetVfdText));

             }

         }

         private void HardwareRemoved(IHardware hardware)

         {

             hardware.SensorAdded -= new SensorEventHandler(SensorAdded);

             hardware.SensorRemoved -= new SensorEventHandler(SensorRemoved);

             foreach (ISensor sensor in hardware.Sensors)

                 SensorRemoved(sensor);

             foreach (IHardware subHardware in hardware.SubHardware)

                 HardwareRemoved(subHardware);

         }

         private void HardwareAdded(IHardware hardware)

         {

             foreach (ISensor sensor in hardware.Sensors)

                 SensorAdded(sensor);

             hardware.SensorAdded += new SensorEventHandler(SensorAdded);

             hardware.SensorRemoved += new SensorEventHandler(SensorRemoved);

             foreach (IHardware subHardware in hardware.SubHardware)

                 HardwareAdded(subHardware);

         }

         private void SensorAdded(ISensor sensor)

         {

             if (settings.GetValue(new Identifier(sensor.Identifier,

               "tray").ToString(), false))

                 Add(sensor, false);

         }

         private void SensorRemoved(ISensor sensor)

         {

             if (Contains(sensor))

                 Remove(sensor, false);

         }

         public void Dispose()

         {

             foreach (SensorFrontView icon in list)

                 icon.Dispose();

             //Unload our DLL

             if (iSoundGraphDll != IntPtr.Zero)

             {

                 bool result = NativeMethods.FreeLibrary(iSoundGraphDll);

             }

         }

         public void Redraw()

         {

             foreach (SensorFrontView icon in list)

                 icon.Update();

         }

         public bool Contains(ISensor sensor)

         {

             foreach (SensorFrontView icon in list)

                 if (icon.Sensor == sensor)

                     return true;

             return false;

         }

         public void Add(ISensor sensor, bool balloonTip)

         {

             if (Contains(sensor))

             {

                 return;

             }

             else

             {

                 //SL:

                 //list.Add(new SensorFrontView(this, sensor, balloonTip, settings, unitManager));

                 //UpdateMainIconVisibilty();

                 //settings.SetValue(new Identifier(sensor.Identifier, "tray").ToString(), true);

             }

         }

         public void Remove(ISensor sensor)

         {

             Remove(sensor, true);

         }

         private void Remove(ISensor sensor, bool deleteConfig)

         {

             if (deleteConfig)

             {

                 settings.Remove(

                   new Identifier(sensor.Identifier, "tray").ToString());

                 settings.Remove(

                   new Identifier(sensor.Identifier, "traycolor").ToString());

             }

             SensorFrontView instance = null;

             foreach (SensorFrontView icon in list)

                 if (icon.Sensor == sensor)

                     instance = icon;

             if (instance != null)

             {

                 list.Remove(instance);

                 UpdateMainIconVisibilty();

                 instance.Dispose();

             }

         }

         private void UpdateMainIconVisibilty()

         {

             /*

             if (mainIconEnabled)

             {

                 mainIcon.Visible = list.Count == 0;

             }

             else

             {

                 mainIcon.Visible = false;

             }

              */

         }

         public void Init(IntPtr aHWND)

         {

             iIMON_Display_Init(aHWND, SoundGraph.WM_DSP_PLUGIN_NOTIFY);

         }

         public void Uninit()

         {

             iIMON_Display_Uninit();

         }

         public void SetText(string aUpperLine, string aLowerLine)

         {

         }

         /*

         public bool IsMainIconEnabled

         {

             get { return mainIconEnabled; }

             set

             {

                 if (mainIconEnabled != value)

                 {

                     mainIconEnabled = value;

                     UpdateMainIconVisibilty();

                 }

             }

         }*/

         public bool IsDllLoaded

         {

             get { return iSoundGraphDll!=IntPtr.Zero; }

         }

         public void DisplayPluginMessage(int uErrCode, bool bError)

         {

 	        if(bError)

 	        {

                 switch ((SoundGraph.DSPNInitResult)uErrCode)

 		        {

                     case SoundGraph.DSPNInitResult.DSPN_ERR_IN_USED: 

                         Console.Write("Display Plug-in is Already Used by Other Application.\n"); break;

                     case SoundGraph.DSPNInitResult.DSPN_ERR_HW_DISCONNECTED: 

                         Console.Write("iMON HW is Not Connected."); break;

                     case SoundGraph.DSPNInitResult.DSPN_ERR_NOT_SUPPORTED_HW: 

                         Console.Write("The Connected iMON HW doesn't Support Display Plug-in.\n"); break;

                     case SoundGraph.DSPNInitResult.DSPN_ERR_PLUGIN_DISABLED: 

                         Console.Write("Display Plug-in Mode Option is Disabled.\n"); break;

                     case SoundGraph.DSPNInitResult.DSPN_ERR_IMON_NO_REPLY: 

                         Console.Write("The Latest iMON is Not Installed or iMON Not Running.\n"); break;

                     case SoundGraph.DSPNInitResult.DSPN_ERR_UNKNOWN: 

                         Console.Write("Unknown Failure.\n"); break;

 		        }

     	    }

 	        else

             {

                 switch ((SoundGraph.DSPNotifyCode)uErrCode)

 		        {

                     case SoundGraph.DSPNotifyCode.DSPNM_PLUGIN_SUCCEED: 

                         Console.Write("Plug-in Mode Inited Successfully.\n"); break;

                     case SoundGraph.DSPNotifyCode.DSPNM_IMON_RESTARTED: 

                         Console.Write("iMON Started and Plug-in Mode Inited.\n"); break;

                     case SoundGraph.DSPNotifyCode.DSPNM_HW_CONNECTED: 

                         Console.Write("iMON HW Connected and Plug-in Mode Inited.\n"); break;

 		        }

 	        }

             //GetDlgItem(IDC_STATIC_INFO)->SetWindowText((LPCTSTR)strErrMsg);

         }

     }

 }