/*

  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.Globalization;

using System.IO;

using System.Security.Permissions;

using System.Reflection;

namespace OpenHardwareMonitor.Hardware {

  public class Computer : IComputer {

    private readonly List<IGroup> groups = new List<IGroup>();

    private readonly ISettings settings;

    private SMBIOS smbios;

    private bool open;

    private bool mainboardEnabled;

    private bool cpuEnabled;

    private bool ramEnabled;

    private bool gpuEnabled;

    private bool fanControllerEnabled;

    private bool hddEnabled;    

    public Computer() {

      this.settings = new Settings();

    }

    public Computer(ISettings settings) {

      this.settings = settings ?? new Settings();

    }

    private void Add(IGroup group) {

      if (groups.Contains(group))

        return;

      groups.Add(group);

      if (HardwareAdded != null)

        foreach (IHardware hardware in group.Hardware)

          HardwareAdded(hardware);

    }

    private void Remove(IGroup group) {

      if (!groups.Contains(group))

        return;

      groups.Remove(group);

      if (HardwareRemoved != null)

        foreach (IHardware hardware in group.Hardware)

          HardwareRemoved(hardware);

      group.Close();

    }

    private void RemoveType<T>() where T : IGroup {

      List<IGroup> list = new List<IGroup>();

      foreach (IGroup group in groups)

        if (group is T)

          list.Add(group);

      foreach (IGroup group in list)

        Remove(group);

    }

    [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

    public void Open() {

      if (open)

        return;

      this.smbios = new SMBIOS();

      Ring0.Open();

      Opcode.Open();

      if (mainboardEnabled)

        Add(new Mainboard.MainboardGroup(smbios, settings));

      if (cpuEnabled)

        Add(new CPU.CPUGroup(settings));

      if (ramEnabled)

        Add(new RAM.RAMGroup(smbios, settings));

      if (gpuEnabled) {

        Add(new ATI.ATIGroup(settings));

        Add(new Nvidia.NvidiaGroup(settings));

      }

      if (fanControllerEnabled) {

        Add(new TBalancer.TBalancerGroup(settings));

        Add(new Heatmaster.HeatmasterGroup(settings));

      }

      if (hddEnabled)

        Add(new HDD.HarddriveGroup(settings));

      open = true;

    }

    public bool MainboardEnabled {

      get { return mainboardEnabled; }

      [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

      set {

        if (open && value != mainboardEnabled) {

          if (value)

            Add(new Mainboard.MainboardGroup(smbios, settings));

          else

            RemoveType<Mainboard.MainboardGroup>();

        }

        mainboardEnabled = value;

      }

    }

    public bool CPUEnabled {

      get { return cpuEnabled; }

      [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

      set {

        if (open && value != cpuEnabled) {

          if (value)

            Add(new CPU.CPUGroup(settings));

          else

            RemoveType<CPU.CPUGroup>();

        }

        cpuEnabled = value;

      }

    }

    public bool RAMEnabled {

      get { return ramEnabled; }

      [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

      set {

        if (open && value != ramEnabled) {

          if (value)

            Add(new RAM.RAMGroup(smbios, settings));

          else

            RemoveType<RAM.RAMGroup>();

        }

        ramEnabled = value;

      }

    }    

    public bool GPUEnabled {

      get { return gpuEnabled; }

      [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

      set {

        if (open && value != gpuEnabled) {

          if (value) {

            Add(new ATI.ATIGroup(settings));

            Add(new Nvidia.NvidiaGroup(settings));

          } else {

            RemoveType<ATI.ATIGroup>();

            RemoveType<Nvidia.NvidiaGroup>();

          }

        }

        gpuEnabled = value;

      }

    }

    public bool FanControllerEnabled {

      get { return fanControllerEnabled; }

      [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

      set {

        if (open && value != fanControllerEnabled) {

          if (value) {

            Add(new TBalancer.TBalancerGroup(settings));

            Add(new Heatmaster.HeatmasterGroup(settings));

          } else {

            RemoveType<TBalancer.TBalancerGroup>();

            RemoveType<Heatmaster.HeatmasterGroup>();

          }

        }

        fanControllerEnabled = value;

      }

    }

    public bool HDDEnabled {

      get { return hddEnabled; }

      [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

      set {

        if (open && value != hddEnabled) {

          if (value)

            Add(new HDD.HarddriveGroup(settings));

          else

            RemoveType<HDD.HarddriveGroup>();

        }

        hddEnabled = value;

      }

    }

    public IHardware[] Hardware {

      get {

        List<IHardware> list = new List<IHardware>();

        foreach (IGroup group in groups)

          foreach (IHardware hardware in group.Hardware)

            list.Add(hardware);

        return list.ToArray();

      }

    }

    private static void NewSection(TextWriter writer) {

      for (int i = 0; i < 8; i++)

        writer.Write("----------");

      writer.WriteLine();

      writer.WriteLine();

    }

    private static int CompareSensor(ISensor a, ISensor b) {

      int c = a.SensorType.CompareTo(b.SensorType);

      if (c == 0)

        return a.Index.CompareTo(b.Index);

      else

        return c;

    }

    private static void ReportHardwareSensorTree(

      IHardware hardware, TextWriter w, string space) 

    {

      w.WriteLine("{0}|", space);

      w.WriteLine("{0}+- {1} ({2})",

        space, hardware.Name, hardware.Identifier);

      ISensor[] sensors = hardware.Sensors;

      Array.Sort(sensors, CompareSensor);

      foreach (ISensor sensor in sensors) {

        w.WriteLine("{0}|  +- {1,-14} : {2,8:G6} {3,8:G6} {4,8:G6} ({5})", 

          space, sensor.Name, sensor.Value, sensor.Min, sensor.Max, 

          sensor.Identifier);

      }

      foreach (IHardware subHardware in hardware.SubHardware)

        ReportHardwareSensorTree(subHardware, w, "|  ");

    }

    private static void ReportHardwareParameterTree(

      IHardware hardware, TextWriter w, string space) {

      w.WriteLine("{0}|", space);

      w.WriteLine("{0}+- {1} ({2})",

        space, hardware.Name, hardware.Identifier);

      ISensor[] sensors = hardware.Sensors;

      Array.Sort(sensors, CompareSensor);

      foreach (ISensor sensor in sensors) {

        string innerSpace = space + "|  ";

        if (sensor.Parameters.Length > 0) {

          w.WriteLine("{0}|", innerSpace);

          w.WriteLine("{0}+- {1} ({2})",

            innerSpace, sensor.Name, sensor.Identifier);

          foreach (IParameter parameter in sensor.Parameters) {

            string innerInnerSpace = innerSpace + "|  ";

            w.WriteLine("{0}+- {1} : {2}",

              innerInnerSpace, parameter.Name,

              string.Format(CultureInfo.InvariantCulture, "{0} : {1}",

                parameter.DefaultValue, parameter.Value));

          }

        }

      }

      foreach (IHardware subHardware in hardware.SubHardware)

        ReportHardwareParameterTree(subHardware, w, "|  ");

    }

    private static void ReportHardware(IHardware hardware, TextWriter w) {

      string hardwareReport = hardware.GetReport();

      if (!string.IsNullOrEmpty(hardwareReport)) {

        NewSection(w);

        w.Write(hardwareReport);

      }

      foreach (IHardware subHardware in hardware.SubHardware)

        ReportHardware(subHardware, w);

    }

    public string GetReport() {

      using (StringWriter w = new StringWriter(CultureInfo.InvariantCulture)) {

        w.WriteLine();

        w.WriteLine("Open Hardware Monitor Report");

        w.WriteLine();

        Version version = typeof(Computer).Assembly.GetName().Version;

        NewSection(w);

        w.Write("Version: "); w.WriteLine(version.ToString());

        w.WriteLine();

        NewSection(w);

        w.Write("Common Language Runtime: ");

        w.WriteLine(Environment.Version.ToString());

        w.Write("Operating System: ");

        w.WriteLine(Environment.OSVersion.ToString());

        w.Write("Process Type: ");

        w.WriteLine(IntPtr.Size == 4 ? "32-Bit" : "64-Bit");

        w.WriteLine();

        string r = Ring0.GetReport();

        if (r != null) {

          NewSection(w);

          w.Write(r);

          w.WriteLine();

        }

        NewSection(w);

        w.WriteLine("Sensors");

        w.WriteLine();

        foreach (IGroup group in groups) {

          foreach (IHardware hardware in group.Hardware)

            ReportHardwareSensorTree(hardware, w, "");

        }

        w.WriteLine();

        NewSection(w);

        w.WriteLine("Parameters");

        w.WriteLine();

        foreach (IGroup group in groups) {

          foreach (IHardware hardware in group.Hardware)

            ReportHardwareParameterTree(hardware, w, "");

        }

        w.WriteLine();

        foreach (IGroup group in groups) {

          string report = group.GetReport();

          if (!string.IsNullOrEmpty(report)) {

            NewSection(w);

            w.Write(report);

          }

          IHardware[] hardwareArray = group.Hardware;

          foreach (IHardware hardware in hardwareArray)

            ReportHardware(hardware, w);

        }

        return w.ToString();

      }

    }

    public void Close() {      

      if (!open)

        return;

      while (groups.Count > 0) {

        IGroup group = groups[groups.Count - 1];

        Remove(group);         

      } 

      Opcode.Close();

      Ring0.Close();

      this.smbios = null;

      open = false;

    }

    public event HardwareEventHandler HardwareAdded;

    public event HardwareEventHandler HardwareRemoved;

    public void Accept(IVisitor visitor) {

      if (visitor == null)

        throw new ArgumentNullException("visitor");

      visitor.VisitComputer(this);

    }

    public void Traverse(IVisitor visitor) {

      foreach (IGroup group in groups)

        foreach (IHardware hardware in group.Hardware) 

          hardware.Accept(visitor);

    }

    private class Settings : ISettings {

      public bool Contains(string name) {

        return false;

      }

      public void SetValue(string name, string value) { }

      public string GetValue(string name, string value) {

        return value;

      }

      public void Remove(string name) { }

    }

  }

}