///
/// Copyright (c) 2015-2020 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.IO;

namespace Results.Entities
{
	public class Batch
	{
        public virtual int Id { get; protected set; }
		public virtual int BatchNr { get; set; }
		public virtual int TestBenchId { get; set; }
        public virtual string TestBenchName { get; set; }	        /// CEVAK, not mapped to DB
        public virtual string Address1 { get; set; }	            /// CEVAK, not mapped to DB
        public virtual string Address2 { get; set; }	            /// CEVAK, not mapped to DB
        public virtual string Address3 { get; set; }	            /// CEVAK, not mapped to DB
        public virtual string Address4 { get; set; }	            /// CEVAK, not mapped to DB
        public virtual string Address5 { get; set; }	            /// CEVAK, not mapped to DB
        public virtual string ProgramVersion { get; set; }
		public virtual string UserName { get; set; }
		public virtual int UserNumber { get; set; }
		public virtual string ProcedureName { get; set; }
		public virtual string ProcedureDescription { get; set; }	/// CEVAK, not mapped to DB
		public virtual int ProcedureRevision { get; set; }
		public virtual string WatermetersStr { get; set; }			/// CEVAK, not mapped to DB
		public virtual string ProtocolTitle { get; set; }
        public virtual string Remark { get; set; }
        public virtual float DensityCorr { get; set; }				/// Density correction in [kg/m3]
		public virtual float Custom2 { get; set; }
		public virtual float Custom3 { get; set; }
        public virtual int Counter6 { get; set; }
        public virtual int Counter7 { get; set; }
        public virtual int Counter8 { get; set; }
        public virtual int Counter9 { get; set; }
        public virtual int Counter10 { get; set; }
        public virtual DateTime StartTime { get; set; }
		public virtual DateTime EndTime { get; set; }
        public virtual bool Dirty { get; set; }
        public virtual bool RsltsSent { get; set; }
		public virtual bool RsltsPrinted { get; set; }
		public virtual IList<TestData> Tests { get; set; }
		public virtual IList<WaterMeter> WaterMeters { get; set; }
		public virtual IList<TestRslt> TestRslts { get; set; }
		public virtual bool Compound { get; set; }					/// Not mapped to DB now
        public virtual bool HeatMeter { get; set; }					/// Not mapped to DB now                                                                   /// 

        public Batch()
		{
			Tests = new List<TestData>();
			WaterMeters = new List<WaterMeter>();
			TestRslts = new List<TestRslt>();

            TestBenchName = string.Empty;
            Address1 = string.Empty;
            Address2 = string.Empty;
            Address3 = string.Empty;
            Address4 = string.Empty;
            Address5 = string.Empty;
            ProgramVersion = string.Empty;
            UserName = string.Empty;
            ProcedureName = string.Empty;
            ProcedureDescription = string.Empty;
            WatermetersStr = string.Empty;
            ProtocolTitle = string.Empty;
            ProtocolTitle = string.Empty;
            Remark = string.Empty;
		}

        public virtual int PassedMetersCount()
        {
            int count = 0;
            foreach (var mtr in WaterMeters) if (mtr.PassedFromTests()) count++;
            return count;
        }

        public virtual int FailedMetersCount()
        {
            return WaterMeters.Count - PassedMetersCount();
        }

        public virtual double AmbTempMean()
		{
            double timeSum = 0;
            double sum = 0;

            foreach (var tr in TestRslts)
            {
                if (tr.TestDone)
                {
                    double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
                    timeSum += duration;
                    sum += (tr.AmbTempMean * duration);
                }
            }

            return (timeSum == 0) ? 0 : (sum / timeSum);
        }

        public virtual double AmbPressMean()
		{
            double timeSum = 0;
            double sum = 0;

            foreach (var tr in TestRslts)
            {
                if (tr.TestDone)
                {
                    double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
                    timeSum += duration;
                    sum += (tr.AmbPressMean * duration);
                }
            }

            return (timeSum == 0) ? 0 : (sum / timeSum);
        }

