namespace LaaProductionWeb.Services
{
    using LaaProductionWeb.Data.Interfaces;
    using LaaProductionWeb.Services.Interfaces;
    using LaaProductionWeb.Services.Models;
    using LaaProductionWeb.Services.Models.Reports;

    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;

    public class ProtocolService : IProtocolService
    {
        private readonly ISqlClient sqlClient;

        public ProtocolService(ISqlClient sqlClient) 
            => this.sqlClient = sqlClient;

        public bool DeleteFile(int fileId)
            => this.sqlClient.ExecuteScalar<int>($@"
                    DELETE FROM [File] 
                     WHERE [FileId] = @{nameof(fileId)};
                    DELETE FROM [FilesOrders] 
                    OUTPUT [Deleted].[FileId]
                     WHERE [FileId] = @{nameof(fileId)};",
                parameters: parameters => parameters.Add(nameof(fileId), fileId)) > 0;

        public string FileContent(int? fileId)
        {
            var fileContent = this.sqlClient.FirstOrDefault(
                query: $@"
                    SELECT [dbo].[File].[FileContent]
                      FROM [dbo].[File]
                     WHERE [dbo].[File].[FileId] = @{nameof(fileId)}",
                parameters: parameters => parameters.Add(nameof(fileId), fileId),
                reader: reader => reader.GetBytes(0)) ?? Array.Empty<byte>();

            return string.Format("data:application/pdf;base64,{0}", Convert.ToBase64String(fileContent));
        }

        public OrderClientModel FindOrder(int orderId)
        {
            var orderClientModel = this.sqlClient.FirstOrDefault(
                query: $@"
                    SELECT DISTINCT
 	                       [APG].[AuftragNr]
 	                     , [K].[KundenNr]
 	                     , [K].[Name]
	                     , ISNULL((SELECT CAST([Positions].[PositionNr] AS VARCHAR) + ', '
				                     FROM (SELECT DISTINCT TOP 1000 [PositionNr] 
						                     FROM [AuftragPositionSerienNr]	
						                    WHERE [AuftragNr] = [APG].[AuftragNr]
						                    ORDER BY [PositionNr])		AS [Positions]
				                      FOR XML PATH('')), '')			AS [Positions]		
                       FROM [AuftragPosition_Gesamt]					AS [APG]
                       JOIN [Auftrag_Gesamt]							AS [AG]
                         ON [AG].[AuftragNr]							 = [APG].[AuftragNr]
                       JOIN [IdentNr]									AS [IN]
                         ON [IN].[IdentNr]								 = [APG].[Identnr]
                        AND [IN].[Typ]									 = 'GNS'
                       JOIN [Kunde]										AS [K]
                         ON [K].[KundenNr]								 = [AG].[KundenNr]
                      WHERE [APG].[AuftragNr]							 = @{nameof(orderId)}",
                parameters: parameters => parameters.Add(nameof(orderId), orderId),
                reader: reader => new OrderClientModel
                {
                    OrderId = reader.GetValue<int>(0),
                    ClientId = reader.GetValue<int>(1),
                    ClientName = reader.GetString(2),
                    Positions = reader.GetString(3).Trim().Trim(',')
                });

            if (orderClientModel != null && orderId > 0)
            {
                orderClientModel.FileId = this.sqlClient.FirstOrDefault($@"
                        SELECT [FileId]
                          FROM [FilesOrders]
                         WHERE [OrderId]    = @{nameof(orderId)}
                           AND [Usage]      = 'PROTOCOL'",
                    parameters: parameters => parameters.Add(nameof(orderId), orderId),
                    reader: reader => reader.GetValue<int>(0));
            }

            return orderClientModel ?? new OrderClientModel();
        }

        public IEnumerable<KeyValuePair<int, string>> FindOrdersById(int orderno)
            => this.sqlClient.ExecuteReader($@"
                    SELECT DISTINCT
	                       [APG].[AuftragNr]
	                     , [K].[Name]
                      FROM [AuftragPosition_Gesamt]	AS [APG]
                      JOIN [Auftrag_Gesamt]			AS [AG]
                        ON [AG].[AuftragNr]			 = [APG].[AuftragNr]
                      JOIN [IdentNr]				AS [IN]
                        ON [IN].[IdentNr]			 = [APG].[Identnr]
                       AND [IN].[Typ]				 = 'GNS'
                      JOIN [Kunde]					AS [K]
                        ON [K].[KundenNr]			 = [AG].[KundenNr]
                     WHERE [APG].[AuftragNr]	  LIKE @{nameof(orderno)}",
                parameters: parameters => parameters.Add(nameof(orderno), $"%{orderno}%"),
                reader: reader => new KeyValuePair<int, string>(
                    key: reader.GetValue<int>(0),
                    value: reader.GetString(1)));

