///
/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using Common;

namespace Config.Entities
{
    /// <summary>
    /// Stores one test procedure, supports revisions and history log
    /// </summary>
    public class Procedure : IHasName, IHasItemNr
    {
        public virtual int Id { get; protected set; }
		public virtual int ItemNr { get; set; }
		public virtual string Name { get; set; }

        public virtual string Description { get; set; }			/// Short description
		public virtual string CreationUser { get; set; }		/// Name of the user who has created or changed this procedure
		public virtual DateTime CreationTime { get; set; }		/// Date and time of the creation or change
		public virtual string LastChgUser { get; set; }			/// Name of the user who has created or changed this procedure
		public virtual DateTime LastChgTime { get; set; }		/// Date and time of the creation or change
		public virtual string LongDescription { get; set; }		/// Long description (notes)

		public virtual ProcedureState ProcedureState { get; set; }
		public virtual int Revision { get; set; }
		public virtual int PredecessorId { get; set; }
		public virtual bool ObtainedByCopy { get; set; }		/// Initial version of this procedure was a copy of another procedure
        /// 
		public virtual MetersKind MetersKind { get; set; }		/// single / compound / heat meters
		public virtual string Watermeters { get; set; }			/// Water meter name or Id
        public virtual bool Protected { get; set; }             /// true = procedure cannot be changed by a testing specialist
		public virtual bool MustBeComplete { get; set; }        /// true = procedure can be finished just when all tests were finished
		public virtual bool ManualCtrlDisabled { get; set; }	/// true = manual control of valves, etc. is disabled

		public virtual string DataEntry { get; set; }			/// Component to use for data entry
		public virtual string ResultsPrinter { get; set; }		/// Component for printing results
		public virtual string ResultsWriter { get; set; }		/// Component for saving results into a file
        public virtual string EventTriggers { get; set; }       /// Component for analysing results and triggering events
        public virtual string TransitionStart { get; set; }
		public virtual string TransitionEnd { get; set; }

        public virtual string AltProcName { get; set; }		    /// Alternative procedure name (null or string.Empty = no alt. procedure)
        public virtual int AltProcPeriod { get; set; }			/// Period of alternative procedures (0 = no alt. procedure)

        public virtual float DN { get; set; }                   /// Not mapped to DB, valid in ProceduresCtrl for procedure filtering only
        public virtual float Qn { get; set; }                   ///   - ' ' -
        public virtual string MClass { get; set; }              ///   - ' ' -
        public virtual string Producer { get; set; }            ///   - ' ' -

		public virtual IList<ComponentProcedure> MoreParams { get; set; }
		public virtual IList<Test> Tests { get; set; }

        TestInstance[] testInstances;

        /// Wrapper
        public virtual IList<Test> RegularTests()
        {
            IList<Test> rslt = new List<Test>();
            foreach (var t in Tests) if (t.IsRegular()) rslt.Add(t);
            return rslt;
        }

        /// ------------- Additional stuff not mapped into the database -------------

        public Procedure()
        {
			MoreParams = new List<ComponentProcedure>();
			Tests = new List<Test>();
            testInstances = null;

			///
			/// Default values
			/// 
			CreationUser = Users.CurrentUser.UserName();
			CreationTime = DateTime.Now;
			LastChgUser = CreationUser;
			LastChgTime = CreationTime;
			MetersKind = MetersKind.Single;
			Watermeters = string.Empty;
			Description = string.Empty;
			LongDescription = string.Empty;

            DN = 0;
            Qn = 0;
            MClass = string.Empty;
            Producer = string.Empty;
        }

		public Procedure(string name, int itemNr)
			: this()
		{
			Name = name;
			ItemNr = itemNr;
		}

        public virtual TestInstance[] UpdateTestInstances(IList<string> loopStartNames, IList<string> loopEndNames, IList<string> autoTests = null)
        {
            List<TestInstance> instances = new List<TestInstance>();

            if (Tests != null)
            {
                int i = 0;
                while (i < Tests.Count)
                {
                    if (!loopStartNames.Contains(Tests[i].Method) && !loopEndNames.Contains(Tests[i].Method))   /// Loop.End is ignored outside a loop
                    {
                        ///
                        /// Outside a loop
                        ///
                        for (int j = 1; j <= Tests[i].Repeats; j++)
                            if (Tests[i].BelongsTo(autoTests))
                                instances.Add(new TestInstance(Tests[i], j));
                    }
                    else if (loopStartNames.Contains(Tests[i].Method))
                    {
                        ///
                        /// Entering a loop
                        ///
                        int loopsCount = Tests[i].Repeats;
                        List<Test> testsInsideLoop = new List<Test>();
                        i++;

                        while (i < Tests.Count && !loopEndNames.Contains(Tests[i].Method))
                        {
                            ///
                            /// Inside a loop
                            ///
                            if (Tests[i].Repeats == loopsCount && !loopStartNames.Contains(Tests[i].Method))    /// Loop.Start is ignored inside a loop
                            {
                                if (Tests[i].BelongsTo(autoTests))
                                    testsInsideLoop.Add(Tests[i]);
                            }

                            i++;
                        }

                        ///
                        /// Append instances of tests inside the last loop to the list
                        ///
                        for (int j = 1; j <= loopsCount; j++)
                        {
                            foreach (var t in testsInsideLoop)
                                instances.Add(new TestInstance(t, j));
                        }
                    }

                    i++;
                }
            }

            testInstances = instances.ToArray();
            return testInstances;
        }

