/*

   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.IO.Compression;

 using OpenHardwareMonitor.Collections;

 namespace OpenHardwareMonitor.Hardware {

   internal class Sensor : ISensor {

     private readonly string defaultName;

     private string name;

     private readonly int index;

     private readonly bool defaultHidden;

     private readonly SensorType sensorType;

     private readonly Hardware hardware;

     private readonly ReadOnlyArray<IParameter> parameters;

     private float? currentValue;

     private float? minValue;

     private float? maxValue;

     private readonly RingCollection<SensorValue> 

       values = new RingCollection<SensorValue>();

     private readonly ISettings settings;

     private IControl control;

     private float sum;

     private int count;

     public Sensor(string name, int index, SensorType sensorType,

       Hardware hardware, ISettings settings) : 

       this(name, index, sensorType, hardware, null, settings) { }

     public Sensor(string name, int index, SensorType sensorType,

       Hardware hardware, ParameterDescription[] parameterDescriptions, 

       ISettings settings) :

       this(name, index, false, sensorType, hardware,

         parameterDescriptions, settings) { }

     public Sensor(string name, int index, bool defaultHidden, 

       SensorType sensorType, Hardware hardware, 

       ParameterDescription[] parameterDescriptions, ISettings settings) 

     {           

       this.index = index;

       this.defaultHidden = defaultHidden;

       this.sensorType = sensorType;

       this.hardware = hardware;

       Parameter[] parameters = new Parameter[parameterDescriptions == null ?

         0 : parameterDescriptions.Length];

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

         parameters[i] = new Parameter(parameterDescriptions[i], this, settings);

       this.parameters = parameters;

       this.settings = settings;

       this.defaultName = name; 

       this.name = settings.GetValue(

         new Identifier(Identifier, "name").ToString(), name);

       GetSensorValuesFromSettings();      

       hardware.Closing += delegate(IHardware h) {

         SetSensorValuesToSettings();

       };

     }

     private void SetSensorValuesToSettings() {

       using (MemoryStream m = new MemoryStream()) {

         using (GZipStream c = new GZipStream(m, CompressionMode.Compress))

         using (BufferedStream b = new BufferedStream(c, 65536))

         using (BinaryWriter writer = new BinaryWriter(b)) {

           long t = 0;

           foreach (SensorValue sensorValue in values) {

             long v = sensorValue.Time.ToBinary();

             writer.Write(v - t);

             t = v;

             writer.Write(sensorValue.Value);

           }

           writer.Flush();

         }

         settings.SetValue(new Identifier(Identifier, "values").ToString(),

           Convert.ToBase64String(m.ToArray()));

       }

     }

     private void GetSensorValuesFromSettings() {

       string name = new Identifier(Identifier, "values").ToString();

       string s = settings.GetValue(name, null);

       try {

         byte[] array = Convert.FromBase64String(s);

         s = null;

         DateTime now = DateTime.UtcNow;

         using (MemoryStream m = new MemoryStream(array))

         using (GZipStream c = new GZipStream(m, CompressionMode.Decompress))

         using (BinaryReader reader = new BinaryReader(c)) {

           try {

             long t = 0;

             while (true) {

               t += reader.ReadInt64();

               DateTime time = DateTime.FromBinary(t);

               if (time > now)

                 break;

               float value = reader.ReadSingle();

               AppendValue(value, time);

             }

           } catch (EndOfStreamException) { }

         }

       } catch { }

       if (values.Count > 0)

         AppendValue(float.NaN, DateTime.UtcNow);

       // remove the value string from the settings to reduce memory usage

       settings.Remove(name);

     }

     private void AppendValue(float value, DateTime time) {

       if (values.Count >= 2 && values.Last.Value == value && 

         values[values.Count - 2].Value == value) {

         values.Last = new SensorValue(value, time);

         return;

       } 

       values.Append(new SensorValue(value, time));

     }

     public IHardware Hardware {

       get { return hardware; }

     }

     public SensorType SensorType {

       get { return sensorType; }

     }

     public Identifier Identifier {

       get {

         return new Identifier(hardware.Identifier,

           sensorType.ToString().ToLowerInvariant(),

           index.ToString(CultureInfo.InvariantCulture));

       }

     }

     public string Name {

       get { 

         return name; 

       }

       set {

         if (!string.IsNullOrEmpty(value)) 

           name = value;          

         else 

           name = defaultName;

         settings.SetValue(new Identifier(Identifier, "name").ToString(), name);

       }

     }

     public int Index {

       get { return index; }

     }

     public bool IsDefaultHidden {

       get { return defaultHidden; }

     }

     public IReadOnlyArray<IParameter> Parameters {

       get { return parameters; }

     }

     public float? Value {

       get { 

         return currentValue; 

       }

       set {

         DateTime now = DateTime.UtcNow;

         while (values.Count > 0 && (now - values.First.Time).TotalDays > 1)

           values.Remove();

         if (value.HasValue) {

           sum += value.Value;

           count++;

           if (count == 4) {

             AppendValue(sum / count, now);

             sum = 0;

             count = 0;

           }

         }

         this.currentValue = value;

         if (minValue > value || !minValue.HasValue)

           minValue = value;

         if (maxValue < value || !maxValue.HasValue)

           maxValue = value;

       }

     }

     public float? Min { get { return minValue; } }

     public float? Max { get { return maxValue; } }

     public void ResetMin() {

       minValue = null;

     }

     public void ResetMax() {

       maxValue = null;

     }

     public IEnumerable<SensorValue> Values {

       get { return values; }

     }    

     public void Accept(IVisitor visitor) {

       if (visitor == null)

         throw new ArgumentNullException("visitor");

       visitor.VisitSensor(this);

     }

     public void Traverse(IVisitor visitor) {

       foreach (IParameter parameter in parameters)

         parameter.Accept(visitor);

     }

     public IControl Control {

       get {

         return control;

       }

       internal set {

         this.control = value;

       }

     }

   }

 }