///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using log4net;
using TBF.Boxes;
using TBF.BenchControl.Generic;
using TBF.BenchControl.GenericDevices;

namespace TBF.BenchControl.Various.TankWithLevelMsrmnt
{
	public class Tank : TBF.BenchControl.MettlerToledo.TankDraining, IDevice, IScaleOrTank, IVolumeMeter, IOperation
    {
		/// <summary>
		/// Info: StartMassMeasurement() and "Balnce response = .., Mass = ..."
		/// Warn: Start measurement when busy is true
		/// </summary>
		private static readonly ILog log = LogManager.GetLogger(typeof(Tank));
		public override string ToString() { return string.Format("TankWithLevelMsrmnt({0})", Cfg.ToString(1)); }

		readonly TankCfg tankCfg;

		bool useCalibTable;
		double[] calibHeight;
		double[] calibVolume;

		public enum CurrentOp
		{
			None,
			ReadVolume,
            ReadStableVolume,
            ManualReadVolume,
        }
		CurrentOp currentOp;
		DoubleBox volumeBox;
        double sdev;

		TBF.BenchControl.GenericDevices.ILevelMeter levelMeter;
        TBF.BenchControl.GenericDevices.ILevelMeter manualLevelMeter;
        DoubleBox levelBox;
		IOperation readLevelOp;


		/// <summary>
        /// Enumeration of balances via static fields and methods
        /// </summary>
        static int nextTankIdx = 0;
        public static new void ResetStaticProperties()
        {
            nextTankIdx = 0;
        }
		public static int TanksCount { get { return nextTankIdx; } }
        public static Tank[] Tanks;
		///
        protected int tankNr;								/// 0-based tank number
		public int ScaleNr { get { return tankNr + 1; } }	/// Formula fits CEVAK config., TODO: Make ScaleNr a configurable parameter
		/// 
        public double Capacity { get { return tankCfg.Capacity; } }
        public int EmptyTimeSec { get { return tankCfg.DrainTimeSec; } }
		public IValve DrainValve2 { get { return drainValve2; } }
		IValve drainValve2;

		public string Format { get { return "F3"; } }


        public double Volume { get { return Level2Volume(levelMeter.Level); } }


