using Microsoft.Data.SqlClient;
using ZA.CoreService.ESBCertificateManager.Models;

namespace ZA.CoreService.ESBCertificateManager.Services;

public sealed class DeploymentTargetRepository
{
    private readonly string _connectionString;

    public DeploymentTargetRepository(string connectionString)
    {
        if (string.IsNullOrWhiteSpace(connectionString))
        {
            throw new ArgumentException(
                "Der SQL-Connection-String ist nicht konfiguriert.",
                nameof(connectionString));
        }

        _connectionString = connectionString;
    }

    public async Task<IReadOnlyList<DeploymentTarget>> GetActiveAsync(
        CancellationToken cancellationToken = default)
    {
        const string sql = """
            SELECT
                target.CertificateTargetId,
                target.TargetDirectory,
                target.TargetFileName,
                target.BackupEnabled,
                target.BackupDirectoryName,
                target.BackupRetentionDays,
                target.IsActive AS TargetIsActive,

                container.SonicContainerId,
                container.ContainerName,
                container.ContainerDisplayName,
                container.RestartTimeoutSeconds,

                connection.ConnectionName,

                service.ServiceCode,
                service.ServiceName,

                environment.EnvironmentCode,
                environment.SortOrder AS EnvironmentSortOrder,

                company.CompanyCode,
                country.CountryCode
            FROM dbo.CertificateTarget AS target
            INNER JOIN dbo.SonicContainer AS container
                ON container.SonicContainerId = target.SonicContainerId
            INNER JOIN dbo.SonicConnection AS connection
                ON connection.SonicConnectionId = container.SonicConnectionId
            INNER JOIN dbo.EsbService AS service
                ON service.EsbServiceId = container.EsbServiceId
            INNER JOIN dbo.Company AS company
                ON company.CompanyId = service.CompanyId
            LEFT JOIN dbo.Country AS country
                ON country.CountryId = service.CountryId
            INNER JOIN dbo.Environment AS environment
                ON environment.EnvironmentId = service.EnvironmentId
            WHERE target.IsActive = 1
              AND container.IsActive = 1
              AND connection.IsActive = 1
              AND service.IsActive = 1
              AND company.IsActive = 1
              AND environment.IsActive = 1
              AND
              (
                  country.CountryId IS NULL
                  OR country.IsActive = 1
              )
            ORDER BY
                company.CompanyCode,
                country.CountryCode,
                environment.SortOrder,
                service.ServiceCode,
                container.ContainerName,
                target.TargetDirectory,
                target.TargetFileName;
            """;

        List<DeploymentTarget> targets = [];

        await using SqlConnection connection = new(_connectionString);
        await connection.OpenAsync(cancellationToken);

        await using SqlCommand command = new(sql, connection);

        await using SqlDataReader reader =
            await command.ExecuteReaderAsync(cancellationToken);

        int targetIdOrdinal =
            reader.GetOrdinal("CertificateTargetId");

        int targetDirectoryOrdinal =
            reader.GetOrdinal("TargetDirectory");

        int targetFileNameOrdinal =
            reader.GetOrdinal("TargetFileName");

        int backupEnabledOrdinal =
            reader.GetOrdinal("BackupEnabled");

        int backupDirectoryNameOrdinal =
            reader.GetOrdinal("BackupDirectoryName");

        int backupRetentionDaysOrdinal =
            reader.GetOrdinal("BackupRetentionDays");

        int targetIsActiveOrdinal =
            reader.GetOrdinal("TargetIsActive");

        int containerNameOrdinal =
            reader.GetOrdinal("ContainerName");

        int containerDisplayNameOrdinal =
            reader.GetOrdinal("ContainerDisplayName");

        int restartTimeoutOrdinal =
            reader.GetOrdinal("RestartTimeoutSeconds");

        int connectionNameOrdinal =
            reader.GetOrdinal("ConnectionName");

        int serviceCodeOrdinal =
            reader.GetOrdinal("ServiceCode");

        int serviceNameOrdinal =
            reader.GetOrdinal("ServiceName");

        int environmentCodeOrdinal =
            reader.GetOrdinal("EnvironmentCode");

        int environmentSortOrderOrdinal =
            reader.GetOrdinal("EnvironmentSortOrder");

        int companyCodeOrdinal =
            reader.GetOrdinal("CompanyCode");

        int countryCodeOrdinal =
            reader.GetOrdinal("CountryCode");

        while (await reader.ReadAsync(cancellationToken))
        {
            string containerName =
                reader.GetString(containerNameOrdinal);

            string? containerDisplayName =
                ReadNullableString(
                    reader,
                    containerDisplayNameOrdinal);

            string serviceCode =
                reader.GetString(serviceCodeOrdinal);

            string serviceName =
                reader.GetString(serviceNameOrdinal);

            string companyCode =
                reader.GetString(companyCodeOrdinal);

            string? countryCode =
                ReadNullableString(reader, countryCodeOrdinal);

            string displayName =
                string.IsNullOrWhiteSpace(containerDisplayName)
                    ? containerName
                    : containerDisplayName;

            string locationCode =
                string.IsNullOrWhiteSpace(countryCode)
                    ? companyCode
                    : $"{companyCode}/{countryCode}";

            targets.Add(new DeploymentTarget
            {
                Id = reader.GetInt32(targetIdOrdinal),

                Name =
                    $"{locationCode} / {serviceName} / {displayName}",

                Environment =
                    reader.GetString(environmentCodeOrdinal),

                IsActive =
                    reader.GetBoolean(targetIsActiveOrdinal),

                TargetDirectory =
                    reader.GetString(targetDirectoryOrdinal),

                CertificateFileName =
                    reader.GetString(targetFileNameOrdinal),

                BackupEnabled =
                    reader.GetBoolean(backupEnabledOrdinal),

                BackupDirectoryName =
                    reader.GetString(backupDirectoryNameOrdinal),

                BackupRetentionDays =
                    ReadNullableInt32(
                        reader,
                        backupRetentionDaysOrdinal),

                ContainerName = containerName,

                RestartType = RestartType.SonicContainer,

                SonicConnectionName =
                    reader.GetString(connectionNameOrdinal),

                RestartTimeoutSeconds =
                    reader.GetInt32(restartTimeoutOrdinal),

                TlsHost = string.Empty,

                TlsPort = null,

                TlsServerName = string.Empty,

                ExpectedFingerprint = null,

                SortOrder =
                    reader.GetInt32(environmentSortOrderOrdinal)
            });
        }

        return targets;
    }

    private static string? ReadNullableString(
        SqlDataReader reader,
        int ordinal)
    {
        return reader.IsDBNull(ordinal)
            ? null
            : reader.GetString(ordinal);
    }

    private static int? ReadNullableInt32(
        SqlDataReader reader,
        int ordinal)
    {
        return reader.IsDBNull(ordinal)
            ? null
            : reader.GetInt32(ordinal);
    }
}