        public virtual TestInstance[] GetTestInstances()
        {
            return testInstances;
        }

        public virtual Procedure Clone()
        {
            Procedure result = new Procedure();

			result.ItemNr = ItemNr;
			result.Name = Name;
			result.Description = Description;
			result.CreationUser = CreationUser;
			result.CreationTime = CreationTime;
			result.LastChgUser = LastChgUser;
			result.LastChgTime = LastChgTime;
			result.LongDescription = LongDescription;
			result.ProcedureState = ProcedureState;
			result.Revision = Revision;
			result.PredecessorId = Id;
			result.ObtainedByCopy = ObtainedByCopy;
			result.MetersKind = MetersKind;
			result.Watermeters = Watermeters;
            result.Protected = Protected;
            result.MustBeComplete = MustBeComplete;
			result.ManualCtrlDisabled = ManualCtrlDisabled;
			result.DataEntry = DataEntry;
			result.ResultsPrinter = ResultsPrinter;
			result.ResultsWriter = ResultsWriter;
            result.EventTriggers = EventTriggers;
            result.TransitionStart = TransitionStart;
			result.TransitionEnd = TransitionEnd;
            result.AltProcName = AltProcName;
            result.AltProcPeriod = AltProcPeriod;

            result.DN = DN;
            result.Qn = Qn;
            result.MClass = MClass;
            result.Producer = Producer;

			foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone(result)); }
			foreach (var test in Tests) { result.Tests.Add(test.Clone()); }

