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

namespace ZA.CoreService.ESBCertificateManager.Services;

public sealed class SonicConnectionRepository
{
    private readonly string _connectionString;

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

        _connectionString = connectionString;
    }

    public async Task<IReadOnlyList<DatabaseSonicConnection>>
        GetActiveAsync(
            string? environmentCode = null,
            CancellationToken cancellationToken = default)
    {
        const string sql = """
            SELECT
                connection.[SonicConnectionId],
                connection.[ConnectionName],
                connection.[ManagementHost],
                connection.[ManagementPort],
                connection.[ConnectionProtocol],
                connection.[DomainName],
                environment.[EnvironmentCode],
                connection.[IsActive]
            FROM [dbo].[SonicConnection] AS connection
            INNER JOIN [dbo].[Environment] AS environment
                ON environment.[EnvironmentId] =
                   connection.[EnvironmentId]
            WHERE connection.[IsActive] = 1
              AND environment.[IsActive] = 1
              AND
              (
                  @EnvironmentCode IS NULL
                  OR environment.[EnvironmentCode] = @EnvironmentCode
              )
            ORDER BY connection.[ConnectionName];
            """;

        List<DatabaseSonicConnection> connections = [];

        await using SqlConnection connection =
            new(_connectionString);

        await connection.OpenAsync(cancellationToken);

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

        string? normalizedEnvironmentCode =
            string.IsNullOrWhiteSpace(environmentCode)
                ? null
                : environmentCode.Trim().ToUpperInvariant();

        command.Parameters.Add(
            new SqlParameter(
                "@EnvironmentCode",
                SqlDbType.NVarChar,
                30)
            {
                Value = normalizedEnvironmentCode is null
                    ? DBNull.Value
                    : normalizedEnvironmentCode
            });

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

        int idOrdinal =
            reader.GetOrdinal("SonicConnectionId");

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

        int hostOrdinal =
            reader.GetOrdinal("ManagementHost");

        int portOrdinal =
            reader.GetOrdinal("ManagementPort");

        int protocolOrdinal =
            reader.GetOrdinal("ConnectionProtocol");

        int domainOrdinal =
            reader.GetOrdinal("DomainName");

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

        int isActiveOrdinal =
            reader.GetOrdinal("IsActive");

        while (await reader.ReadAsync(cancellationToken))
        {
            connections.Add(
                new DatabaseSonicConnection
                {
                    Id = reader.GetInt32(idOrdinal),

                    Name =
                        reader.GetString(nameOrdinal),

                    ManagementHost =
                        reader.GetString(hostOrdinal),

                    ManagementPort =
                        reader.GetInt32(portOrdinal),

                    ConnectionProtocol =
                        ReadNullableString(
                            reader,
                            protocolOrdinal),

                    DomainName =
                        ReadNullableString(
                            reader,
                            domainOrdinal),

                    EnvironmentCode =
                        ReadNullableString(
                            reader,
                            environmentCodeOrdinal),

                    IsActive =
                        reader.GetBoolean(
                            isActiveOrdinal)
                });
        }

        return connections;
    }

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