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

namespace Results.Output
{
    public enum LogType
    {
        Just_Q3Q2Q1,            /// pNrs = -1,3,2,1
        Just_Q3Q2Q1_Alt,        /// pNrs = -1,5,2,1
        Just_Q3Q2adjQ1,         /// pNrs = -1,3,2,1
        Just_Q3Q2adjQ1_Alt,     /// pNrs = -1,5,2,1
        JustA0A4_Q3Q2adjQ1,     /// pNrs = -2,-1,3,2,1 (Australia 169 MHz, raw data pNrs: -2,-1,4,3,2,1)
        JustA0A4_Q3Q2Q1,        /// pNrs = -2,-1,3,2,1 (Australia 169 MHz smart, raw data pNrs: -2,-1,3,2,1)
        JustA0_Q3Q2Q1,          /// pNrs = -1,3,2,1    (Australia 169 MHz smart, raw data pNrs: -1,3,2,1)
        DEWA,           	    /// Q4, Q3, Q2adj, Q2, Q1
        DEWA_wo_Q2,             /// Q4, Q3, Q2adj, Q1
        Suez,           	    /// Two directions, with Q2 and Q2ac
        Suez_smart,             /// There is only Q2ac in both directions
        Suez_Repeatability,     /// 3xQ3, 3xQ2, 3xQ1 
        Suez_EMP_DN15,          /// EMP: 12 flow rates
        Suez_EMP_DN20,          /// EMP: 12 flow rates
        Suez_EMP_DN32,          /// EMP: 12 flow rates
        Suez_EMP_DN40,          /// EMP: 12 flow rates
        Greece,                 /// Q3, Q2adj, Q2, Q1
        S620,                   /// Q3, Q100, Q2, Q1
        S620_Alt,               /// Q3, Q100, Q2, Q1
        S620_Kiwa,
        Count,
        None,
    }

    public enum Range
    {
        Undefined,
        R90_100,
        R95_105,
        R100_110,
    }

    ///
    /// Information extracted from VT_PRUEFPUNKT_SOLL_SD for a given watermeter by query:
    ///    SELECT * FROM VT_PRUEFPUNKT_SOLL_SD WHERE ANBID=4 AND ID_WZTyp=x AND Rev_WZTyp=y
    ///
    public class SensusTestInfo
    {
        public string TestName;             /// Test name in TBF procedures
        public int PruefungsNrDB;           /// Identification of a flow
        public string QBezeichnungDB;       /// Flow name in Oracle database
        public int PruefungsNrOpto;         /// Identification of a flow - string form for log files
        public string QBezeichnungOpto;     /// Flow name in Oracle database
        public int PruefungsNrLog;          /// Identification of a flow
        public string QBezeichnungLog;      /// Flow name in Oracle database
        public Range Range;                 /// Range.R90_100 or Range.R100_110 (flow range in % of a target flow)

        public double Flow;
        public int TestTime;
        public double ErrLimLoFromDB;
        public double ErrLimHiFromDB;
        public double Uncertainty;
        public string TestMethod;

        public SensusTestInfo() { }

        public SensusTestInfo(string tstName, int pnDB, string qbDB, int pnOpto, string qbOpto, int pnLog, string qbLog, Range range)
        {
            TestName = tstName;
            PruefungsNrDB = pnDB;
            QBezeichnungDB = qbDB;
            PruefungsNrOpto = pnOpto;
            QBezeichnungOpto = qbOpto;
            PruefungsNrLog = pnLog;
            QBezeichnungLog = qbLog;
            Range = range;
            Flow = 0;
            TestTime = 0;
            ErrLimLoFromDB = 0;
            ErrLimHiFromDB = 0;
            Uncertainty = 0;
            TestMethod = string.Empty;
        }