        public virtual double AmbHumiMean()
		{
            double timeSum = 0;
            double sum = 0;
            
            foreach (var tr in TestRslts)
            {
                if (tr.TestDone)
                {
                    double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
                    timeSum += duration;
                    sum += (tr.AmbHumiMean * duration);
                }
            }

            return (timeSum == 0) ? 0 : (sum / timeSum);
        }

        public virtual double AmbTempStart()
        {
            for (int i = 0; i < TestRslts.Count; i++)
            {
                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
                    return TestRslts[i].AmbTempStart;
            }
            return 0;
        }
        public virtual double AmbPressStart()
        {
            for (int i = 0; i < TestRslts.Count; i++)
            {
                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
                    return TestRslts[i].AmbPressStart;
            }
            return 0;
        }
        public virtual double AmbHumiStart()
        {
            for (int i = 0; i < TestRslts.Count; i++)
            {
                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
                    return TestRslts[i].AmbHumiStart;
            }
            return 0;
        }

        public virtual double AmbTempEnd()
        {
            for (int i = TestRslts.Count - 1; i >= 0; i++)
            {
                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
                    return TestRslts[i].AmbTempEnd;
            }
            return 0;
        }
        public virtual double AmbPressEnd()
        {
            for (int i = TestRslts.Count - 1; i >= 0; i++)
            {
                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
                    return TestRslts[i].AmbPressEnd;
            }
            return 0;
        }
        public virtual double AmbHumiEnd()
        {
            for (int i = TestRslts.Count - 1; i >= 0; i++)
            {
                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
                    return TestRslts[i].AmbHumiEnd;
            }
            return 0;
        }

        public virtual double Buoyancy()
        {
            double timeSum = 0;
            double sum = 0;

            foreach (var tr in TestRslts)
            {
                if (tr.TestData.Evaluate && tr.TestDone)
                {
                    double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
                    timeSum += duration;
                    sum += (tr.Buoyancy * duration);
                }
            }

            return (timeSum == 0) ? 0 : (sum / timeSum);
        }

		public virtual TestRslt GetTestRslt(string name, int part)
		{
			foreach (var tr in TestRslts)
			{
				if (part == tr.Part && name.Equals(tr.Name())) return tr;
			}
			return null;
		}

		public override string ToString()
		{
			return string.Format("Batch #{0}, Start:{1}, End:{2}, Procedure:{3}", BatchNr, StartTime, EndTime, ProcedureName);
		}

		public virtual string ToString(int i)
		{
			return string.Format("Batch: BatchNr={0} TestBenchId={1} ProgramVersion={2} UserName={3} UserNumber={4} ProcedureName={5} ProcedureRevision={6} ProtocolTitle={7} Remark={8} DensityCorr={9} Custom2={10} Custom3={11} StartTime={12} EndTime={13} Dirty={14} RsltsSent={15} RsltsPrinted={16}",
								BatchNr, TestBenchId, ProgramVersion, UserName, UserNumber,
								ProcedureName, ProcedureRevision, ProtocolTitle, Remark, DensityCorr,
								Custom2, Custom3, StartTime, EndTime, Dirty,
								RsltsSent, RsltsPrinted);
		}