        public IEnumerable<KeyValuePair<int, string>> FindOrdersByClient(string clientName)
            => this.sqlClient.ExecuteReader(
                query: $@"
                    SELECT DISTINCT
	                       [APG].[AuftragNr]
	                     , [K].[Name]
                      FROM [AuftragPosition_Gesamt]	AS [APG]
                      JOIN [Auftrag_Gesamt]			AS [AG]
                        ON [AG].[AuftragNr]			 = [APG].[AuftragNr]
                      JOIN [IdentNr]				AS [IN]
                        ON [IN].[IdentNr]			 = [APG].[Identnr]
                       AND [IN].[Typ]				 = 'GNS'
                      JOIN [Kunde]					AS [K]
                        ON [K].[KundenNr]			 = [AG].[KundenNr]
                     WHERE [K].[Name]	          LIKE @{nameof(clientName)}",
                parameters: parameters => parameters.Add(nameof(clientName), $"%{clientName}%"),
                reader: reader => new KeyValuePair<int, string>(
                    key: reader.GetValue<int>(0),
                    value: reader.GetString(1)));

        public IEnumerable<TestStatus> LoadTestStatus(int orderId)
            => this.sqlClient.ExecuteReader(
                query: $@"
                    SELECT DISTINCT
 	                       [APS].[PositionNr]										AS [PosNr]                          -- 0
	                     , ISNULL([APS].[KundeneigeneSerienNr], [APS].[SerienNr])	AS [SerialNr]                       -- 1
 	                     , [CPT].[CordonelPressureTest_Valid]						AS [3TightnessTest]	                -- 2
 	                     , [DP].[Dicht]												AS [4PressureAndTightness]          -- 3
 	                     , MAX([APS].[StatusFertigung])								AS [5Metrologicaltesting]           -- 4
 	                     , [CRRH].[Result]											AS [6ConfigComparisonAndRadiotest]  -- 5
                      FROM [AuftragPositionSerienNr]								AS [APS]
                      LEFT JOIN [Genesis_Meter]                 AS [GM]             ON [GM].[Seriennummer]                          = [APS].[SerienNr]
                      LEFT JOIN [MapPcbIdToSerialNumber]        AS [PCB]            ON [PCB].[MapPcbIdToSerialNumber_SerialNumber]  = [GM].[Seriennummer]
                      LEFT JOIN [Cordonel_Radio_RSSI_History]	AS [CRRH]           ON [CRRH].[RadioAdress]						    = [GM].[Adresse] - 10000000000
                                                                                   AND [CRRH].[IsLast]							    = 1
                                                                                   AND [CRRH].[Result]							    = 1
                      LEFT JOIN [Druckpruefung]					AS [DP]             ON [DP].[FabNr]								    = [PCB].[MapPcbIdToSerialNumber_PcbId]
                                                                                   AND [DP].[Dicht]								    = 1
                      LEFT JOIN [Cordonel_PressureTest]	        AS [CPT]            ON [CPT].[CordonelPressureTest_PcbId]			= [PCB].[MapPcbIdToSerialNumber_PcbId]	
                                                                                   AND [CPT].[CordonelPressureTest_Valid]			= 1
                     WHERE [APS].[AuftragNr]										 = @{nameof(orderId)}
                     GROUP BY [APS].[PositionNr]
 		                    , [APS].[SerienNr]
 		                    , [APS].[KundeneigeneSerienNr]		
 		                    , [CPT].[CordonelPressureTest_Valid]			
 		                    , [DP].[Dicht]									
 		                    , [CRRH].[Result]							 
                     ORDER BY [APS].[PositionNr]
		                    , ISNULL([APS].[KundeneigeneSerienNr], [APS].[SerienNr])",
                parameters: parameters => parameters.Add(nameof(orderId), orderId),
                reader: reader => new TestStatus
                {
                    PosNr = $"{reader.GetValue<short>(0)}",
                    SerialNr = reader.GetValue<string>(1),
                    HeliumTest = reader.GetValue<bool?>(2),
                    PressureTest = reader.GetValue<bool?>(3),
                    MetroTest = this.MetrologicalValue(reader.GetValue<byte?>(4)),
                    RadioTest = reader.GetValue<bool?>(5),
                });

