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

using System;
using System.ComponentModel;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Windows.Forms;

namespace OpenHardwareMonitor.GUI {

  public class NotifyIconAdv : IDisposable {

    private NotifyIcon genericNotifyIcon;
    private NotifyIconWindowsImplementation windowsNotifyIcon;

    public NotifyIconAdv() {
      int p = (int)Environment.OSVersion.Platform;
      if ((p == 4) || (p == 128)) { // Unix
        genericNotifyIcon = new NotifyIcon();
      } else { // Windows
        windowsNotifyIcon = new NotifyIconWindowsImplementation();
      }
    }

    public event EventHandler BalloonTipClicked {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipClicked += value;
        else
          windowsNotifyIcon.BalloonTipClicked += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipClicked -= value;
        else
          windowsNotifyIcon.BalloonTipClicked -= value;
      }
    }

    public event EventHandler BalloonTipClosed {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipClosed += value;
        else
          windowsNotifyIcon.BalloonTipClosed += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipClosed -= value;
        else
          windowsNotifyIcon.BalloonTipClosed -= value;
      }
    }

    public event EventHandler BalloonTipShown {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipShown += value;
        else
          windowsNotifyIcon.BalloonTipShown += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipShown -= value;
        else
          windowsNotifyIcon.BalloonTipShown -= value;
      }
    }

    public event EventHandler Click {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.Click += value;
        else
          windowsNotifyIcon.Click += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.Click -= value;
        else
          windowsNotifyIcon.Click -= value;
      }
    }

    public event EventHandler DoubleClick {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.DoubleClick += value;
        else
          windowsNotifyIcon.DoubleClick += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.DoubleClick -= value;
        else
          windowsNotifyIcon.DoubleClick -= value;
      }
    }

    public event MouseEventHandler MouseClick {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseClick += value;
        else
          windowsNotifyIcon.MouseClick += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseClick -= value;
        else
          windowsNotifyIcon.MouseClick -= value;
      }
    }

    public event MouseEventHandler MouseDoubleClick {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseDoubleClick += value;
        else
          windowsNotifyIcon.MouseDoubleClick += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseDoubleClick -= value;
        else
          windowsNotifyIcon.MouseDoubleClick -= value;
      }
    }

    public event MouseEventHandler MouseDown {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseDown += value;
        else
          windowsNotifyIcon.MouseDown += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseDown -= value;
        else
          windowsNotifyIcon.MouseDown -= value;
      }
    }

    public event MouseEventHandler MouseMove {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseMove += value;
        else
          windowsNotifyIcon.MouseMove += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseMove -= value;
        else
          windowsNotifyIcon.MouseMove -= value;
      }
    }

    public event MouseEventHandler MouseUp {
      add {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseUp += value;
        else
          windowsNotifyIcon.MouseUp += value;
      }
      remove {
        if (genericNotifyIcon != null)
          genericNotifyIcon.MouseUp -= value;
        else
          windowsNotifyIcon.MouseUp -= value;
      }
    }

    public string BalloonTipText {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.BalloonTipText;
        else
          return windowsNotifyIcon.BalloonTipText;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipText = value;
        else
          windowsNotifyIcon.BalloonTipText = value;
      }
    }

    public ToolTipIcon BalloonTipIcon {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.BalloonTipIcon;
        else
          return windowsNotifyIcon.BalloonTipIcon;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipIcon = value;
        else
          windowsNotifyIcon.BalloonTipIcon = value;
      }
    }

    public string BalloonTipTitle {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.BalloonTipTitle;
        else
          return windowsNotifyIcon.BalloonTipTitle;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.BalloonTipTitle = value;
        else
          windowsNotifyIcon.BalloonTipTitle = value;
      }
    }

    public ContextMenu ContextMenu {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.ContextMenu;
        else
          return windowsNotifyIcon.ContextMenu;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.ContextMenu = value;
        else
          windowsNotifyIcon.ContextMenu = value;
      }
    }

    public ContextMenuStrip ContextMenuStrip {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.ContextMenuStrip;
        else
          return windowsNotifyIcon.ContextMenuStrip;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.ContextMenuStrip = value;
        else
          windowsNotifyIcon.ContextMenuStrip = value;
      }
    }

    public object Tag { get; set; }

    public Icon Icon {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.Icon;
        else
          return windowsNotifyIcon.Icon;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.Icon = value;
        else
          windowsNotifyIcon.Icon = value;
      }
    }

    public string Text {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.Text;
        else
          return windowsNotifyIcon.Text;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.Text = value;
        else
          windowsNotifyIcon.Text = value;
      }
    }

    public bool Visible {
      get {
        if (genericNotifyIcon != null)
          return genericNotifyIcon.Visible;
        else
          return windowsNotifyIcon.Visible;
      }
      set {
        if (genericNotifyIcon != null)
          genericNotifyIcon.Visible = value;
        else
          windowsNotifyIcon.Visible = value;
      }
    }

    public void Dispose() {
      if (genericNotifyIcon != null)
        genericNotifyIcon.Dispose();
      else
        windowsNotifyIcon.Dispose();
    }

    public void ShowBalloonTip(int timeout) {
      ShowBalloonTip(timeout, BalloonTipTitle, BalloonTipText, BalloonTipIcon);
    }

    public void ShowBalloonTip(int timeout, string tipTitle, string tipText,
      ToolTipIcon tipIcon) {
      if (genericNotifyIcon != null)
        genericNotifyIcon.ShowBalloonTip(timeout, tipTitle, tipText, tipIcon);
      else
        windowsNotifyIcon.ShowBalloonTip(timeout, tipTitle, tipText, tipIcon);
    }
    
    private class NotifyIconWindowsImplementation : Component {

      private static int nextId = 0;

      private object syncObj = new object();
      private Icon icon;
      private string text = "";
      private int id;
      private bool created;
      private NotifyIconNativeWindow window;
      private bool doubleClickDown;
      private bool visible;
      private MethodInfo commandDispatch;

      public event EventHandler BalloonTipClicked;
      public event EventHandler BalloonTipClosed;
      public event EventHandler BalloonTipShown;
      public event EventHandler Click;
      public event EventHandler DoubleClick;
      public event MouseEventHandler MouseClick;
      public event MouseEventHandler MouseDoubleClick;
      public event MouseEventHandler MouseDown;
      public event MouseEventHandler MouseMove;
      public event MouseEventHandler MouseUp;

      public string BalloonTipText { get; set; }
      public ToolTipIcon BalloonTipIcon { get; set; }
      public string BalloonTipTitle { get; set; }
      public ContextMenu ContextMenu { get; set; }
      public ContextMenuStrip ContextMenuStrip { get; set; }
      public object Tag { get; set; }

      public Icon Icon {
        get {
          return icon;
        }
        set {
          if (icon != value) {
            icon = value;
            UpdateNotifyIcon(visible);
          }
        }
      }

      public string Text {
        get {
          return text;
        }
        set {
          if (value == null)
            value = "";

          if (value.Length > 63)
            throw new ArgumentOutOfRangeException();

          if (!value.Equals(text)) {
            text = value;

            if (visible)
              UpdateNotifyIcon(visible);
          }
        }
      }

      public bool Visible {
        get {
          return visible;
        }
        set {
          if (visible != value) {
            visible = value;
            UpdateNotifyIcon(visible);
          }
        }
      }

      public NotifyIconWindowsImplementation() {
        BalloonTipText = "";
        BalloonTipTitle = "";

        commandDispatch = typeof(Form).Assembly.
          GetType("System.Windows.Forms.Command").GetMethod("DispatchID",
          BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public,
          null, new Type[] { typeof(int) }, null);

        id = ++NotifyIconWindowsImplementation.nextId;
        window = new NotifyIconNativeWindow(this);
        UpdateNotifyIcon(visible);
      }

      protected override void Dispose(bool disposing) {
        if (disposing) {
          if (window != null) {
            icon = null;
            text = "";
            UpdateNotifyIcon(false);
            window.DestroyHandle();
            window = null;
            ContextMenu = null;
            ContextMenuStrip = null;
          }
        } else {
          if (window != null && window.Handle != IntPtr.Zero) {
            NativeMethods.PostMessage(
              new HandleRef(window, window.Handle), WM_CLOSE, 0, 0);
            window.ReleaseHandle();
          }
        }
        base.Dispose(disposing);
      }

      public void ShowBalloonTip(int timeout) {
        ShowBalloonTip(timeout, BalloonTipTitle, BalloonTipText, BalloonTipIcon);
      }

      public void ShowBalloonTip(int timeout, string tipTitle, string tipText,
        ToolTipIcon tipIcon) {
        if (timeout < 0)
          throw new ArgumentOutOfRangeException("timeout");

        if (string.IsNullOrEmpty(tipText))
          throw new ArgumentException("tipText");

        if (DesignMode)
          return;

        if (created) {
          NativeMethods.NotifyIconData data = new NativeMethods.NotifyIconData();
          if (window.Handle == IntPtr.Zero)
            window.CreateHandle(new CreateParams());

          data.Window = window.Handle;
          data.ID = id;
          data.Flags = NativeMethods.NotifyIconDataFlags.Info;
          data.TimeoutOrVersion = timeout;
          data.InfoTitle = tipTitle;
          data.Info = tipText;
          data.InfoFlags = (int)tipIcon;

          NativeMethods.Shell_NotifyIcon(
            NativeMethods.NotifyIconMessage.Modify, data);
        }
      }

      private void ShowContextMenu() {
        if (ContextMenu == null && ContextMenuStrip == null)
          return;

        NativeMethods.Point p = new NativeMethods.Point();
        NativeMethods.GetCursorPos(ref p);
        NativeMethods.SetForegroundWindow(
          new HandleRef(window, window.Handle));

        if (ContextMenu != null) {
          ContextMenu.GetType().InvokeMember("OnPopup",
            BindingFlags.NonPublic | BindingFlags.InvokeMethod |
            BindingFlags.Instance, null, ContextMenu,
            new Object[] { System.EventArgs.Empty });

          NativeMethods.TrackPopupMenuEx(
            new HandleRef(ContextMenu, ContextMenu.Handle), 72,
            p.x, p.y, new HandleRef(window, window.Handle),
            IntPtr.Zero);

          NativeMethods.PostMessage(
            new HandleRef(window, window.Handle), WM_NULL, 0, 0);
          return;
        }

        if (ContextMenuStrip != null)
          ContextMenuStrip.GetType().InvokeMember("ShowInTaskbar",
            BindingFlags.NonPublic | BindingFlags.InvokeMethod |
            BindingFlags.Instance, null, ContextMenuStrip,
            new Object[] { p.x, p.y });
      }

      private void UpdateNotifyIcon(bool showNotifyIcon) {
        if (DesignMode)
          return;

        lock (syncObj) {
          window.LockReference(showNotifyIcon);

          NativeMethods.NotifyIconData data = new NativeMethods.NotifyIconData();
          data.CallbackMessage = WM_TRAYMOUSEMESSAGE;
          data.Flags = NativeMethods.NotifyIconDataFlags.Message;

          if (showNotifyIcon && window.Handle == IntPtr.Zero)
            window.CreateHandle(new CreateParams());

          data.Window = window.Handle;
          data.ID = id;

          if (icon != null) {
            data.Flags |= NativeMethods.NotifyIconDataFlags.Icon;
            data.Icon = icon.Handle;
          }

          data.Flags |= NativeMethods.NotifyIconDataFlags.Tip;
          data.Tip = text;

          if (showNotifyIcon && icon != null) {
            if (!created) {
              int i = 0;
              do {
                created = NativeMethods.Shell_NotifyIcon(
                  NativeMethods.NotifyIconMessage.Add, data);
                if (!created) {
                  System.Threading.Thread.Sleep(200);
                  i++;
                }
              } while (!created && i < 40);
            } else {
              NativeMethods.Shell_NotifyIcon(
                NativeMethods.NotifyIconMessage.Modify, data);
            }
          } else {
            if (created) {
              int i = 0;
              bool deleted = false;
              do {
                deleted = NativeMethods.Shell_NotifyIcon(
                  NativeMethods.NotifyIconMessage.Delete, data);
                if (!deleted) {
                  System.Threading.Thread.Sleep(200);
                  i++;
                }
              } while (!deleted && i < 40);
              created = false;
            }
          }
        }
      }

      private void ProcessMouseDown(ref Message message, MouseButtons button,
        bool doubleClick) {
        if (doubleClick) {
          if (DoubleClick != null)
            DoubleClick(this, new MouseEventArgs(button, 2, 0, 0, 0));

          if (MouseDoubleClick != null)
            MouseDoubleClick(this, new MouseEventArgs(button, 2, 0, 0, 0));

          doubleClickDown = true;
        }

        if (MouseDown != null)
          MouseDown(this,
            new MouseEventArgs(button, doubleClick ? 2 : 1, 0, 0, 0));
      }

      private void ProcessMouseUp(ref Message message, MouseButtons button) {
        if (MouseUp != null)
          MouseUp(this, new MouseEventArgs(button, 0, 0, 0, 0));

        if (!doubleClickDown) {
          if (Click != null)
            Click(this, new MouseEventArgs(button, 0, 0, 0, 0));

          if (MouseClick != null)
            MouseClick(this, new MouseEventArgs(button, 0, 0, 0, 0));
        }
        doubleClickDown = false;
      }

      private void ProcessInitMenuPopup(ref Message message) {
        if (ContextMenu != null &&
          (bool)ContextMenu.GetType().InvokeMember("ProcessInitMenuPopup",
            BindingFlags.NonPublic | BindingFlags.InvokeMethod |
            BindingFlags.Instance, null, ContextMenu,
            new Object[] { message.WParam })) {
          return;
        }
        window.DefWndProc(ref message);
      }

      private void WndProc(ref Message message) {
        switch (message.Msg) {
          case WM_DESTROY:
            UpdateNotifyIcon(false);
            return;
          case WM_COMMAND:
            if (message.LParam != IntPtr.Zero) {
              window.DefWndProc(ref message);
              return;
            }
            commandDispatch.Invoke(null, new object[] { 
            message.WParam.ToInt32() & 0xFFFF });
            return;
          case WM_INITMENUPOPUP:
            ProcessInitMenuPopup(ref message);
            return;
          case WM_TRAYMOUSEMESSAGE:
            switch ((int)message.LParam) {
              case WM_MOUSEMOVE:
                if (MouseMove != null)
                  MouseMove(this,
                    new MouseEventArgs(Control.MouseButtons, 0, 0, 0, 0));
                return;
              case WM_LBUTTONDOWN:
                ProcessMouseDown(ref message, MouseButtons.Left, false);
                return;
              case WM_LBUTTONUP:
                ProcessMouseUp(ref message, MouseButtons.Left);
                return;
              case WM_LBUTTONDBLCLK:
                ProcessMouseDown(ref message, MouseButtons.Left, true);
                return;
              case WM_RBUTTONDOWN:
                ProcessMouseDown(ref message, MouseButtons.Right, false);
                return;
              case WM_RBUTTONUP:
                if (ContextMenu != null || ContextMenuStrip != null)
                  ShowContextMenu();
                ProcessMouseUp(ref message, MouseButtons.Right);
                return;
              case WM_RBUTTONDBLCLK:
                ProcessMouseDown(ref message, MouseButtons.Right, true);
                return;
              case WM_MBUTTONDOWN:
                ProcessMouseDown(ref message, MouseButtons.Middle, false);
                return;
              case WM_MBUTTONUP:
                ProcessMouseUp(ref message, MouseButtons.Middle);
                return;
              case WM_MBUTTONDBLCLK:
                ProcessMouseDown(ref message, MouseButtons.Middle, true);
                return;
              case NIN_BALLOONSHOW:
                if (BalloonTipShown != null)
                  BalloonTipShown(this, EventArgs.Empty);
                return;
              case NIN_BALLOONHIDE:
              case NIN_BALLOONTIMEOUT:
                if (BalloonTipClosed != null)
                  BalloonTipClosed(this, EventArgs.Empty);
                return;
              case NIN_BALLOONUSERCLICK:
                if (BalloonTipClicked != null)
                  BalloonTipClicked(this, EventArgs.Empty);
                return;
              default:
                return;
            }
        }

        if (message.Msg == NotifyIconWindowsImplementation.WM_TASKBARCREATED) {
          lock (syncObj) {
            created = false;
          }
          UpdateNotifyIcon(visible);
        }

        window.DefWndProc(ref message);
      }

      private class NotifyIconNativeWindow : NativeWindow {
        private NotifyIconWindowsImplementation reference;
        private GCHandle referenceHandle;

        internal NotifyIconNativeWindow(NotifyIconWindowsImplementation component) {
          this.reference = component;
        }

        ~NotifyIconNativeWindow() {
          if (base.Handle != IntPtr.Zero)
            NativeMethods.PostMessage(
              new HandleRef(this, base.Handle), WM_CLOSE, 0, 0);
        }

        public void LockReference(bool locked) {
          if (locked) {
            if (!referenceHandle.IsAllocated) {
              referenceHandle = GCHandle.Alloc(reference, GCHandleType.Normal);
              return;
            }
          } else {
            if (referenceHandle.IsAllocated)
              referenceHandle.Free();
          }
        }

        protected override void OnThreadException(Exception e) {
          Application.OnThreadException(e);
        }

        protected override void WndProc(ref Message m) {
          reference.WndProc(ref m);
        }
      }

      private const int WM_NULL = 0x00;
      private const int WM_DESTROY = 0x02;
      private const int WM_CLOSE = 0x10;
      private const int WM_COMMAND = 0x111;
      private const int WM_INITMENUPOPUP = 0x117;
      private const int WM_MOUSEMOVE = 0x200;
      private const int WM_LBUTTONDOWN = 0x201;
      private const int WM_LBUTTONUP = 0x202;
      private const int WM_LBUTTONDBLCLK = 0x203;
      private const int WM_RBUTTONDOWN = 0x204;
      private const int WM_RBUTTONUP = 0x205;
      private const int WM_RBUTTONDBLCLK = 0x206;
      private const int WM_MBUTTONDOWN = 0x207;
      private const int WM_MBUTTONUP = 0x208;
      private const int WM_MBUTTONDBLCLK = 0x209;
      private const int WM_TRAYMOUSEMESSAGE = 0x800;

      private const int NIN_BALLOONSHOW = 0x402;
      private const int NIN_BALLOONHIDE = 0x403;
      private const int NIN_BALLOONTIMEOUT = 0x404;
      private const int NIN_BALLOONUSERCLICK = 0x405;

      private static int WM_TASKBARCREATED =
        NativeMethods.RegisterWindowMessage("TaskbarCreated");

      private static class NativeMethods {
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr PostMessage(HandleRef hwnd, int msg,
          int wparam, int lparam);

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern int RegisterWindowMessage(string msg);

        [Flags]
        public enum NotifyIconDataFlags : int {
          Message = 0x1,
          Icon = 0x2,
          Tip = 0x4,
          State = 0x8,
          Info = 0x10
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        public class NotifyIconData {
          private int Size = Marshal.SizeOf(typeof(NotifyIconData));
          public IntPtr Window;
          public int ID;
          public NotifyIconDataFlags Flags;
          public int CallbackMessage;
          public IntPtr Icon;
          [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
          public string Tip;
          public int State;
          public int StateMask;
          [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
          public string Info;
          public int TimeoutOrVersion;
          [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
          public string InfoTitle;
          public int InfoFlags;
        }

        public enum NotifyIconMessage : int {
          Add = 0x0,
          Modify = 0x1,
          Delete = 0x2
        }

        [DllImport("shell32.dll", CharSet = CharSet.Auto)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool Shell_NotifyIcon(NotifyIconMessage message,
          NotifyIconData pnid);

        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern bool TrackPopupMenuEx(HandleRef hmenu, int fuFlags,
          int x, int y, HandleRef hwnd, IntPtr tpm);

        [StructLayout(LayoutKind.Sequential)]
        public struct Point {
          public int x;
          public int y;
        }

        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern bool GetCursorPos(ref Point point);

        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern bool SetForegroundWindow(HandleRef hWnd);
      }
    }
  }
}