        public virtual void WriteBinary(BinaryWriter writer)
        {
            writer.Write((ProgramVersion != null) ? ProgramVersion : string.Empty);
            writer.Write(Id);
            writer.Write(BatchNr);
            writer.Write(TestBenchId);
            writer.Write((TestBenchName != null) ? TestBenchName : string.Empty);
            writer.Write((Address1 != null) ? Address1 : string.Empty);
            writer.Write((Address2 != null) ? Address2 : string.Empty);
            writer.Write((Address3 != null) ? Address3 : string.Empty);
            writer.Write((Address4 != null) ? Address4 : string.Empty);
            writer.Write((Address5 != null) ? Address5 : string.Empty);
            writer.Write((UserName != null) ? UserName : string.Empty);
            writer.Write(UserNumber);
            writer.Write((ProcedureName != null) ? ProcedureName : string.Empty);
            writer.Write((ProcedureDescription != null) ? ProcedureDescription : string.Empty);
            writer.Write(ProcedureRevision);
            writer.Write((WatermetersStr != null) ? WatermetersStr : string.Empty);
            writer.Write((ProtocolTitle != null) ? ProtocolTitle : string.Empty);
            writer.Write((Remark != null) ? Remark : string.Empty);
            writer.Write(DensityCorr);
            writer.Write(Custom2);
            writer.Write(Custom3);
            writer.Write(Counter6);
            writer.Write(Counter7);
            writer.Write(Counter8);
            writer.Write(Counter9);
            writer.Write(Counter10);
            writer.Write(StartTime.ToString());
            writer.Write(EndTime.ToString());
            writer.Write(Dirty);
            writer.Write(RsltsSent);
            writer.Write(RsltsPrinted);
            writer.Write(Compound);
            writer.Write(HeatMeter);

            IList<TestData> savedTestDatas = new List<TestData>();  /// Initially empty
            writer.Write(TestRslts.Count);
            for (int i = 0; i < TestRslts.Count; i++)
            {
                TestRslts[i].WriteBinary(writer, savedTestDatas);
            }

            IList<WaterMeterData> savedWMDatas = new List<WaterMeterData>();  /// Initially empty
            writer.Write(WaterMeters.Count);
            for (int i = 0; i < WaterMeters.Count; i++)
            {
                WaterMeters[i].WriteBinary(writer, savedWMDatas);
            }
        }

        public virtual void ReadBinary(BinaryReader reader, string expectedProgramVersion)
        {
            ProgramVersion = reader.ReadString();
            if (expectedProgramVersion != null && ProgramVersion != expectedProgramVersion)
            {
                throw new Exception(string.Format("Process data were stored by TBF v.{0}", ProgramVersion));
            }
            Id = reader.ReadInt32();
            BatchNr = reader.ReadInt32();
            TestBenchId = reader.ReadInt32();
            TestBenchName = reader.ReadString();
            Address1 = reader.ReadString();
            Address2 = reader.ReadString();
            Address3 = reader.ReadString();
            Address4 = reader.ReadString();
            Address5 = reader.ReadString();
            UserName = reader.ReadString();
            UserNumber = reader.ReadInt32();
            ProcedureName = reader.ReadString();
            ProcedureDescription = reader.ReadString();
            ProcedureRevision = reader.ReadInt32();
            WatermetersStr = reader.ReadString();
            ProtocolTitle = reader.ReadString();
            Remark = reader.ReadString();
            DensityCorr = reader.ReadInt32();
            Custom2 = reader.ReadInt32();
            Custom3 = reader.ReadInt32();
            Counter6 = reader.ReadInt32();
            Counter7 = reader.ReadInt32();
            Counter8 = reader.ReadInt32();
            Counter9 = reader.ReadInt32();
            Counter10 = reader.ReadInt32();
            StartTime = DateTime.Parse(reader.ReadString());
            EndTime = DateTime.Parse(reader.ReadString());
            Dirty = reader.ReadBoolean();
            RsltsSent = reader.ReadBoolean();
            RsltsPrinted = reader.ReadBoolean();
            Compound = reader.ReadBoolean();
            HeatMeter = reader.ReadBoolean();

            Tests = new List<TestData>();       /// Initially empty

            int testRsltsCount = reader.ReadInt32();
            TestRslts = new List<TestRslt>();
            for (int i = 0; i < testRsltsCount; i++)
            {
                TestRslts.Add(new TestRslt());
                TestRslts[i].ReadBinary(reader, Tests);
                TestRslts[i].Batch = this;
            }

            IList<WaterMeterData> wmDatasRetirevedSoFar = new List<WaterMeterData>();    /// Initially empty

            int waterMetersCount = reader.ReadInt32();
            WaterMeters = new List<WaterMeter>();
            for (int i = 0; i < waterMetersCount; i++)
            {
                WaterMeters.Add(new WaterMeter());
                WaterMeters[i].ReadBinary(reader, wmDatasRetirevedSoFar, TestRslts);
                WaterMeters[i].Batch = this;
            }
         }
    }
}