        public SensusTestInfo(int pnDB, string qbDB, double flow, int testTime, double errLimLo, double errLimHi, Range range)
        {
            TestName = null;
            PruefungsNrDB = pnDB;
            QBezeichnungDB = qbDB;
            PruefungsNrOpto = 0;
            QBezeichnungOpto = null;
            PruefungsNrLog = 0;
            QBezeichnungLog = null;
            Range = range;
            Flow = flow;
            TestTime = testTime;
            ErrLimLoFromDB = errLimLo;
            ErrLimHiFromDB = errLimHi;
            Uncertainty = 0;
            TestMethod = string.Empty;
        }

        /// <summary>
        /// Determines whether test infos are compatible with procedure tests:
        ///   For each 'cti'in candidate SensusTestInfo array there must exist a string 'cti.TestName' in testNames.
        /// </summary>
        /// <returns>true when compatible</returns>
        public static bool AreCompatible(SensusTestInfo[] completeTestInfo, IList<string> testNames)
        {
            /// All TBF tests in the completeTestInfo must exist in the procedure         
            foreach (var cti in completeTestInfo)
            {
                bool testExists = false;
                foreach (var tn in testNames)
                {
                    if (cti.TestName == tn)
                    {
                        testExists = true;
                        break;
                    }
                }
                if (!testExists) return false;
            }

            return true;
        }


        /// <summary>
        /// Determines whether Oracle and complete test infos are compatible:
        ///   For each 'oti' in OracleTestInfo there must exist a compatible ...
        ///   ... cti.PruefungsNrDB + cti.QBezeichnungDB pair in candidate SensusTestInfo.
        /// </summary>
        /// <returns>true when compatible</returns>
        public static bool AreCompatible(IList<SensusTestInfo> oracleTestInfo, SensusTestInfo[] completeTestInfo)
        {
            if (oracleTestInfo == null) return false;

            /// All tests in oracleTestInfo must exist in completeTestInfo
            foreach (var oti in oracleTestInfo)
            {
                bool testExists = false;
                foreach (var cti in completeTestInfo)
                {
                    if ((cti.PruefungsNrDB == oti.PruefungsNrDB) && oti.QBezeichnungDB.Contains(cti.QBezeichnungDB))
                    {
                        testExists = true;
                        break;
                    }
                }
                if (!testExists) return false;
            }

            return true;
        }


        /// <summary>
        /// Get best matching TBF complete test infos (never null).
        /// </summary>
        /// <param name="oracleTestInfo">Raw test info from Oracle</param>
        /// <returns>Complete test info</returns>
        public static SensusTestInfo[] GetBestMatch(IList<SensusTestInfo> oracleTestInfo, IList<string> testNames)
        {
            string tInfoName;
            return GetBestMatch(oracleTestInfo, testNames, out tInfoName);
        }

        public static SensusTestInfo[] GetBestMatch(IList<SensusTestInfo> oracleTestInfo, IList<string> testNames, out string tInfoName)
        {
            LogType bestLT = LogType.None;
            SensusTestInfo[] bestMatch = null;
            int bestMatchLen = 0;
            tInfoName = string.Empty;

            ///
            /// Find the longest match that is compatible with TBF procedure _AND_ 'oracleTestInfo'.
            ///
            for (LogType lt = 0; lt < LogType.Count; lt++)
            {
                SensusTestInfo[] candidateTinfo = SensusTestInfo.GetTestInfos(lt);

                if (AreCompatible(candidateTinfo, testNames) && AreCompatible(oracleTestInfo, candidateTinfo) &&
                    ((bestMatch == null) || (candidateTinfo.Length < bestMatchLen)))
                {
                    bestLT = lt;
                    bestMatch = candidateTinfo;
                    bestMatchLen = candidateTinfo.Length;
                    tInfoName = lt.ToString();
                }
            }

            if (bestMatch == null)
            {
                ///
                /// No matching complete test info found so far => Find a match that is compatible with TBF procedure _ONLY_.
                ///
                for (LogType lt = 0; lt < LogType.Count; lt++)
                {
                    SensusTestInfo[] candidateTinfo = SensusTestInfo.GetTestInfos(lt);

                    if (AreCompatible(candidateTinfo, testNames) && ((bestMatch == null) || (candidateTinfo.Length < bestMatchLen)))
                    {
                        bestLT = lt;
                        bestMatch = candidateTinfo;
                        bestMatchLen = candidateTinfo.Length;
                        tInfoName = lt.ToString();
                    }
                }
            }

            if (bestLT != LogType.None)
            {
                return bestMatch;
            }
            else
            {
                tInfoName = LogType.Just_Q3Q2Q1.ToString();
                return GetTestInfos(LogType.Just_Q3Q2Q1);       /// Never return null
            }
        }


