/*

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

 */

 using System;

 using System.Collections.Generic;

 using System.Drawing;

 using System.Drawing.Imaging;

 using System.Windows.Forms;

 using System.IO;

 using OpenHardwareMonitor.Hardware;

 namespace OpenHardwareMonitor.GUI {

   public class SensorGadget : Gadget {

     private UnitManager unitManager;

     private Image back = Utilities.EmbeddedResources.GetImage("gadget.png");

     private Image image = null;

     private Image fore = null;

     private Image barBack = Utilities.EmbeddedResources.GetImage("barback.png");

     private Image barFore = Utilities.EmbeddedResources.GetImage("barblue.png");

     private const int topBorder = 6;

     private const int bottomBorder = 7;

     private const int leftBorder = 6;

     private const int rightBorder = 7;

     private Image background = new Bitmap(1, 1);

     private readonly float scale;

     private float fontSize;

     private int iconSize;

     private int hardwareLineHeight;

     private int sensorLineHeight;

     private int rightMargin;

     private int leftMargin;

     private int topMargin;

     private int bottomMargin;

     private int progressWidth;

     private IDictionary<IHardware, IList<ISensor>> sensors =

       new SortedDictionary<IHardware, IList<ISensor>>(new HardwareComparer());

     private PersistentSettings settings;

     private UserOption hardwareNames;

     private UserOption alwaysOnTop;

     private UserOption lockPositionAndSize;

     private Font largeFont;

     private Font smallFont;

     private Brush darkWhite;

     private StringFormat stringFormat;

     private StringFormat trimStringFormat;

     private StringFormat alignRightStringFormat;

     public SensorGadget(IComputer computer, PersistentSettings settings, 

       UnitManager unitManager) 

     {

       this.unitManager = unitManager;

       this.settings = settings;

       computer.HardwareAdded += new HardwareEventHandler(HardwareAdded);

       computer.HardwareRemoved += new HardwareEventHandler(HardwareRemoved);      

       this.darkWhite = new SolidBrush(Color.FromArgb(0xF0, 0xF0, 0xF0));

       this.stringFormat = new StringFormat();

       this.stringFormat.FormatFlags = StringFormatFlags.NoWrap;

       this.trimStringFormat = new StringFormat();

       this.trimStringFormat.Trimming = StringTrimming.EllipsisCharacter;

       this.trimStringFormat.FormatFlags = StringFormatFlags.NoWrap;

       this.alignRightStringFormat = new StringFormat();

       this.alignRightStringFormat.Alignment = StringAlignment.Far;

       this.alignRightStringFormat.FormatFlags = StringFormatFlags.NoWrap;

       if (File.Exists("gadget_background.png")) {

         try { 

           Image newBack = new Bitmap("gadget_background.png");

           back.Dispose();

           back = newBack;

         } catch { }

       }

       if (File.Exists("gadget_image.png")) {

         try {

           image = new Bitmap("gadget_image.png"); 

         } catch {}

       }

       if (File.Exists("gadget_foreground.png")) {

         try {

           fore = new Bitmap("gadget_foreground.png"); 

         } catch { }

       }

       if (File.Exists("gadget_bar_background.png")) {

         try {

           Image newBarBack = new Bitmap("gadget_bar_background.png");

           barBack.Dispose();

           barBack = newBarBack;

         } catch { }

       }

       if (File.Exists("gadget_bar_foreground.png")) {

         try {

           Image newBarColor = new Bitmap("gadget_bar_foreground.png");

           barFore.Dispose();

           barFore = newBarColor;

         } catch { }

       }

       this.Location = new Point(

         settings.GetValue("sensorGadget.Location.X", 100),

         settings.GetValue("sensorGadget.Location.Y", 100)); 

       LocationChanged += delegate(object sender, EventArgs e) {

         settings.SetValue("sensorGadget.Location.X", Location.X);

         settings.SetValue("sensorGadget.Location.Y", Location.Y);

       };

       // get the custom to default dpi ratio

       using (Bitmap b = new Bitmap(1, 1)) {

         scale = b.HorizontalResolution / 96.0f;

       }

       SetFontSize(settings.GetValue("sensorGadget.FontSize", 7.5f));

       Resize(settings.GetValue("sensorGadget.Width", Size.Width));

       ContextMenu contextMenu = new ContextMenu();

       MenuItem hardwareNamesItem = new MenuItem("Hardware Names");

       contextMenu.MenuItems.Add(hardwareNamesItem);

       MenuItem fontSizeMenu = new MenuItem("Font Size");

       for (int i = 0; i < 4; i++) {

         float size;

         string name;

         switch (i) {

           case 0: size = 6.5f; name = "Small"; break;

           case 1: size = 7.5f; name = "Medium"; break;

           case 2: size = 9f; name = "Large"; break;

           case 3: size = 11f; name = "Very Large"; break;

           default: throw new NotImplementedException();

         }

         MenuItem item = new MenuItem(name);

         item.Checked = fontSize == size;

         item.Click += delegate(object sender, EventArgs e) {

           SetFontSize(size);

           settings.SetValue("sensorGadget.FontSize", size);

           foreach (MenuItem mi in fontSizeMenu.MenuItems)

             mi.Checked = mi == item;

         };

         fontSizeMenu.MenuItems.Add(item);

       }

       contextMenu.MenuItems.Add(fontSizeMenu);

       contextMenu.MenuItems.Add(new MenuItem("-"));

       MenuItem lockItem = new MenuItem("Lock Position and Size");

       contextMenu.MenuItems.Add(lockItem);

       contextMenu.MenuItems.Add(new MenuItem("-"));

       MenuItem alwaysOnTopItem = new MenuItem("Always on Top");

       contextMenu.MenuItems.Add(alwaysOnTopItem);

       MenuItem opacityMenu = new MenuItem("Opacity");

       contextMenu.MenuItems.Add(opacityMenu);

       Opacity = (byte)settings.GetValue("sensorGadget.Opacity", 255);      

       for (int i = 0; i < 5; i++) {

         MenuItem item = new MenuItem((20 * (i + 1)).ToString() + " %");

         byte o = (byte)(51 * (i + 1));

         item.Checked = Opacity == o;

         item.Click += delegate(object sender, EventArgs e) {

           Opacity = o;

           settings.SetValue("sensorGadget.Opacity", Opacity);

           foreach (MenuItem mi in opacityMenu.MenuItems)

             mi.Checked = mi == item;          

         };

         opacityMenu.MenuItems.Add(item);

       }

       this.ContextMenu = contextMenu;

       hardwareNames = new UserOption("sensorGadget.Hardwarenames", true,

         hardwareNamesItem, settings);

       hardwareNames.Changed += delegate(object sender, EventArgs e) {

         Resize();

       };

       alwaysOnTop = new UserOption("sensorGadget.AlwaysOnTop", false, 

         alwaysOnTopItem, settings);

       alwaysOnTop.Changed += delegate(object sender, EventArgs e) {

         this.AlwaysOnTop = alwaysOnTop.Value;

       };

       lockPositionAndSize = new UserOption("sensorGadget.LockPositionAndSize", 

         false, lockItem, settings);

       lockPositionAndSize.Changed += delegate(object sender, EventArgs e) {

         this.LockPositionAndSize = lockPositionAndSize.Value;

       };

       HitTest += delegate(object sender, HitTestEventArgs e) {

         if (lockPositionAndSize.Value)

           return;

         if (e.Location.X < leftBorder) {

           e.HitResult = HitResult.Left;

           return;

         }

         if (e.Location.X > Size.Width - 1 - rightBorder) {

           e.HitResult = HitResult.Right;

           return;

         }

       };

       SizeChanged += delegate(object sender, EventArgs e) {

         settings.SetValue("sensorGadget.Width", Size.Width);

         Redraw();

       };

       VisibleChanged += delegate(object sender, EventArgs e) {

         Rectangle bounds = new Rectangle(Location, Size);

         Screen screen = Screen.FromRectangle(bounds);

         Rectangle intersection = 

           Rectangle.Intersect(screen.WorkingArea, bounds);

         if (intersection.Width < Math.Min(16, bounds.Width) || 

             intersection.Height < Math.Min(16, bounds.Height)) 

         {

           Location = new Point(

             screen.WorkingArea.Width / 2 - bounds.Width / 2, 

             screen.WorkingArea.Height / 2 - bounds.Height / 2);

         }

       };

       MouseDoubleClick += delegate(object obj, MouseEventArgs args) {

         SendHideShowCommand();

       };

     }

     public override void Dispose() {

       largeFont.Dispose();

       largeFont = null;

       smallFont.Dispose();

       smallFont = null;

       darkWhite.Dispose();

       darkWhite = null;

       stringFormat.Dispose();

       stringFormat = null;

       trimStringFormat.Dispose();

       trimStringFormat = null;

       alignRightStringFormat.Dispose();

       alignRightStringFormat = null;     

       back.Dispose();

       back = null;

       barFore.Dispose();

       barFore = null;

       barBack.Dispose();

       barBack = null;

       background.Dispose();

       background = null;

       if (image != null) {

         image.Dispose();

         image = null;

       }

       if (fore != null) {

         fore.Dispose();

         fore = null;

       }

       base.Dispose();

     }

     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,

         "gadget").ToString(), false)) 

         Add(sensor);

     }

     private void SensorRemoved(ISensor sensor) {

       if (Contains(sensor))

         Remove(sensor, false);

     }

     public bool Contains(ISensor sensor) {

       foreach (IList<ISensor> list in sensors.Values)

         if (list.Contains(sensor))

           return true;

       return false;

     }

     public void Add(ISensor sensor) {

       if (Contains(sensor)) {

         return;

       } else {

         // get the right hardware

         IHardware hardware = sensor.Hardware;

         while (hardware.Parent != null)

           hardware = hardware.Parent;

         // get the sensor list associated with the hardware

         IList<ISensor> list;

         if (!sensors.TryGetValue(hardware, out list)) {

           list = new List<ISensor>();

           sensors.Add(hardware, list);

         }

         // insert the sensor at the right position

         int i = 0;

         while (i < list.Count && (list[i].SensorType < sensor.SensorType || 

           (list[i].SensorType == sensor.SensorType && 

            list[i].Index < sensor.Index))) i++;

         list.Insert(i, sensor);

         settings.SetValue(

           new Identifier(sensor.Identifier, "gadget").ToString(), true);

         Resize();

       }

     }

     public void Remove(ISensor sensor) {

       Remove(sensor, true);

     }

     private void Remove(ISensor sensor, bool deleteConfig) {

       if (deleteConfig) 

         settings.Remove(new Identifier(sensor.Identifier, "gadget").ToString());

       foreach (KeyValuePair<IHardware, IList<ISensor>> keyValue in sensors)

         if (keyValue.Value.Contains(sensor)) {

           keyValue.Value.Remove(sensor);          

           if (keyValue.Value.Count == 0) {

             sensors.Remove(keyValue.Key);

             break;

           }

         }

       Resize();

     }

     public event EventHandler HideShowCommand;

     public void SendHideShowCommand() {

       if (HideShowCommand != null)

         HideShowCommand(this, null);

     }

     private Font CreateFont(float size, FontStyle style) {

       try {

         return new Font(SystemFonts.MessageBoxFont.FontFamily, size, style);

       } catch (ArgumentException) {

         // if the style is not supported, fall back to the original one

         return new Font(SystemFonts.MessageBoxFont.FontFamily, size, 

           SystemFonts.MessageBoxFont.Style);

       }

     }

     private void SetFontSize(float size) {

       fontSize = size;

       largeFont = CreateFont(fontSize, FontStyle.Bold);

       smallFont = CreateFont(fontSize, FontStyle.Regular);

       double scaledFontSize = fontSize * scale;

       iconSize = (int)Math.Round(1.5 * scaledFontSize);

       hardwareLineHeight = (int)Math.Round(1.66 * scaledFontSize);

       sensorLineHeight = (int)Math.Round(1.33 * scaledFontSize);

       leftMargin = leftBorder + (int)Math.Round(0.3 * scaledFontSize);

       rightMargin = rightBorder + (int)Math.Round(0.3 * scaledFontSize);

       topMargin = topBorder;

       bottomMargin = bottomBorder + (int)Math.Round(0.3 * scaledFontSize);

       progressWidth = (int)Math.Round(5.3 * scaledFontSize);

       Resize((int)Math.Round(17.3 * scaledFontSize));

     }

     private void Resize() {

       Resize(this.Size.Width);

     }

     private void Resize(int width) {

       int y = topMargin;      

       foreach (KeyValuePair<IHardware, IList<ISensor>> pair in sensors) {

         if (hardwareNames.Value) {

           if (y > topMargin)

             y += hardwareLineHeight - sensorLineHeight;

           y += hardwareLineHeight;

         }

         y += pair.Value.Count * sensorLineHeight;

       }      

       if (sensors.Count == 0)

         y += 4 * sensorLineHeight + hardwareLineHeight;

       y += bottomMargin;

       this.Size = new Size(width, y);

     }

     private void DrawImageWidthBorder(Graphics g, int width, int height, 

       Image back, int t, int b, int l, int r) 

     {

       GraphicsUnit u = GraphicsUnit.Pixel;

       g.DrawImage(back, new Rectangle(0, 0, l, t),

             new Rectangle(0, 0, l, t), u);

       g.DrawImage(back, new Rectangle(l, 0, width - l - r, t),

         new Rectangle(l, 0, back.Width - l - r, t), u);

       g.DrawImage(back, new Rectangle(width - r, 0, r, t),

         new Rectangle(back.Width - r, 0, r, t), u);

       g.DrawImage(back, new Rectangle(0, t, l, height - t - b),

         new Rectangle(0, t, l, back.Height - t - b), u);

       g.DrawImage(back, new Rectangle(l, t, width - l - r, height - t - b),

         new Rectangle(l, t, back.Width - l - r, back.Height - t - b), u);

       g.DrawImage(back, new Rectangle(width - r, t, r, height - t - b),

         new Rectangle(back.Width - r, t, r, back.Height - t - b), u);

       g.DrawImage(back, new Rectangle(0, height - b, l, b),

         new Rectangle(0, back.Height - b, l, b), u);

       g.DrawImage(back, new Rectangle(l, height - b, width - l - r, b),

         new Rectangle(l, back.Height - b, back.Width - l - r, b), u);

       g.DrawImage(back, new Rectangle(width - r, height - b, r, b),

         new Rectangle(back.Width - r, back.Height - b, r, b), u);

     }

     private void DrawBackground(Graphics g) {

       int w = Size.Width;

       int h = Size.Height;      

       if (w != background.Width || h != background.Height) {

         background.Dispose();

         background = new Bitmap(w, h, PixelFormat.Format32bppPArgb);

         using (Graphics graphics = Graphics.FromImage(background)) {

           DrawImageWidthBorder(graphics, w, h, back, topBorder, bottomBorder, 

             leftBorder, rightBorder);    

           if (fore != null)

             DrawImageWidthBorder(graphics, w, h, fore, topBorder, bottomBorder,

             leftBorder, rightBorder);

           if (image != null) {

             int width = w - leftBorder - rightBorder;

             int height = h - topBorder - bottomBorder;

             float xRatio = width / (float)image.Width;

             float yRatio = height / (float)image.Height;

             float destWidth, destHeight;

             float xOffset, yOffset;

             if (xRatio < yRatio) {

               destWidth = width;

               destHeight = image.Height * xRatio;

               xOffset = 0;

               yOffset = 0.5f * (height - destHeight);

             } else {

               destWidth = image.Width * yRatio;

               destHeight = height;

               xOffset = 0.5f * (width - destWidth);

               yOffset = 0;

             }

             graphics.DrawImage(image,

               new RectangleF(leftBorder + xOffset, topBorder + yOffset, 

                 destWidth, destHeight));

           }

         }

       }

       g.DrawImageUnscaled(background, 0, 0);

     }

     private void DrawProgress(Graphics g, float x, float y, 

       float width, float height, float progress) 

     {

       g.DrawImage(barBack, 

         new RectangleF(x + width * progress, y, width * (1 - progress), height), 

         new RectangleF(barBack.Width * progress, 0, 

           (1 - progress) * barBack.Width, barBack.Height), 

         GraphicsUnit.Pixel);

       g.DrawImage(barFore,

         new RectangleF(x, y, width * progress, height),

         new RectangleF(0, 0, progress * barFore.Width, barFore.Height),

         GraphicsUnit.Pixel);

     }

     protected override void OnPaint(PaintEventArgs e) {

       Graphics g = e.Graphics;

       int w = Size.Width;

       g.Clear(Color.Transparent);

       DrawBackground(g);

       int x;

       int y = topMargin;

       if (sensors.Count == 0) {

         x = leftBorder + 1;

         g.DrawString("Right-click on a sensor in the main window and select " + 

           "\"Show in Gadget\" to show the sensor here.", 

           smallFont, Brushes.White,

           new Rectangle(x, y - 1, w - rightBorder - x, 0));

       }

       foreach (KeyValuePair<IHardware, IList<ISensor>> pair in sensors) {

         if (hardwareNames.Value) {

           if (y > topMargin)

             y += hardwareLineHeight - sensorLineHeight;

           x = leftBorder + 1;

           g.DrawImage(HardwareTypeImage.Instance.GetImage(pair.Key.HardwareType),

             new Rectangle(x, y + 1, iconSize, iconSize));

           x += iconSize + 1;

           g.DrawString(pair.Key.Name, largeFont, Brushes.White,

             new Rectangle(x, y - 1, w - rightBorder - x, 0), 

             stringFormat);

           y += hardwareLineHeight;

         }

         foreach (ISensor sensor in pair.Value) {

           int remainingWidth;

           if ((sensor.SensorType != SensorType.Load &&

                sensor.SensorType != SensorType.Control &&

                sensor.SensorType != SensorType.Level) || !sensor.Value.HasValue) 

           {

             string formatted;

             if (sensor.Value.HasValue) {

               string format = "";

               switch (sensor.SensorType) {

                 case SensorType.Voltage:

                   format = "{0:F3} V";

                   break;

                 case SensorType.Clock:

                   format = "{0:F0} MHz";

                   break;

                 case SensorType.Temperature:

                   format = "{0:F1} °C";

                   break;

                 case SensorType.Fan:

                   format = "{0:F0} RPM";

                   break;

                 case SensorType.Flow:

                   format = "{0:F0} L/h";

                   break;

                 case SensorType.Power:

                   format = "{0:F1} W";

                   break;

                 case SensorType.Data:

                   format = "{0:F1} GB";

                   break;

                 case SensorType.Factor:

                   format = "{0:F3}";

                   break;

               }

               if (sensor.SensorType == SensorType.Temperature &&

                 unitManager.TemperatureUnit == TemperatureUnit.Fahrenheit) {

                 formatted = string.Format("{0:F1} °F",

                   UnitManager.CelsiusToFahrenheit(sensor.Value));

               } else {

                 formatted = string.Format(format, sensor.Value);

               }

             } else {

               formatted = "-";

             }

             g.DrawString(formatted, smallFont, darkWhite,

               new RectangleF(-1, y - 1, w - rightMargin + 3, 0),

               alignRightStringFormat);

             remainingWidth = w - (int)Math.Floor(g.MeasureString(formatted,

               smallFont, w, StringFormat.GenericTypographic).Width) -

               rightMargin;

           } else {

             DrawProgress(g, w - progressWidth - rightMargin,

               y + 0.35f * sensorLineHeight, progressWidth,

               0.6f * sensorLineHeight, 0.01f * sensor.Value.Value);

             remainingWidth = w - progressWidth - rightMargin;

           }

           remainingWidth -= leftMargin + 2;

           if (remainingWidth > 0) {

             g.DrawString(sensor.Name, smallFont, darkWhite,

               new RectangleF(leftMargin - 1, y - 1, remainingWidth, 0), 

               trimStringFormat);

           }

           y += sensorLineHeight;

         }

       }

     }

     private class HardwareComparer : IComparer<IHardware> {

       public int Compare(IHardware x, IHardware y) {

         if (x == null && y == null)

           return 0;

         if (x == null)

           return -1;

         if (y == null)

           return 1;

         if (x.HardwareType != y.HardwareType)

           return x.HardwareType.CompareTo(y.HardwareType);

         return x.Identifier.CompareTo(y.Identifier);

       }

     }

   }

 }