		public Tank()
		{
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="cfg">Balance properties</param>
		/// <param components="cfg">A list of components loaded so far</param>
        public Tank(Generic.IComponentCfg cfg)
			: base(cfg)
        {
			tankCfg = cfg as TankCfg;

            tankNr = nextTankIdx++;
			///
			if (Tanks == null || Tanks.Length < nextTankIdx)
			{
				Tank[] tanksSoFar = Tanks;
				Tanks = new Tank[nextTankIdx];
				if (tanksSoFar != null) for (int i = 0; i < tanksSoFar.Length; i++) Tanks[i] = tanksSoFar[i];
				Tanks[nextTankIdx - 1] = this;
			}

            currentOp = CurrentOp.None;
            levelBox = new DoubleBox();

			log.Debug(this.ToString());
		}


		///
		/// IDevice interface (required to call base and initialize 'DrainValve')
		///
		public void Initialize()
		{
			base.Initalize();

			drainValve2 = TbfComponents.FindComponent(tankCfg.DrainValve2) as IValve;

            manualLevelMeter = new Various.ManualLevelMsrmnt.ManualLevelMsrmnt();
            levelMeter = TbfComponents.FindComponent(tankCfg.LevelMeasurement) as ILevelMeter;
            if (levelMeter == null) levelMeter = manualLevelMeter;

            useCalibTable = LoadCalibrationTable(tankCfg.CalibrationTable);
		}
		public void RunDeviceBefore() { }
		public void RunDeviceAfter() { }
		public void StopDevice() { }
		public void StopDevice2() { }


		public override bool IsEmpty()
		{
            return false;
		}

        public override bool ContainsMoreThen(float thld)
        {
            return (Volume >= thld);
        }

		/// <summary>
		/// Loads a calibration table in CSV format (column1 = height[mm], column2 = volume[l]).
		/// </summary>
		/// <param name="pathName">Path name of the CSV file</param>
		/// <returns>true when loaded successfully</returns>
		bool LoadCalibrationTable(string pathName)
		{
			try
			{
				IList<double> heights = new List<double>();
				IList<double> volumes = new List<double>();

				using (TextReader reader = new StreamReader(pathName))
				{
					while (true)
					{
						double h, v;

						string line = reader.ReadLine();
						if (line == null) break;

						string[] columns = line.Split(new char[] { ';' });
						if (columns.Length != 2 ||
							!double.TryParse(columns[0], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out h) ||
							!double.TryParse(columns[1], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out v))
						{
							break;
						}

						if (heights.Count > 0 && h <= heights[heights.Count - 1])
						{
							throw new Exception("Calibration file content error: height is not monotonically increasing");
						}

						heights.Add(h);
						volumes.Add(v);
					}
				}

				if ((heights.Count == 0) || (heights.Count != volumes.Count))
				{
					throw new Exception("No data in the calibration file");
				}

				calibHeight = new double[heights.Count];
				calibVolume = new double[heights.Count];
				for (int i = 0; i < heights.Count; i++)
				{
					calibHeight[i] = heights[i];
					calibVolume[i] = volumes[i];
				}

				log.WarnFormat("calibration table {0} was successfully loaded.", pathName);
				return true;
			}
			catch (Exception)
			{
				log.Warn("calibration table was NOT loaded.");
				return false;
			}
		}

		/// <summary>
		/// Converts water level to volume.
		/// Tank capcacity is used o distinguish bettween existing tanks:
		///   CEVAL small tank: Capacity = 2000 .. 2220
		///   CEVAL large tank: Capacity = 10000 .. 10850
		/// </summary>
		/// <param name="h">Height in mm</param>
		/// <returns>Volume in l</returns>
		double Level2Volume(double h)
		{
			if (useCalibTable)
			{
				return Level2VolumeTable(h);
			}
			else if (Capacity >= 2000 && Capacity <= 2220)
			{
				return Level2VolumeCevakSmall(h);
			}
			else if (Capacity >= 10000 && Capacity <= 10850)
			{
				return Level2VolumeCevakLarge(h);
			}
			else
			{
				return 0;
			}
		}

		/// <summary>
		/// Converts water level to volume using calibration table.
		/// </summary>
		/// <param name="h">Height in mm</param>
		/// <returns>Volume in l</returns>
		double Level2VolumeTable(double h)
		{
			if (h <= calibHeight[0]) return calibVolume[0];

			for (int i = 1; i < calibHeight.Length; i++)
			{
				if (h <= calibHeight[i])
				{
					double h1 = calibHeight[i - 1];
					double h2 = calibHeight[i];
					double v1 = calibVolume[i - 1];
					double v2 = calibVolume[i];

					return v1 + (v2 - v1) * (h - h1) / (h2 - h1);
				}
			}

			return calibVolume[calibHeight.Length - 1];
		}

		/// <summary>
		/// Converts water level to volume for 2000 liter water tank in CEVAK Ceske Budejovice.
		/// </summary>
		/// <param name="h">Height in mm</param>
		/// <returns>Volume in l</returns>
		double Level2VolumeCevakSmall(double h)
		{
			if (h < 150)
			{
				return 0;
			}
			else if (h < 1265.0)
			{
				return -302.70018 + 2.0099983 * h - 0.000034838627 * h * h + 1.8667691E-8 * h * h * h;
			}
			else
			{
				return 2220;
			}
		}

		/// <summary>
		/// Converts water level to volume for 10000 liter water tank in CEVAK Ceske Budejovice.
		/// </summary>
		/// <param name="h">Height in mm</param>
		/// <returns>Volume in l</returns>
		double Level2VolumeCevakLarge(double h)
		{
			double h1 = 150;
			double h2 = 890;
			double h3 = 1075;
			double h4 = 1320;
			double h5 = 1505;

			if (h <= h1)
			{
				return 0;
			}
			else if (/* h > h1 && */ h < h2)
			{
				double v1 = Level2VolumeCevakLarge(h1);
				double v2 = Level2VolumeCevakLarge(h2);
				return v1 + (v2 - v1) * (h - h1) / (h2 - h1);
			}
			else if (/* h >= h2 && */ h <= h3)
			{
				return -818.19344 + 5.8227917 * h + 0.00010646841 * h * h;
			}
			else if (/* h > h3 && */ h < h4)
			{
				double v3 = Level2VolumeCevakLarge(h3);
				double v4 = Level2VolumeCevakLarge(h4);
				return v3 + (v4 - v3) * (h - h3) / (h4 - h3);
			}
			else if (/* h >= h4 && */ h <= h5)
			{
				return 1002.1633 + 4.7686186 * h + 0.0011826136 * h * h;
			}
			else
			{
				return Level2VolumeCevakLarge(h5);
			}
		}


		/// <returns>Reference to the operation</returns>
		public IOperation ReadVolumeOp(ref DoubleBox volume)
		{
			if (currentOp != CurrentOp.None) throw new Exception("Sequence error");
            this.volumeBox = volume;
			readLevelOp = levelMeter.ReadLevelOp(ref levelBox);
			currentOp = CurrentOp.ReadVolume;
			return this;
		}

        /// <returns>Reference to the operation</returns>
        public IOperation ReadStableVolumeOp(ref DoubleBox volume, double sdev)
        {
            if (currentOp != CurrentOp.None) throw new Exception("Sequence error");
            this.volumeBox = volume;
            this.sdev = sdev;
            readLevelOp = levelMeter.ReadStableLevelOp(ref levelBox, sdev);
            currentOp = CurrentOp.ReadStableVolume;
            return this;
        }

        /// <returns>Reference to the operation</returns>
        public IOperation ManualReadVolumeOp(ref DoubleBox volume)
        {
            if (currentOp != CurrentOp.None) throw new Exception("Sequence error");
            this.volumeBox = volume;
            readLevelOp = manualLevelMeter.ReadLevelOp(ref levelBox);
            currentOp = CurrentOp.ManualReadVolume;
            return this;
        }

		public void Start()
		{
			readLevelOp.Start();
		}

		public Event Run()
		{
			if (readLevelOp.Run() == Event.LevelDone)
			{
				volumeBox.Val = Level2Volume(levelBox.Val);
				return Event.VolumeDone;
			}
			else
			{
				return Event.Busy;
			}
		}

		public void Stop()
		{
            currentOp = CurrentOp.None;
            readLevelOp.Stop();
		}
	}
}