        /// <summary>
        /// Get on eof the pre-defined complete test infos.
        /// </summary>
        /// <param name="logType">Type</param>
        /// <returns>Complete test info</returns>
        public static SensusTestInfo[] GetTestInfos(LogType logType)
        {
            switch (logType)
            {
                default:
                case LogType.Just_Q3Q2Q1:           /// Standard R160, R250, R400
                    return new SensusTestInfo[]
                    {
                        ///                TBF            Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Adjustment",  -1, "Just",  -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Q3",           3,   "Q3",   3, "03",   3,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",           2,   "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",           1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.Just_Q3Q2Q1_Alt:       /// Alternative R160, R250, R400
                    return new SensusTestInfo[]
                    {
                        ///                TBF            Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Adjustment",  -1, "Just",  -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Q3",           5,   "Q3",   5, "05",   5,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",           2,   "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",           1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.Just_Q3Q2adjQ1:        /// Standard R800
                    return new SensusTestInfo[]
                    {
                        ///                TBF            Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Q2adj",        0,     "",   2, "02",   0,     "", Range.R100_110),
                        new SensusTestInfo("Adjustment",  -1, "Just",  -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Q3",           3,   "Q3",   3, "03",   3,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",           2,   "Q2",   0,   "",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",           1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.Just_Q3Q2adjQ1_Alt:    /// Alternative R800
                    return new SensusTestInfo[]
                    {
                        ///                TBF            Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Q2adj",        0,     "",   2, "02",   0,     "", Range.R100_110),
                        new SensusTestInfo("Adjustment",  -1, "Just",  -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Q3",           5,   "Q3",   5, "05",   5,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",           2,   "Q2",   0,   "",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",           1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.JustA0A4_Q3Q2adjQ1:    /// Australia 169 MHz
                    return new SensusTestInfo[]
                    {
                        ///                TBF            Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Q2adj",        0,     "",   3, "03",   3,"Q2adj", Range.R100_110),
                        new SensusTestInfo("Qjust_A0",    -1, "Just",  -1, "-1",  -1,  "Q-1", Range.R95_105),
                        new SensusTestInfo("Qjust_A4",    -2, "Just",  -2, "-2",  -2,  "Q-2", Range.R95_105),
                        new SensusTestInfo("Q3",           3,   "Q3",   4, "04",   4,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",           2,   "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",           1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.JustA0A4_Q3Q2Q1:    /// Australia 169 MHz with default Q2 corrections and conditional update at the end of cycle
                    return new SensusTestInfo[]
                    {
                        ///                TBF            Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Qjust_A0",    -1, "Just",  -1, "-1",  -1,  "Q-1", Range.R95_105),
                        new SensusTestInfo("Qjust_A4",    -2, "Just",  -2, "-2",  -2,  "Q-2", Range.R95_105),
                        new SensusTestInfo("Q3",           3,   "Q3",   3, "03",   3,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",           2,   "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",           1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.JustA0_Q3Q2Q1:      /// Australia 169 MHz with default Q2 corrections and conditional update at the end of cycle
                    return new SensusTestInfo[]
                    {
                        ///                TBF            Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Qjust_A0",    -1, "Just",  -1, "-1",  -1,  "Q-1", Range.R95_105),
                        new SensusTestInfo("Q3",           3,   "Q3",   3, "03",   3,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",           2,   "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",           1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };
                
                case LogType.DEWA:                  /// DEWA (with Q4 and Q2 after correction)
                    return new SensusTestInfo[]
                    {
                        ///                TBF           Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Adjustment", -1, "Just",  -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Q4",          5,   "Q4",   5, "05",   5,   "Q4", Range.R90_100),
                        new SensusTestInfo("Q3",          4,   "Q3",   4, "04",   4,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2adj",       3,   "Q2",   3, "03",   3,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q2",          2,   "Q2",   2, "02",   2, "Q2ac", Range.R100_110),
                        new SensusTestInfo("Q1",          1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.DEWA_wo_Q2:            /// DEWA (with Q4, without Q2 after correction)
                    return new SensusTestInfo[]
                    {
                        ///                TBF           Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Adjustment", -1, "Just",  -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Q4",          5,   "Q4",   5, "05",   5,   "Q4", Range.R90_100),
                        new SensusTestInfo("Q3",          4,   "Q3",   4, "04",   4,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2adj",       0,     "",   2, "02",   0,     "", Range.R100_110),
                        new SensusTestInfo("Q2est",       2,   "Q2",   0,   "",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",          1,   "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.Suez:
                    return new SensusTestInfo[]     /// SUEZ (2 directions)
                    {
                        ///                TBF         Oracle DB   Opto RAW   LU logfiles 
                        new SensusTestInfo("Qjust_A0", -1, "Just", -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Qjust_A4", -2, "Just", -2, "-2",  -2, "Just", Range.R95_105),
                        new SensusTestInfo("Q3_rl",    10,   "Q3", 10, "10",  10,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2_rl",     8,   "Q2",  8, "08",   8,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q2ac_rl",   7, "Q2ac",  7, "07",   7, "Q2ac", Range.R100_110),
                        new SensusTestInfo("Q1_rl",     6,   "Q1",  6, "06",   6,   "Q1", Range.R100_110),
                        new SensusTestInfo("Q3_lr",     5,   "Q3",  5, "05",   5,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2_lr",     3,   "Q2",  3, "03",   3,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q2ac_lr",   2, "Q2ac",  2, "02",   2, "Q2ac", Range.R100_110),
                        new SensusTestInfo("Q1_lr",     1,   "Q1",  1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.Suez_smart:
                    return new SensusTestInfo[]     /// SUEZ (2 directions)
                    {
                        ///                TBF         Oracle DB   Opto RAW   LU logfiles 
                        new SensusTestInfo("Qjust_A0", -1, "Just", -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Qjust_A4", -2, "Just", -2, "-2",  -2, "Just", Range.R95_105),
                        new SensusTestInfo("Q3_rl",    10,   "Q3", 10, "10",  10,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2ac_rl",   7, "Q2ac",  7, "07",   7, "Q2ac", Range.R100_110),
                        new SensusTestInfo("Q1_rl",     6,   "Q1",  6, "06",   6,   "Q1", Range.R100_110),
                        new SensusTestInfo("Q3_lr",     5,   "Q3",  5, "05",   5,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2ac_lr",   2, "Q2ac",  2, "02",   2, "Q2ac", Range.R100_110),
                        new SensusTestInfo("Q1_lr",     1,   "Q1",  1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.Suez_Repeatability:
                    return new SensusTestInfo[]
                    {
                        ///                TBF             Oracle DB   Opto RAW   LU logfiles 
                        new SensusTestInfo("Q3_lr (1/3)",   5, "Q3",    9, "09",  9, "Q3 1/3",   Range.R90_100),
                        new SensusTestInfo("Q3_lr (2/3)",   5, "Q3",    8, "08",  8, "Q3 2/3",   Range.R90_100),
                        new SensusTestInfo("Q3_lr (3/3)",   5, "Q3",    7, "07",  7, "Q3 3/3",   Range.R90_100),
                        new SensusTestInfo("Q2ac_lr (1/3)", 2, "Q2ac",  6, "06",  6, "Q2ac 1/3", Range.R100_110),
                        new SensusTestInfo("Q2ac_lr (2/3)", 2, "Q2ac",  5, "05",  5, "Q2ac 2/3", Range.R100_110),
                        new SensusTestInfo("Q2ac_lr (3/3)", 2, "Q2ac",  4, "04",  4, "Q2ac 3/3", Range.R100_110),
                        new SensusTestInfo("Q1_lr (1/3)",   1, "Q1",    3, "03",  3, "Q1 1/3",   Range.R100_110),
                        new SensusTestInfo("Q1_lr (2/3)",   1, "Q1",    2, "02",  2, "Q1 2/3",   Range.R100_110),
                        new SensusTestInfo("Q1_lr (3/3)",   1, "Q1",    1, "01",  1, "Q1 3/3",   Range.R100_110),
                    };

                case LogType.Suez_EMP_DN15:
                    return new SensusTestInfo[]
                    {
                        ///                TBF        Oracle DB   Opto RAW   LU logfiles 
                        new SensusTestInfo("Q4",       0, "",     12, "12",  12, "Q4",      Range.R90_100),
                        new SensusTestInfo("Q3_lr",    5, "Q3",   11, "11",  11, "Q3",      Range.R90_100),
                        new SensusTestInfo("Q1.35",    0, "",     10, "10",  10, "Q1.35",   Range.R95_105),
                        new SensusTestInfo("Q0.7",     0, "",      9, "09",   9, "Q0.7",    Range.R95_105),
                        new SensusTestInfo("Q0.28",    0, "",      8, "08",   8, "Q0.28",   Range.R95_105),
                        new SensusTestInfo("Q0.15",    0, "",      7, "07",   7, "Q0.15",   Range.R95_105),
                        new SensusTestInfo("Q0.08",    0, "",      6, "06",   6, "Q0.08",   Range.R95_105),
                        new SensusTestInfo("Q0.04",    0, "",      5, "05",   5, "Q0.04",   Range.R95_105),
                        new SensusTestInfo("Q0.0236",  0, "",      4, "04",   4, "Q0.0236", Range.R95_105),
                        new SensusTestInfo("Q0.010",   0, "",      3, "03",   3, "Q0.010",  Range.R95_105),
                        new SensusTestInfo("Q2ac_lr",  2, "Q2ac",  2, "02",   2, "Q2",      Range.R100_110),
                        new SensusTestInfo("Q1_lr",    1, "Q1",    1, "01",   1, "Q1",      Range.R100_110),
                    };

                case LogType.Suez_EMP_DN20:
                    return new SensusTestInfo[]
                    {
                        ///                TBF        Oracle DB   Opto RAW   LU logfiles
                        new SensusTestInfo("Q4",       0, "",     12, "12",  12, "Q4",      Range.R90_100),
                        new SensusTestInfo("Q3_lr",    5, "Q3",   11, "11",  11, "Q3",      Range.R90_100),
                        new SensusTestInfo("Q2.16",    0, "",     10, "10",  10, "Q2.16",   Range.R95_105),
                        new SensusTestInfo("Q1.35",    0, "",      9, "09",   9, "Q1.35",   Range.R95_105),
                        new SensusTestInfo("Q0.7",     0, "",      8, "08",   8, "Q0.7",    Range.R95_105),
                        new SensusTestInfo("Q0.28",    0, "",      7, "07",   7, "Q0.28",   Range.R95_105),
                        new SensusTestInfo("Q0.15",    0, "",      6, "06",   6, "Q0.15",   Range.R95_105),
                        new SensusTestInfo("Q0.08",    0, "",      5, "05",   5, "Q0.08",   Range.R95_105),
                        new SensusTestInfo("Q0.04",    0, "",      4, "04",   4, "Q0.04",   Range.R95_105),
                        new SensusTestInfo("Q0.02",    0, "",      3, "03",   3, "Q0.02",   Range.R95_105),
                        new SensusTestInfo("Q2ac_lr",  2, "Q2ac",  2, "02",   2, "Q2",      Range.R100_110),
                        new SensusTestInfo("Q1_lr",    1, "Q1",    1, "01",   1, "Q1",      Range.R100_110),
                    };

                case LogType.Suez_EMP_DN32:
                    return new SensusTestInfo[]
                    {
                        ///                TBF       Oracle DB   Opto RAW   LU logfiles
                        new SensusTestInfo("Q4",      0, "",     12, "12",  12, "Q4",    Range.R90_100),
                        new SensusTestInfo("Q3_lr",   5, "Q3",   11, "11",  11, "Q3",    Range.R90_100),
                        new SensusTestInfo("Q5",      0, "",     10, "10",  10, "Q5",    Range.R95_105),
                        new SensusTestInfo("Q2.5",    0, "",      9, "09",   9, "Q2.5",  Range.R95_105),
                        new SensusTestInfo("Q1.35",   0, "",      8, "08",   8, "Q1.35", Range.R95_105),
                        new SensusTestInfo("Q0.65",   0, "",      7, "07",   7, "Q0.65", Range.R95_105),
                        new SensusTestInfo("Q0.35",   0, "",      6, "06",   6, "Q0.35", Range.R95_105),
                        new SensusTestInfo("Q0.16",   0, "",      5, "05",   5, "Q0.16", Range.R95_105),
                        new SensusTestInfo("Q0.09",   0, "",      4, "04",   4, "Q0.09", Range.R95_105),
                        new SensusTestInfo("Q0.04",   0, "",      3, "03",   3, "Q0.04", Range.R95_105),
                        new SensusTestInfo("Q2ac_lr", 2, "Q2ac",  2, "02",   2, "Q2",    Range.R100_110),
                        new SensusTestInfo("Q1_lr",   1, "Q1",    1, "01",   1, "Q1",    Range.R100_110),
                    };

                case LogType.Suez_EMP_DN40:
                    return new SensusTestInfo[]
                    {
                        ///                TBF       Oracle DB   Opto RAW   LU logfiles
                        new SensusTestInfo("Q4",      0, "",     12, "12",  12, "Q4",     Range.R90_100),
                        new SensusTestInfo("Q3_lr",   5, "Q3",   11, "11",  11, "Q3",     Range.R90_100),
                        new SensusTestInfo("Q8",      0, "",     10, "10",  10, "Q8",     Range.R95_105),
                        new SensusTestInfo("Q5",      0, "",      9, "09",   9, "Q5",     Range.R95_105),
                        new SensusTestInfo("Q2.5",    0, "",      8, "08",   8, "Q2.5",   Range.R95_105),
                        new SensusTestInfo("Q1.35",   0, "",      7, "07",   7, "Q1.35",  Range.R95_105),
                        new SensusTestInfo("Q0.65",   0, "",      6, "06",   6, "Q0.65",  Range.R95_105),
                        new SensusTestInfo("Q0.35",   0, "",      5, "05",   5, "Q0.35",  Range.R95_105),
                        new SensusTestInfo("Q0.16",   0, "",      4, "04",   4, "Q0.16",  Range.R95_105),
                        new SensusTestInfo("Q0.09",   0, "",      3, "03",   3, "Q0.09",  Range.R95_105),
                        new SensusTestInfo("Q2ac_lr", 2, "Q2ac",  2, "02",   2, "Q2",     Range.R100_110),
                        new SensusTestInfo("Q1_lr",   1, "Q1",    1, "01",   1, "Q1",     Range.R100_110),
                    };

                case LogType.Greece:                  /// Q2adj (before correction) and Q2 (after correction) measured
                    return new SensusTestInfo[]
                    {
                        ///                TBF           Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Adjustment", -1,  "Just",  -1, "-1",  -1, "Just", Range.R95_105),
                        new SensusTestInfo("Q3",          4,    "Q3",   4, "04",   4,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2adj",       3, "Q2adj",   3, "03",   3,"Q2adj", Range.R100_110),
                        new SensusTestInfo("Q2",          2,    "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",          1,    "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.S620:
                    return new SensusTestInfo[]
                    {
                        ///                TBF           Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Q3",          3,    "Q3",   3, "03",   3,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",          2,    "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",          1,    "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.S620_Alt:
                    return new SensusTestInfo[]
                    {
                        ///                TBF           Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Q3",          5,    "Q3",   5, "05",   5,   "Q3", Range.R90_100),
                        new SensusTestInfo("Q2",          2,    "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",          1,    "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };

                case LogType.S620_Kiwa:
                    return new SensusTestInfo[]
                    {
                        ///                TBF           Oracle DB    Opto RAW   LU logfiles 
                        new SensusTestInfo("Q4",          5,    "Q4",   5, "05",   5,   "Q4", Range.R90_100),
                        new SensusTestInfo("Q2",          2,    "Q2",   2, "02",   2,   "Q2", Range.R100_110),
                        new SensusTestInfo("Q1",          1,    "Q1",   1, "01",   1,   "Q1", Range.R100_110),
                    };
            }
        }


        /// <summary>
        /// Generate a array of SensusTestInfo objects representing the procedure.
        /// Multiple parts of the same test (with the same name) generate only one SensusTestInfo object.
        /// </summary>
        /// <param name="procedure">Procedure entity</param>
        /// <returns>Array of SensusTestInfo objects</returns>
        public static SensusTestInfo[] CreateFromProcedure(Config.Entities.Procedure procedure)
        {
            ///
            /// Count the number of different tests.
            /// Multiple parts of the same test (same name) are counted only once.
            /// 
            IList<string> listOfHydroTests = new List<string>();
            foreach (var test in procedure.Tests)
            {
                if (TestShouldBeIncluded(test))
                {
                    for (int repNr = 1; repNr <= test.Repeats; repNr++)
                    {
                        string fullTestNameWoPart = (test.Repeats == 1) ? test.Name : string.Format("{0} ({1}/{2})", test.Name, repNr, test.Repeats);
                        if (!listOfHydroTests.Contains(fullTestNameWoPart))
                        {
                            listOfHydroTests.Add(fullTestNameWoPart);
                        }
                    }
                }
            }

            SensusTestInfo[] stiArray = new SensusTestInfo[listOfHydroTests.Count];
            int ix = 0;
            int luID = listOfHydroTests.Count;
            listOfHydroTests.Clear();

            foreach (var test in procedure.Tests)
            {
                if (TestShouldBeIncluded(test))
                {
                    for (int repNr = 1; repNr <= test.Repeats; repNr++)
                    {
                        string fullTestNameWoPart = (test.Repeats == 1) ? test.Name : string.Format("{0} ({1}/{2})", test.Name, repNr, test.Repeats);
                        if (!listOfHydroTests.Contains(fullTestNameWoPart))
                        {
                            listOfHydroTests.Add(fullTestNameWoPart);
                            stiArray[ix++] = CreateFromTest(test, repNr, luID--, fullTestNameWoPart);
                        }
                    }
                }
            }

            return stiArray;
        }
        /// 
        static bool TestShouldBeIncluded(Config.Entities.Test test)
        {
            return test.DoEvaluate && test.IsRegular() && !test.Method.ToLower().Contains("iperlcommunication");
        }
        /// 
        public static SensusTestInfo CreateFromTest(Config.Entities.Test test, int repetitionNr, int luID, string fullTestNameWoPart)
        {
            bool isQ4Q3 = test.Name.ToLower().Contains("q4") ||
                          test.Name.ToLower().Contains("q3") ||
                          test.Name.ToLower().Contains("qmax") ||
                          test.Name.ToLower().Contains("qn");

            bool isQ2Q1 = test.Name.ToLower().Contains("q2") ||
                          test.Name.ToLower().Contains("q1") ||
                          test.Name.ToLower().Contains("qt") ||
                          test.Name.ToLower().Contains("qmin");

            /// Range.R90_100 or Range.R100_110 (flow range in % of a target flow)
            Range range = isQ4Q3 ? Range.R90_100 : (isQ2Q1 ? Range.R100_110 : Range.R95_105);
            
            return new SensusTestInfo()
            {
                TestName = fullTestNameWoPart,                              /// Test name in TBF procedures
                PruefungsNrDB = luID,                                       /// Identification of a flow
                QBezeichnungDB = fullTestNameWoPart,                        /// Flow name in Oracle database
                PruefungsNrOpto = luID,                                     /// Identification of a flow - string form for log files
                QBezeichnungOpto = luID.ToString("D02"),                    /// Flow name in Oracle database
                PruefungsNrLog = luID,                                      /// Identification of a flow
                QBezeichnungLog = fullTestNameWoPart,                       /// Flow name in Oracle database
                Range = range,
                Flow = (range == Range.R100_110) ? test.Qfrom : (range == Range.R90_100) ? test.Qto : (test.Qfrom + test.Qto) / 2,
                TestTime = (int)Math.Round(test.TestTime),
                ErrLimLoFromDB = test.ErrLimLo,
                ErrLimHiFromDB = test.ErrLimHi,
                Uncertainty = test.Uncertainty,
                TestMethod = test.Method,
            };
        }


        public override string ToString()
        {
            return string.Format("{0} DB={1}/'{2}' Opto={3}/'{4}' Log={5}/'{6}'/{7}", TestName, PruefungsNrDB, QBezeichnungDB, PruefungsNrOpto, QBezeichnungOpto, PruefungsNrLog, QBezeichnungLog, Range);
        }

        public void WriteBinary(BinaryWriter writer)
        {
            writer.Write((TestName != null) ? TestName : string.Empty);
            writer.Write(PruefungsNrDB);
            writer.Write((QBezeichnungDB != null) ? QBezeichnungDB : string.Empty);
            writer.Write(PruefungsNrOpto);
            writer.Write((QBezeichnungOpto != null) ? QBezeichnungOpto : string.Empty);
            writer.Write(PruefungsNrLog);
            writer.Write((QBezeichnungLog != null) ? QBezeichnungLog : string.Empty);
            writer.Write((int)Range);
            writer.Write(Flow);
            writer.Write(TestTime);
            writer.Write(ErrLimLoFromDB);
            writer.Write(ErrLimHiFromDB);
            writer.Write(Uncertainty);
            writer.Write((TestMethod != null) ? TestMethod : string.Empty);
        }

        public void ReadBinary(BinaryReader reader)
        {
            TestName = reader.ReadString();
            PruefungsNrDB = reader.ReadInt32();
            QBezeichnungDB = reader.ReadString();
            PruefungsNrOpto = reader.ReadInt32();
            QBezeichnungOpto = reader.ReadString();
            PruefungsNrLog = reader.ReadInt32();
            QBezeichnungLog = reader.ReadString();
            Range = (Range)reader.ReadInt32();
            Flow = reader.ReadDouble();
            TestTime = reader.ReadInt32();
            ErrLimLoFromDB = reader.ReadDouble();
            ErrLimHiFromDB = reader.ReadDouble();
            Uncertainty = reader.ReadDouble();
            TestMethod = reader.ReadString();
        }
    }
}