/*

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

 	Copyright (C) 2010 Paul Werelds

   Copyright (C) 2011 Roland Reinl <roland-reinl@gmx.de>

 */

 using System;

 using System.Collections.Generic;

 using System.Globalization;

 using System.IO;

 using System.Text;

 using OpenHardwareMonitor.Collections;

 namespace OpenHardwareMonitor.Hardware.HDD {

   internal abstract class AbstractHarddrive : Hardware {

     private const int UPDATE_DIVIDER = 30; // update only every 30s

     // array of all harddrive types, matching type is searched in this order

     private static Type[] hddTypes = {       

       typeof(SSDPlextor),

       typeof(SSDIntel),

       typeof(SSDSandforce),

       typeof(SSDIndilinx),

       typeof(SSDSamsung),

       typeof(SSDMicron),

       typeof(GenericHarddisk)

     };

     private string firmwareRevision;

     private readonly ISmart smart;

     private readonly IntPtr handle;

     private readonly int index;

     private int count;

     private IList<SmartAttribute> smartAttributes;

     private IDictionary<SmartAttribute, Sensor> sensors;

     private DriveInfo[] driveInfos;

     private Sensor usageSensor;

     protected AbstractHarddrive(ISmart smart, string name, 

       string firmwareRevision, int index, 

       IEnumerable<SmartAttribute> smartAttributes, ISettings settings) 

       : base(name, new Identifier("hdd",

         index.ToString(CultureInfo.InvariantCulture)), settings)

     {

       this.firmwareRevision = firmwareRevision;

       this.smart = smart;

       handle = smart.OpenDrive(index);

       if (handle != smart.InvalidHandle)

         smart.EnableSmart(handle, index);

       this.index = index;

       this.count = 0;

       this.smartAttributes = new List<SmartAttribute>(smartAttributes);

       string[] logicalDrives = smart.GetLogicalDrives(index);

       List<DriveInfo> driveInfoList = new List<DriveInfo>(logicalDrives.Length);

       foreach (string logicalDrive in logicalDrives) {

         try {

           DriveInfo di = new DriveInfo(logicalDrive);

           if (di.TotalSize > 0) 

             driveInfoList.Add(new DriveInfo(logicalDrive));

         } catch (ArgumentException) { } catch (IOException) { }

       }

       driveInfos = driveInfoList.ToArray();

       CreateSensors();

     }

     public static AbstractHarddrive CreateInstance(ISmart smart, 

       int driveIndex, ISettings settings) 

     {

       IntPtr deviceHandle = smart.OpenDrive(driveIndex);

       string name = null;

       string firmwareRevision = null;

       DriveAttributeValue[] values = { };

       if (deviceHandle != smart.InvalidHandle) {

         bool nameValid = smart.ReadNameAndFirmwareRevision(deviceHandle,

         driveIndex, out name, out firmwareRevision);

         bool smartEnabled = smart.EnableSmart(deviceHandle, driveIndex);

         if (smartEnabled)

           values = smart.ReadSmartData(deviceHandle, driveIndex);

         smart.CloseHandle(deviceHandle);

         if (!nameValid) {

           name = null;

           firmwareRevision = null;

         }

       } else {

         string[] logicalDrives = smart.GetLogicalDrives(driveIndex);

         if (logicalDrives == null || logicalDrives.Length == 0)

           return null;

       }

       if (string.IsNullOrEmpty(name))

         name = "Generic Hard Disk";

       if (string.IsNullOrEmpty(firmwareRevision))

         firmwareRevision = "Unknown";

       foreach (Type type in hddTypes) {

         // get the array of name prefixes for the current type

         NamePrefixAttribute[] namePrefixes = type.GetCustomAttributes(

           typeof(NamePrefixAttribute), true) as NamePrefixAttribute[];

         // get the array of the required SMART attributes for the current type

         RequireSmartAttribute[] requiredAttributes = type.GetCustomAttributes(

           typeof(RequireSmartAttribute), true) as RequireSmartAttribute[];

         // check if all required attributes are present

         bool allRequiredAttributesFound = true;

         foreach (var requireAttribute in requiredAttributes) {

           bool adttributeFound = false;

           foreach (DriveAttributeValue value in values) {

             if (value.Identifier == requireAttribute.AttributeId) {

               adttributeFound = true;

               break;

             }

           }

           if (!adttributeFound) {

             allRequiredAttributesFound = false;

             break;

           }

         }

         // if an attribute is missing, then try the next type

         if (!allRequiredAttributesFound)

           continue;        

         // check if there is a matching name prefix for this type

         foreach (NamePrefixAttribute prefix in namePrefixes) {

           if (name.StartsWith(prefix.Prefix, StringComparison.InvariantCulture)) 

             return Activator.CreateInstance(type, smart, name, firmwareRevision,

               driveIndex, settings) as AbstractHarddrive;

         }

       }

       // no matching type has been found

       return null;

     }

     private void CreateSensors() {

       sensors = new Dictionary<SmartAttribute, Sensor>();

       if (handle != smart.InvalidHandle) {

         IList<Pair<SensorType, int>> sensorTypeAndChannels =

           new List<Pair<SensorType, int>>();

         DriveAttributeValue[] values = smart.ReadSmartData(handle, index);

         foreach (SmartAttribute attribute in smartAttributes) {

           if (!attribute.SensorType.HasValue)

             continue;

           bool found = false;

           foreach (DriveAttributeValue value in values) {

             if (value.Identifier == attribute.Identifier) {

               found = true;

               break;

             }

           }

           if (!found)

             continue;

           Pair<SensorType, int> pair = new Pair<SensorType, int>(

             attribute.SensorType.Value, attribute.SensorChannel);

           if (!sensorTypeAndChannels.Contains(pair)) {

             Sensor sensor = new Sensor(attribute.Name,

               attribute.SensorChannel, attribute.DefaultHiddenSensor,

               attribute.SensorType.Value, this, attribute.ParameterDescriptions,

               settings);

             sensors.Add(attribute, sensor);

             ActivateSensor(sensor);

             sensorTypeAndChannels.Add(pair);

           }

         }

       }

       if (driveInfos.Length > 0) {

         usageSensor = 

           new Sensor("Used Space", 0, SensorType.Load, this, settings);

         ActivateSensor(usageSensor);

       }

     }

     public override HardwareType HardwareType {

       get { return HardwareType.HDD; }

     }

     public virtual void UpdateAdditionalSensors(DriveAttributeValue[] values) {}

     public override void Update() {

       if (count == 0) {

         if (handle != smart.InvalidHandle) {

           DriveAttributeValue[] values = smart.ReadSmartData(handle, index);

           foreach (KeyValuePair<SmartAttribute, Sensor> keyValuePair in sensors) 

           {

             SmartAttribute attribute = keyValuePair.Key;

             foreach (DriveAttributeValue value in values) {

               if (value.Identifier == attribute.Identifier) {

                 Sensor sensor = keyValuePair.Value;

                 sensor.Value = attribute.ConvertValue(value, sensor.Parameters);

               }

             }

           }

           UpdateAdditionalSensors(values);

         }

         if (usageSensor != null) {

           long totalSize = 0;

           long totalFreeSpace = 0;

           for (int i = 0; i < driveInfos.Length; i++) {

             if (!driveInfos[i].IsReady)

               continue;

             try {

               totalSize += driveInfos[i].TotalSize;

               totalFreeSpace += driveInfos[i].TotalFreeSpace;

             } catch (IOException) { } catch (UnauthorizedAccessException) { }

           }

           if (totalSize > 0) {

             usageSensor.Value = 100.0f - (100.0f * totalFreeSpace) / totalSize;

           } else {

             usageSensor.Value = null;

           }

         }

       }

       count++; 

       count %= UPDATE_DIVIDER; 

     }

     public override string GetReport() {

       StringBuilder r = new StringBuilder();

       r.AppendLine(this.GetType().Name);

       r.AppendLine();

       r.AppendLine("Drive name: " + name);

       r.AppendLine("Firmware version: " + firmwareRevision);

       r.AppendLine();

       if (handle != smart.InvalidHandle) {

         DriveAttributeValue[] values = smart.ReadSmartData(handle, index);

         DriveThresholdValue[] thresholds =

           smart.ReadSmartThresholds(handle, index);

         if (values.Length > 0) {

           r.AppendFormat(CultureInfo.InvariantCulture,

             " {0}{1}{2}{3}{4}{5}{6}{7}",

             ("ID").PadRight(3),

             ("Description").PadRight(35),

             ("Raw Value").PadRight(13),

             ("Worst").PadRight(6),

             ("Value").PadRight(6),

             ("Thres").PadRight(6),

             ("Physical").PadRight(8),

             Environment.NewLine);

           foreach (DriveAttributeValue value in values) {

             if (value.Identifier == 0x00)

               break;

             byte? threshold = null;

             foreach (DriveThresholdValue t in thresholds) {

               if (t.Identifier == value.Identifier) {

                 threshold = t.Threshold;

               }

             }

             string description = "Unknown";

             float? physical = null;

             foreach (SmartAttribute a in smartAttributes) {

               if (a.Identifier == value.Identifier) {

                 description = a.Name;

                 if (a.HasRawValueConversion | a.SensorType.HasValue)

                   physical = a.ConvertValue(value, null);

                 else

                   physical = null;

               }

             }

             string raw = BitConverter.ToString(value.RawValue);

             r.AppendFormat(CultureInfo.InvariantCulture,

               " {0}{1}{2}{3}{4}{5}{6}{7}",

               value.Identifier.ToString("X2").PadRight(3),

               description.PadRight(35),

               raw.Replace("-", "").PadRight(13),

               value.WorstValue.ToString(CultureInfo.InvariantCulture).PadRight(6),

               value.AttrValue.ToString(CultureInfo.InvariantCulture).PadRight(6),

               (threshold.HasValue ? threshold.Value.ToString(

                 CultureInfo.InvariantCulture) : "-").PadRight(6),

               (physical.HasValue ? physical.Value.ToString(

                 CultureInfo.InvariantCulture) : "-").PadRight(8),

               Environment.NewLine);

           }

           r.AppendLine();

         }

       }

       foreach (DriveInfo di in driveInfos) {

         if (!di.IsReady)

           continue;

         try {

           r.AppendLine("Logical drive name: " + di.Name);

           r.AppendLine("Format: " + di.DriveFormat);

           r.AppendLine("Total size: " + di.TotalSize);

           r.AppendLine("Total free space: " + di.TotalFreeSpace);

           r.AppendLine();

         } catch (IOException) { } catch (UnauthorizedAccessException) { }

       }

       return r.ToString();

     }

     protected static float RawToInt(byte[] raw, byte value,

       IReadOnlyArray<IParameter> parameters) 

     {

       return (raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0];

     }

     public override void Close() {

       if (handle != smart.InvalidHandle)

         smart.CloseHandle(handle);

       base.Close();

     }

     public override void Traverse(IVisitor visitor) {

       foreach (ISensor sensor in Sensors)

         sensor.Accept(visitor);

     }

   }

 }