using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Results.Entities;

namespace Results
{
	public class BatchResults
	{
		public readonly int WMPositionsCount;

		public IList<Entities.TestData> TestDataList;
		public IList<Entities.Components> ComponentsList;
		public IList<Entities.WaterMeterData> WaterMeterDataList;

		private BatchResults(int wmPositionsCount)
		{
			WMPositionsCount = wmPositionsCount;

			TestDataList = new List<Entities.TestData>();
			ComponentsList = new List<Entities.Components>();
			WaterMeterDataList = new List<Entities.WaterMeterData>();
		}


		public Batch Batch;
		public WaterMeter[] WaterMeters;

		public static BatchResults NewFromProcedure(int batchNr, int benchId, string benchName, string a1, string a2, string a3, string a4, string a5,
                                                    string user, int userNr, string programVer, Config.Entities.Procedure procedure,
													WaterMeterData[] waterMeterDatas, int[] waterMeterParts, double densityCorr)
		{
			BatchResults d = new BatchResults(waterMeterDatas.Length);
            int year = DateTime.Now.Year;

			/// Create new batch
			d.Batch = new Batch()
				{
                    BatchNr = batchNr,
                    TestBenchId = benchId,
                    TestBenchName = benchName,
					Address1 = a1,
					Address2 = a2,
					Address3 = a3,
					Address4 = a4,
					Address5 = a5,
					ProgramVersion = programVer,
					UserName = user,
					UserNumber = userNr,
					ProcedureName = procedure.Name,
					ProcedureDescription = procedure.Description,
					WatermetersStr = procedure.Watermeters,
					ProcedureRevision = procedure.Revision,
					ProtocolTitle = string.Empty,
					StartTime = DateTime.Now,
					DensityCorr = (float)densityCorr,
					Compound = (procedure.MetersKind == Config.Entities.MetersKind.Combined),
#if HEAT_METERS
                    HeatMeter = (procedure.MetersKind == Config.Entities.MetersKind.HeatMeter),
#endif
                };

			///
			/// Add watermeter to an array, array index is WM position.
			/// AddWaterMetersToBatch() has to be used before saving results.
			///
			d.WaterMeters = new WaterMeter[d.WMPositionsCount];
			for (int i = 0; i < d.WMPositionsCount; i++)
			{
				if (waterMeterDatas[i] == null) continue;
				WaterMeterData wmd = WaterMeterData.UpdateList(d.WaterMeterDataList, waterMeterDatas[i]);
                d.WaterMeters[i] = new WaterMeter()
                    {
                        Batch = d.Batch,
                        WaterMeterData = wmd,
                        WMPosition = i + 1,
                        YearOfProduction = year,
                    };
			}


			foreach (var t in procedure.Tests)
			{
				if (t.Publish != (byte)Config.Entities.Publish.Never)
				{
					TestData td = TestData.UpdateList(d.TestDataList, new TestData(t));

					for (int rnr = 1; rnr <= t.Repeats; rnr++)
					{
						/// Create an empty test result and add it to the list
						TestRslt tr = new TestRslt(d.Batch, td, t.Part, rnr);
						d.Batch.TestRslts.Add(tr);

						for (int i = 0; i < d.WMPositionsCount; i++)
						{
							if (d.WaterMeters[i] == null) continue;

							if (!t.IsPartCompatible(waterMeterParts[i])) continue;

							///
							/// Create empty watermeter test results and add them to the list and to dictionaries
							///
							IList<MeterTestRslt> wmtrs = d.WaterMeters[i].MeterTestRslts;
							if (d.Batch.Compound)
							{
								/// Compound water meter
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.CompoundMain));
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.CompoundAux));
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.Compound));
							}
							else if (d.Batch.HeatMeter)
							{
								/// Heat meter
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.HeatMeterVolume));
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.HeatMeterEnergy));
							}
							else
							{
								/// Water meter
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.Single));
							}
						}
					}
				}
			}

			return d;
		}

        public static BatchResults FromBatch(Batch batch)
        {
            if (batch.WaterMeters == null || batch.WaterMeters.Count == 0) return null;

            int wmPosMax = 0;
            foreach (var wm in batch.WaterMeters) if (wm.WMPosition > wmPosMax) wmPosMax = wm.WMPosition;

            BatchResults batchResults = new BatchResults(wmPosMax);
            batchResults.Batch = batch;
            batchResults.WaterMeters = new WaterMeter[wmPosMax];
            for (int i = 0; i < batch.WaterMeters.Count; i++)
            {
                WaterMeter wm = batch.WaterMeters[i];
                batchResults.WaterMeters[wm.WMPosition - 1] = wm;
            }

            return batchResults;
        }

        public TestRslt GetTestRslt(string name, int part)
		{
			return Batch.GetTestRslt(name, part);
		}

		public MeterTestRslt GetMeterTestRslt(string name, int wmnr0, Config.Entities.CompoundMeterId meterId)
		{
			if (WaterMeters[wmnr0] != null)
			{
				return WaterMeters[wmnr0].GetMeterTestRslt(name, meterId);
			}
			return null;
		}


		/// <summary>
		/// Returns true when all tests were done
		/// </summary>
		/// <returns>true = all tests done</returns>
		public bool AllTestsDone()
		{
			for (int i = 0; i < WMPositionsCount; i++)
			{
                if ((WaterMeters[i] != null) && !WaterMeters[i].Disabled)
				{
					foreach (var mtr in WaterMeters[i].MeterTestRslts)
					{
                        if (!mtr.TestDone) return false;
					}
				}
			}
			return true;
		}


		/// <summary>
		/// Adds non-null water meters from an array to a Batch water meters list.
		/// This method should be used when results are prepared and
		/// all disabled water meters are deleted.
		/// </summary>
		public void AddWaterMetersToBatch()
		{
			for (int i = 0; i < WMPositionsCount; i++)
			{
				if (WaterMeters[i] != null)
                {
                    WaterMeters[i].Passed = WaterMeters[i].PassedFromTests();
					if (!WaterMeters[i].Disabled)
					{
						Batch.WaterMeters.Add(WaterMeters[i]);
					}
                }
			}
		}


        public bool IsProduction()
        {
            for (int i = 0; i < WMPositionsCount; i++)
            {
                if (WaterMeters[i] != null)
                {
                    foreach (var mtr in WaterMeters[i].MeterTestRslts)
                    {
                        if (mtr.TestData().Name.ToLower().Contains("adj") || mtr.TestData().Name.ToLower().Contains("just"))
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
	}
}