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 user, int userNr, string programVer,
													Config.Entities.Procedure procedure,
													WaterMeterData[] waterMeterDatas, int[] waterMeterParts)
		{
			BatchResults d = new BatchResults(waterMeterDatas.Length);

			/// Create new batch
			d.Batch = new Batch()
				{
					TestBenchId = benchId,
					BatchNr = batchNr,
					ProgramVersion = programVer,
					UserName = user,
					UserNumber = userNr,
					ProcedureName = procedure.Name,
					ProcedureDescription = procedure.Description,
					WatermetersStr = procedure.Watermeters,
					ProcedureRevision = procedure.Revision,
					ProtocolTitle = procedure.ProtocolTitle,
					StartTime = DateTime.Now,
					Compound = (procedure.MetersKind == Config.Entities.MetersKind.Combined),
				};

			///
			/// 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 };
			}


			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.Part != 0 && waterMeterParts[i] != 0 && t.Part != waterMeterParts[i]) continue;

							/// Create empty watermeter test results and add them to the list and to dictionaries
							if (!d.Batch.Compound)
							{
								MeterTestRslt mtr = new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.Single);
								d.WaterMeters[i].MeterTestRslts.Add(mtr);
							}
							else
							{
								MeterTestRslt mainMTR = new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.CompoundMain);
								d.WaterMeters[i].MeterTestRslts.Add(mainMTR);

								MeterTestRslt auxMTR = new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.CompoundAux);
								d.WaterMeters[i].MeterTestRslts.Add(auxMTR);

								MeterTestRslt cmpdMTR = new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.Compound);
								d.WaterMeters[i].MeterTestRslts.Add(cmpdMTR);
							}
						}
					}
				}
			}

			return d;
		}


		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)
				{
					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]);
					}
                }
			}
		}
	}
}