namespace Xylem.Common.Service.MeterProcessState.Controllers
{
    using LaaPackages.SqlClient;
    using System;
    using System.Collections.Generic;
    using System.Configuration;
    using System.Linq;
    using System.Net;
    using System.Text;
    using System.Web.Http;

    using Xylem.Common.Logic.ProductionOrderCore.TestResults;
    using Xylem.Common.Logic.ServiceCore;

    [RoutePrefix("api/TestBench")]
    public class TestBenchController : ApiController
    {
        public static class GlobalConfig
        {
            public static Lazy<String> connectionString = new Lazy<String>(() => ConfigurationManager.ConnectionStrings["default"].ConnectionString);
        }

        public static readonly Lazy<String> ConnectionString = new Lazy<String>(() => ConfigurationManager.ConnectionStrings["default"].ConnectionString);

        /// <summary>
        /// SetMeterLogPathInfo
        /// </summary>
        /// <param name="SerialNumber">PcbID from Meter</param>
        /// <param name="TestRunId"> </param>
        /// <param name="CalibrationRunId"> </param>
        /// <param name="BasePath"> </param>
        /// <param name="MainLogName"> </param>
        /// <param name="LEDName"> </param>
        /// <returns></returns>
        [Route("SetMeterLogPathInfo"), HttpGet]
        public IHttpActionResult SetMeterLogPathInfo(Int32 SerialNumber, Int32? TestRunId = null, Int32? CalibrationRunId = null, String BasePath = "", String MainLogName = "", String LEDName = "")
        {
            var rowsAffected = SqlConnection
                .CreateSqlConnection(ConnectionString.Value)
                .CreateCommand($@"
                    INSERT 
                      INTO [CordonelLogFiles]
                         ( [SerialNumber]
                         , [TestRunId]
                         , [CalibrationRunId]
                         , [BasePath]
                         , [MainLog]
                         , [LED])
                    VALUES (@{nameof(SerialNumber)}
                         ,  @{nameof(TestRunId)}
                         ,  @{nameof(CalibrationRunId)}
                         ,  @{nameof(BasePath)}
                         ,  @{nameof(MainLogName)}
                         ,  @{nameof(LEDName)})")
                .SetParameter(nameof(SerialNumber), SerialNumber)
                .SetParameter(nameof(TestRunId), TestRunId)
                .SetParameter(nameof(CalibrationRunId), CalibrationRunId)
                .SetParameter(nameof(BasePath), BasePath)
                .SetParameter(nameof(MainLogName), MainLogName)
                .SetParameter(nameof(LEDName), LEDName)
                .ExecuteNonQuery();

            if (rowsAffected == 1)
            {
                return this.Ok();
            }

            return this.BadRequest("Invalid data.");
        }

        [Route("SetCalibrationValues"), HttpPost]
        public IHttpActionResult SetCalibrationValues([FromBody] JustageResults val)
        {
            var rowsAffected = SqlConnection
                .CreateSqlConnection(ConnectionString.Value)
                .CreateCommand($@"

        INSERT INTO[dbo].[Cordonel_Q3Calibration]
                   ([PcbId]
                   ,[P1Offset]
                   ,[P1Cal]
                   ,[P2Offset]
                   ,[P2Cal]
                   ,[P3Offset]
                   ,[P3Cal]
                   ,[Date])
                    VALUES (@{nameof(JustageResults.pcbId)}
                         ,  @{nameof(JustageResults.p1Target)}
                        ,  @{nameof(JustageResults.p1Value)}
                        ,  @{nameof(JustageResults.p2Target)}
                        ,  @{nameof(JustageResults.p2Value)}
                        ,  @{nameof(JustageResults.p3Target)}
                         ,  @{nameof(JustageResults.p3Value)}
                        ,  @{nameof(JustageResults.dt)})")
                .SetParameter(nameof(JustageResults.pcbId), int.Parse(val.pcbId))
                .SetParameter(nameof(JustageResults.p1Target), val.p1Target)
                .SetParameter(nameof(JustageResults.p1Value), ((Int32)val.p1Value))
                .SetParameter(nameof(JustageResults.p2Target), val.p2Target)
                .SetParameter(nameof(JustageResults.p2Value), ((Int32)val.p2Value))
                .SetParameter(nameof(JustageResults.p3Target), val.p3Target)
                .SetParameter(nameof(JustageResults.p3Value), ((Int32)val.p3Value))
                .SetParameter(nameof(JustageResults.dt), val.dt)
                .ExecuteNonQuery();

            if (rowsAffected == 1)
            {
                return this.Ok();
            }

            return this.BadRequest("Invalid data.");
        }
        /// <summary>
        /// Get SerialNumber from PcbID
        /// </summary>
        /// <param name="PcbID">PcbID from Meter</param>
        /// <returns></returns>
        [Route("GetMeterInfoForTestBench"), HttpGet]
        public IHttpActionResult GetMeterInfoForTestBench(String PcbID)
        {
            var results = SqlConnection
                .CreateSqlConnection(ConnectionString.Value)
                .CreateCommand($@"
                    SELECT DISTINCT 
	                       [MapPcbIdToSerialNumber_SerialNumber]						AS [SerialNr]
	                     , [MapOrder].[CordonelAssignedPicking_FertigungsAuftragsNr]	AS [FertigungsNr] 
	                     , [Meter].[Adresse]											AS [RadioAddress] 
	                     , [KundeneigeneSerienNr]										AS [CustomerSerialNr] 
                         , (SELECT TOP 1 [ID] 
		                      FROM [CordonelMeterCalibrationResults] 
		                     WHERE [PcbId] = @{nameof(PcbID)} 
		                     ORDER BY [Date] DESC)										AS [CalibrationRunID] 
                         , (SELECT TOP 1 [StatusFertigung] 
		                      FROM [AuftragPositionSerienNr] 
		                     WHERE [SerienNr] = [MapPcbIdToSerialNumber_SerialNumber] 
		                     ORDER BY [AnlageDatum] DESC)								AS [LastProcessState] 
	                     , [Nennweite]													AS [Dn] 
                         , (SELECT TOP 1 [Dn_InternalId] 
	                          FROM [CordonelMeterSizes] 
		                     WHERE [Dn_VakoID] = SUBSTRING([Identnr].[VakoCode], 4, 2))	AS [NewNennweiteID] 
                         , [lut].[FileCrc]												AS [LutCrc] 
                        , fw.Version													as FWVersion
                      FROM [Cordonel_AssignedPicking]									AS [MapOrder]
                      LEFT OUTER JOIN [MapPcbIdToSerialNumber]							AS [map]  
                        ON [MapOrder].[CordonelAssignedPicking_PcbId]					 = [map].[MapPcbIdToSerialNumber_PcbId] 
                       AND [map].[MapPcbIdToSerialNumber_Deleted]						 = 0 
                      LEFT OUTER JOIN [AuftragPositionSerienNr]							AS [mapSrn] 
	                    ON [map].[MapPcbIdToSerialNumber_SerialNumber]					 = [mapSrn].[SerienNr] 
                       AND [mapSrn].[Pruefgangnr]										 = 0 
                      LEFT OUTER JOIN [AuftragPosition_gesamt]							AS [auftraginfo] 
                        ON [auftraginfo].[AuftragNr]									 = [mapSrn].[AuftragNr] 
                       AND [auftraginfo].[PositionNr]									 = [mapSrn].[PositionNr] 
                      LEFT OUTER JOIN [Genesis_Meter]									AS [Meter] 
	                    ON [Meter].[Seriennummer]										 = [map].[MapPcbIdToSerialNumber_SerialNumber] 
                      LEFT OUTER JOIN [Identnr] 
                        ON [auftraginfo].[Identnr]										 = [Identnr].[IdentNr]  
                      LEFT OUTER JOIN [Cordonel_Lut]									AS [lut] 
	                    ON [lut].[MeterSize]											 = (SELECT TOP 1 [Dn_InternalId] 
																		                      FROM [CordonelMeterSizes] 
																		                     WHERE [Dn_VakoID] = SUBSTRING([Identnr].[VakoCode], 4, 2)) 
																		                       AND [lut].[CurrentVersionForProd] = 1 
					left outer join Cordonel_CurrentFw AS fw
					 ON [fw].Metersize 												= (SELECT TOP 1 [Dn_InternalId] 
																		                      FROM [CordonelMeterSizes] 
																		                     WHERE [Dn_VakoID] = SUBSTRING([Identnr].[VakoCode], 4, 2)) 
																		                       AND [fw].CurrentForProd = 1 

                     WHERE [MapOrder].[CordonelAssignedPicking_IsDeleted]                = 0 
                       AND [MapOrder].[CordonelAssignedPicking_PcbId]                    = @{nameof(PcbID)} ")
                .SetParameter(nameof(PcbID), PcbID)
                .ExecuteReader(x => new string[]
                {
                    $"{x.GetValue<Int32>(0)}",              // SerialNr,
                    $"{x.GetValue<Int32>(1)}",              // FertigungsNr,
                    $"{x.GetValue<Int64>(2)}",              // RadioAddress, 
                    $"{x.GetValue<String>(3)}",             // CustomerSerialNr,
                    $"{x.GetValue<Int32?>(4)}",             // CalibrationRunID, 
                    $"{x.GetValue<Byte>(5)}",               // LastProcessState,
                    $"{x.GetValue<Int32>(6)}",              // Dn,
                    $"{x.GetValue<Int32>(7)}",              // NewNennweiteID,
                    $"{x.GetValue<Int32?>(8)}",             // LutCrc
                    $"{x.GetValue<Int32?>(9)}",             // Fwversion
                });

            if (results.Count() == 1)
            {
                return this.Ok(results.FirstOrDefault());
            }

            return this.Content(HttpStatusCode.BadRequest, new string[] { string.Empty, string.Empty, string.Empty });
        }

        [HttpGet]
        [Route("GetOffsetCalibration/{pcbId}")]
        public IHttpActionResult GetOffsetCalibration(int pcbId)
        {
            var offset = SqlConnection
                .CreateSqlConnection(ConnectionString.Value)
                .CreateCommand($@"
                    SELECT [PcbId]
                         , [TestRunNr]
                         , [Offset]
                      FROM [Cordonel_Calibrations]
                     WHERE [PcbId] = @{nameof(pcbId)}")
                .SetParameter(nameof(pcbId), pcbId)
                .FirstOrDefault(x => new CordonelCalibration
                {
                    PcbId = x.GetValue<Int32>(0),
                    TestRunNr = x.GetValue<Int32>(1),
                    Offset = x.GetValue<Double>(2)
                });

            return this.Ok();
        }

        [HttpPost]
        public IHttpActionResult AddOffsetCalibration([FromBody] CordonelCalibration model)
        {
            var rowsAffected = SqlConnection
                .CreateSqlConnection(ConnectionString.Value)
                .CreateCommand($@"
                    INSERT 
                      INTO [Cordonel_Calibrations]
                         ( [PcbId]
                         , [TestRunNr]
                         , [Offset])
                    VALUES (@{nameof(CordonelCalibration.PcbId)}
                         ,  @{nameof(CordonelCalibration.TestRunNr)}
                         ,  @{nameof(CordonelCalibration.Offset)})")
                .SetParameter(nameof(CordonelCalibration.PcbId), model.PcbId)
                .SetParameter(nameof(CordonelCalibration.TestRunNr), model.TestRunNr)
                .SetParameter(nameof(CordonelCalibration.Offset), model.Offset)
                .ExecuteNonQuery();

            if (rowsAffected == 1)
            {
                return this.Ok();
            }

            return this.BadRequest("Invalid data.");
        }

        [HttpPost]
        public IHttpActionResult SetOffsetCalibration([FromBody] CordonelCalibration model)
        {
            var rowsAffected = SqlConnection
                .CreateSqlConnection(ConnectionString.Value)
                .CreateCommand($@"
                    UPDATE [Cordonel_Calibrations]
                       SET [TestRunNr]	= @{nameof(CordonelCalibration.TestRunNr)}
                         , [Offset]		= @{nameof(CordonelCalibration.Offset)}
                     WHERE [PcbId]		= @{nameof(CordonelCalibration.PcbId)}")
                .SetParameter(nameof(CordonelCalibration.TestRunNr), model.TestRunNr)
                .SetParameter(nameof(CordonelCalibration.Offset), model.Offset)
                .SetParameter(nameof(CordonelCalibration.PcbId), model.PcbId)
                .ExecuteNonQuery();

            if (rowsAffected == 1)
            {
                return this.Ok();
            }

            return this.BadRequest("Invalid data.");
        }



        [Route("GetTestResults"), HttpGet]
        public IHttpActionResult GetTestResults(int SerialNr, int TestRunNr)
        {
            using (var dataacces = new SqlDataAccess(GlobalConfig.connectionString.Value))
            {
                var sb = new StringBuilder();
                sb.AppendLine($@"
                    Select 
                    p.PruefgangNr,
                    p.PruefstationNr,
                    p.Datum,
                    p.Typ	,
                    p.Nennweite	,
                    p.Nenntemperatur	,
                    p.Lufttemperatur	,
                    p.LuftDruck,
                    p.RelativeFeuchte,
                    p.Vorlauftemperatur,
                    p.Anzahl, ");



                for (int i = 1; i < 10; i++)
                {
                    sb.AppendLine($"p.PP{i}_Zeit,");

                    sb.AppendLine($"p.PP{i}_Soll         ,  ");
                    sb.AppendLine($"p.PP{i}_Ist          ,  ");
                    sb.AppendLine($"p.PP{i}_RefZSerienNr ,  ");
                    sb.AppendLine($"p.PP{i}_RefFehl      ,  ");
                    sb.AppendLine($"p.PP{i}_Ist_V        ,  ");
                    sb.AppendLine($"p.PP{i}_Waage        ,  ");
                    sb.AppendLine($"p.PP{i}_Info         ,  ");


                    sb.AppendLine($"f.PP{i}_Fehler as  PP{i}DisplayError,");



                    sb.AppendLine($"f1.PP{i}_Fehler as  PP{i}Chnl_1_Error,");
                    sb.AppendLine($"f1.PP{i}_TimeS as  PP{i}Chnl_1_TimeS,");
                    sb.AppendLine($"f1.PP{i}_VolumeQm as  PP{i}Chnl_1_VolumeQm, ");



                    sb.AppendLine($"f2.PP{i}_Fehler as  PP{i}Chnl_2_Error,");
                    sb.AppendLine($"f2.PP{i}_TimeS as  PP{i}Chnl_2_TimeS,");
                    sb.AppendLine($"f2.PP{i}_VolumeQm as  PP{i}Chnl_2_VolumeQm, ");


                    sb.AppendLine($"f3.PP{i}_Fehler as  PP{i}Chnl_3_Error,");
                    sb.AppendLine($"f3.PP{i}_TimeS as  PP{i}Chnl_3_TimeS,");
                    sb.AppendLine($"f3.PP{i}_VolumeQm as  PP{i}Chnl_3_VolumeQm, ");
                }

                sb.AppendLine($@"
                   p.Bemerkung
                from Pruefgang p
                inner
                join Prueffehler f on f.PruefgangNr = p.PruefgangNr and f.SerienNr = {SerialNr}
                inner join PrueffehlerGenesisPfade f1 on f1.PruefgangNr = p.PruefgangNr and f1.SerienNr = {SerialNr} and f1.Pfad = 1
                inner join PrueffehlerGenesisPfade f2 on f2.PruefgangNr = p.PruefgangNr and f2.SerienNr = {SerialNr} and f2.Pfad = 2
                inner join PrueffehlerGenesisPfade f3 on f3.PruefgangNr = p.PruefgangNr and f3.SerienNr = {SerialNr} and f3.Pfad = 3
                where p.PruefgangNr = {TestRunNr}");

                var dt = dataacces.ExecuteQuery(sb.ToString());


                if (dt.Rows.Count != 1)
                {
                    return this.Content(HttpStatusCode.BadRequest, new string[] { });
                }
                var tr = new TestResults();
                tr.Serialnr = SerialNr;
                tr.TestRunNr = TestRunNr;


                //Convert.ToInt32(
                var dr = dt.Rows[0];
                tr.TestBenchNr = Convert.ToInt32(dr["PruefstationNr"]);
                tr.Date = Convert.ToDateTime(dr["Datum"]);
                tr.MeterType = dt.Rows[0]["Typ"].ToString();
                tr.MeterSize = Convert.ToInt32(dr["Nennweite"]);
                tr.AirTempC = Convert.ToDouble(dr["Lufttemperatur"]);
                tr.AirPressure = Convert.ToDouble(dr["LuftDruck"]);
                tr.AirHumanity = Convert.ToDouble(dr["RelativeFeuchte"]);
                tr.WaterTempC = Convert.ToDouble(dr["Vorlauftemperatur"]);
                tr.TotalMeters = Convert.ToInt32(dr["Anzahl"]);
                tr.Remark = dr["Bemerkung"].ToString();

                tr.Details = new List<TestPointDetail>();
                tr.TestPointsChannels = new List<ChnlTestPoint>();
                tr.TestPointsMain = new List<TestPoint>();
                for (int i = 1; i < 10; i++)
                {
                    try
                    {
                        var d = new TestPointDetail();

                        if (dr[$"PP{i}_Soll"] is DBNull)
                        {
                            continue;
                        }
                        d.TimeS = Convert.ToDouble(dr[$"PP{i}_Zeit"]);
                        d.FlowTargetQmh = Convert.ToDouble(dr[$"PP{i}_Soll"]);
                        d.FlowrateQmh = Convert.ToDouble(dr[$"PP{i}_Ist"]);
                        d.VolumeQm = Convert.ToDouble(dr[$"PP{i}_Ist_V"]);
                        d.Info = dr[$"PP{i}_Info"].ToString();
                        d.Scale = Convert.ToBoolean(dr[$"PP{i}_Waage"]);

                        tr.Details.Add(d);
                        var m = new TestPoint();
                        m.TestPointNr = i;

                        m.Error = Convert.ToDouble(dr[$"PP{i}DisplayError"]);
                        tr.TestPointsMain.Add(m);

                        for (int z = 1; z < 3; z++)
                        {
                            var c = new ChnlTestPoint();
                            c.TestPointNr = i;
                            c.ChanlNr = z;
                            c.Error = Convert.ToDouble(dr[$"PP{i}Chnl_{z}_Error"]);
                            c.TimeS = Convert.ToDouble(dr[$"PP{i}Chnl_{z}_TimeS"]);
                            c.VolumenQm = Convert.ToDouble(dr[$"PP{i}Chnl_{z}_VolumeQm"]);
                            tr.TestPointsChannels.Add(c);
                        }
                    }
                    catch (Exception ex)
                    {

                    }



                }

                return this.Content(HttpStatusCode.OK, tr);
            }
        }

        public class CordonelCalibration
        {
            public int PcbId { get; set; }

            public int TestRunNr { get; set; }

            public double Offset { get; set; }
        }
    }
}