        public bool OrderCompleted(int orderId)
        {
            var sumResults = this.sqlClient.ExecuteReader($@"
                SELECT CAST(CASE WHEN ISNULL([CPT].[CordonelPressureTest_Valid], 1) = 1 THEN 0 ELSE 1 END AS INT)
	                 + CAST(CASE WHEN ISNULL([DP].[Dicht], 1) = 1 THEN 0 ELSE 1 END AS INT)	
	                 + ISNULL(MAX([APS].[StatusFertigung]) - 30, 0)
	                 + CAST(CASE WHEN ISNULL([CRRH].[Result], 1) = 1 THEN 0 ELSE 1 END AS INT)						
                  FROM [AuftragPositionSerienNr]								AS [APS]
                  LEFT JOIN [Genesis_Meter]                 AS [GM]             ON [GM].[Seriennummer]                          = [APS].[SerienNr]
                  LEFT JOIN [MapPcbIdToSerialNumber]        AS [PCB]            ON [PCB].[MapPcbIdToSerialNumber_SerialNumber]  = [GM].[Seriennummer]
                  LEFT JOIN [Cordonel_Radio_RSSI_History]	AS [CRRH]           ON [CRRH].[RadioAdress]						    = [GM].[Adresse] - 10000000000
                                                                               AND [CRRH].[IsLast]							    = 1
                                                                               AND [CRRH].[Result]							    = 1
                  LEFT JOIN [Druckpruefung]					AS [DP]             ON [DP].[FabNr]								    = [PCB].[MapPcbIdToSerialNumber_PcbId]
                                                                               AND [DP].[Dicht]								    = 1
                  LEFT JOIN [Cordonel_PressureTest]	        AS [CPT]            ON [CPT].[CordonelPressureTest_PcbId]			= [PCB].[MapPcbIdToSerialNumber_PcbId]	
                                                                               AND [CPT].[CordonelPressureTest_Valid]			= 1
                 WHERE [APS].[AuftragNr]										 = @{nameof(orderId)}
                 GROUP BY [APS].[PositionNr]
                        , [APS].[SerienNr]
                        , [APS].[KundeneigeneSerienNr]		
                        , [CPT].[CordonelPressureTest_Valid]			
                        , [DP].[Dicht]									
                        , [CRRH].[Result]",
                parameters => parameters.Add(nameof(orderId), orderId),
                reader => reader.GetValue<int>(0))
                .Sum(x => x);

            return sumResults == 0;
        }

        public int SaveFile(Stream fileStream, int clientId, int orderId)
        {
            var fileName = $"{clientId}_{orderId}.pdf";
            var fileContent = this.GetBuffer(fileStream);

            return this.sqlClient.ExecuteScalar<int>(
                query: $@"
                    INSERT INTO [dbo].[File] (
	                       [FileName]
	                     , [FileContent])
                    OUTPUT  @{nameof(orderId)}, [Inserted].[FileId], 'PROTOCOL'
                      INTO [dbo].[FilesOrders]([OrderId], [FileId], [Usage])
                    OUTPUT [Inserted].[FileId]
                    VALUES (@{nameof(fileName)}
	                     ,  @{nameof(fileContent)})",
                parameters: parameters => parameters
                    .Add(nameof(orderId), orderId)
                    .Add(nameof(fileName), fileName)
                    .AddFile(nameof(fileContent), fileContent));
        }

        private byte[] GetBuffer(Stream fileStream)
        {
            var fileContent = new byte[fileStream.Length];

            using (var memoryStream = new MemoryStream())
            {
                fileStream.CopyTo(memoryStream);

                fileContent = memoryStream.ToArray();
            }

            return fileContent;
        }

        private bool? MetrologicalValue(byte? value)
        {
            if (value is null)
            {
                return null;
            }

            return value == 30;
        }
    }
}