/*

   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 OpenHardwareMonitor.Hardware;

 namespace OpenHardwareMonitor.GUI {

   public class HardwareNode : Node {

     private PersistentSettings settings;

     private UnitManager unitManager;

     private IHardware hardware;

     private List<TypeNode> typeNodes = new List<TypeNode>();

     public HardwareNode(IHardware hardware, PersistentSettings settings, 

       UnitManager unitManager) : base() 

     {

       this.settings = settings;

       this.unitManager = unitManager;

       this.hardware = hardware;

       this.Image = HardwareTypeImage.Instance.GetImage(hardware.HardwareType);

       foreach (SensorType sensorType in Enum.GetValues(typeof(SensorType)))

         typeNodes.Add(new TypeNode(sensorType));

       foreach (ISensor sensor in hardware.Sensors)

         SensorAdded(sensor);

       hardware.SensorAdded +=new SensorEventHandler(SensorAdded);

       hardware.SensorRemoved += new SensorEventHandler(SensorRemoved);

     }

     public override string Text {

       get { return hardware.Name; }

       set { hardware.Name = value; }

     }

     public IHardware Hardware {

       get { return hardware; }

     }

     private void UpdateNode(TypeNode node) {  

       if (node.Nodes.Count > 0) {

         if (!Nodes.Contains(node)) {

           int i = 0;

           while (i < Nodes.Count &&

             ((TypeNode)Nodes[i]).SensorType < node.SensorType)

             i++;

           Nodes.Insert(i, node);  

         }

       } else {

         if (Nodes.Contains(node))

           Nodes.Remove(node);

       }

     }

     private void SensorRemoved(ISensor sensor) {

       foreach (TypeNode typeNode in typeNodes)

         if (typeNode.SensorType == sensor.SensorType) { 

           SensorNode sensorNode = null;

           foreach (Node node in typeNode.Nodes) {

             SensorNode n = node as SensorNode;

             if (n != null && n.Sensor == sensor)

               sensorNode = n;

           }

           if (sensorNode != null) {

             sensorNode.PlotSelectionChanged -= SensorPlotSelectionChanged;

             typeNode.Nodes.Remove(sensorNode);

             UpdateNode(typeNode);

           }

         }

       if (PlotSelectionChanged != null)

         PlotSelectionChanged(this, null);

     }

     private void InsertSorted(Node node, ISensor sensor) {

       int i = 0;

       while (i < node.Nodes.Count &&

         ((SensorNode)node.Nodes[i]).Sensor.Index < sensor.Index)

         i++;

       SensorNode sensorNode = new SensorNode(sensor, settings, unitManager);

       sensorNode.PlotSelectionChanged += SensorPlotSelectionChanged;

       node.Nodes.Insert(i, sensorNode);

     }

     private void SensorPlotSelectionChanged(object sender, EventArgs e) {

       if (PlotSelectionChanged != null)

         PlotSelectionChanged(this, null);

     }

     private void SensorAdded(ISensor sensor) {

       foreach (TypeNode typeNode in typeNodes)

         if (typeNode.SensorType == sensor.SensorType) {

           InsertSorted(typeNode, sensor);

           UpdateNode(typeNode);          

         }

       if (PlotSelectionChanged != null)

         PlotSelectionChanged(this, null);

     }

     public event EventHandler PlotSelectionChanged;

   }

 }