            return result;
        }

        public virtual void Export(StreamWriter output)
        {
			output.WriteLine(ItemNr.ToString(CultureInfo.InvariantCulture));
            output.WriteLine(Name);
            output.WriteLine(Description);
            output.WriteLine(CreationUser);
			output.WriteLine(CreationTime.ToString(CultureInfo.InvariantCulture));
            output.WriteLine(LastChgUser);
			output.WriteLine(LastChgTime.ToString(CultureInfo.InvariantCulture));
			output.WriteLine(MetersKind.ToString());
            output.WriteLine(Watermeters);
            output.WriteLine(Protected.ToString());
            output.WriteLine(MustBeComplete.ToString());
			output.WriteLine(ManualCtrlDisabled.ToString());
            output.WriteLine(DataEntry);
            output.WriteLine(ResultsPrinter);
            output.WriteLine(ResultsWriter);
            output.WriteLine(EventTriggers);
            output.WriteLine(TransitionStart); 
            output.WriteLine(TransitionEnd);

            foreach (var prms in MoreParams) { prms.Export(output); }
            output.WriteLine();

            foreach (var test in Tests) { test.Export(output); }
            output.WriteLine();

            output.Close();
        }

        public static Procedure Import(StreamReader input)
        {
            Procedure result = new Procedure();

			result.ItemNr = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
            result.Name = input.ReadLine();
            result.Description = input.ReadLine();
            result.CreationUser = input.ReadLine();
			result.CreationTime = DateTime.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
            result.LastChgUser = input.ReadLine();
			result.LastChgTime = DateTime.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
            string line = input.ReadLine();
            result.MetersKind = line.Equals(MetersKind.Single.ToString()) ? MetersKind.Single : (line.Equals(MetersKind.Combined.ToString()) ? MetersKind.Combined : MetersKind.HeatMeter);
            result.Watermeters = input.ReadLine();
            result.Protected = bool.Parse(input.ReadLine());
            result.MustBeComplete = bool.Parse(input.ReadLine());
			result.ManualCtrlDisabled = bool.Parse(input.ReadLine());
            result.DataEntry = input.ReadLine();
            result.ResultsPrinter = input.ReadLine();
            result.ResultsWriter = input.ReadLine();
            result.EventTriggers = input.ReadLine();
            result.TransitionStart = input.ReadLine();
            result.TransitionEnd = input.ReadLine();

            while(true)
            {
                ComponentProcedure prms = ComponentProcedure.Import(input, result);
                if (prms == null)
                    break;
                else
                    result.MoreParams.Add(prms);
            }

            while (true)
            {
                Test tst = Test.Import(input, result);
                if (tst == null)
                    break;
                else
                    result.Tests.Add(tst);
            }

            return result;
        }

        public virtual string Compare(StreamReader inp)
        {
            System.Text.StringBuilder diff = new System.Text.StringBuilder();
            const string fmt = "{0} = {1}\r\n (in the file {2})\r\n";
            string ln;

            ln = inp.ReadLine();            /// skip ItemNr
            ln = inp.ReadLine(); if (ln != Name)                          { diff.AppendFormat(fmt, "Name", Name, ln); };
            ln = inp.ReadLine(); if (ln != Description)                   { diff.AppendFormat(fmt, "Description", Description, ln); };
            ln = inp.ReadLine();            /// skip CreationUser
            ln = inp.ReadLine();            /// skip CreationTime
            ln = inp.ReadLine();            /// skip LastChgUser
            ln = inp.ReadLine();            /// skip LastChgTime
            ln = inp.ReadLine(); if (ln != MetersKind.ToString())         { diff.AppendFormat(fmt, "MetersKind", MetersKind, ln); };
            ln = inp.ReadLine(); if (ln != Watermeters)                   { diff.AppendFormat(fmt, "Watermeters", Watermeters, ln); };

            ln = inp.ReadLine(); if (ln != Protected.ToString())          { diff.AppendFormat(fmt, "Protected", Protected, ln); };
            ln = inp.ReadLine(); if (ln != MustBeComplete.ToString())     { diff.AppendFormat(fmt, "MustBeComplete", MustBeComplete, ln); };
            ln = inp.ReadLine(); if (ln != ManualCtrlDisabled.ToString()) { diff.AppendFormat(fmt, "ManualCtrlDisabled", ManualCtrlDisabled, ln); };
            ln = inp.ReadLine(); if (ln != DataEntry)                     { diff.AppendFormat(fmt, "DataEntry", DataEntry, ln); };
            ln = inp.ReadLine(); if (ln != ResultsPrinter)                { diff.AppendFormat(fmt, "ResultsPrinter", ResultsPrinter, ln); };
            ln = inp.ReadLine(); if (ln != ResultsWriter)                 { diff.AppendFormat(fmt, "ResultsWriter", ResultsWriter, ln); };
            ln = inp.ReadLine(); if (ln != EventTriggers)                 { diff.AppendFormat(fmt, "EventTriggers", EventTriggers, ln); };
            ln = inp.ReadLine(); if (ln != TransitionStart)               { diff.AppendFormat(fmt, "TransitionStart", TransitionStart, ln); };
            ln = inp.ReadLine(); if (ln != TransitionEnd)                 { diff.AppendFormat(fmt, "TransitionEnd", TransitionEnd, ln); };

            /// TODO Compare componentprocedure-s
            while (ComponentProcedure.Import(inp, null) != null)
            {
            }


            //foreach (var test in Tests)
            //{
            //    string testDiff = test.Compare(inp);
            //    if (testDiff.Contains(
            //}

            //bool extraTestsInFile = true;
            //while (Test.Import(inp, null) != null) { extraTestsInFile = true; }

            return diff.ToString();
        }

        public virtual ComponentProcedure GetProcedureParamsEntity(string cmpntName)
        {
            foreach (var procPrms in MoreParams)
            {
                if (procPrms.CmpntName == cmpntName) return procPrms;
            }
            return null;
        }


        /// <summary>
        /// Processes the selection done by the bench control panel in the main sequence.
        /// </summary>
        /// <param name="selection">Selection.Q1, .Q2, .Q3 or .Test</param>
        /// <returns>The selected test or null</returns>
        public virtual Test GetTest(string expandedTestName, out int testIx, out int repetNr)
        {
            for (int ix = 0; ix < Tests.Count; ix++)
            {
                Test test = Tests[ix];
                if (test.Name.Equals(expandedTestName))
                {
                    /// Name is not expanded => Repeats==1
                    testIx = ix;
                    repetNr = 1;
                    return test;
                }

                for (int r = 1; r <= test.Repeats; r++)
                {
                    if (test.GetExpandedTestName(r).Equals(expandedTestName))
                    {
                        testIx = ix;
                        repetNr = r;
                        return test;
                    }
                }
            }

            testIx = 0;
            repetNr = 1;
            return null;
        }


		public override string ToString()
		{
			return string.Format("{0}, rev.{1}", Name, Revision);
		}
    }
}