MeterVault/src/Infrastructure/Ingestion/HaConnectionTester.cs

using System.Net.Http.Headers;
using Microsoft.Extensions.Logging;

namespace MeterVault.Infrastructure.Ingestion;

/// <summary>Which way a Home Assistant connectivity test ended.</summary>
/// <remarks>
/// The verdict is shown to whoever clicked "Test connection", so it has to be sayable in their
/// language — and this assembly has no business knowing what that is. The outcome travels as a
/// value and the admin UI supplies the words.
/// </remarks>
public enum HaTestOutcome
{
    /// <summary>
    /// No test was run — the caller decided beforehand (no token configured, base URL edited since
    /// saving) and put its own, already-localized wording in <see cref="HaTestResult.Message"/>.
    /// The default, so a result built by the UI needs no ceremony to say so.
    /// </summary>
    Precondition,

    /// <summary>Reachable and the token was accepted; no entity was named to sample.</summary>
    Connected,

    /// <summary>Reachable and the named entity returned a number — see <see cref="HaTestResult.SampleValue"/>.</summary>
    ConnectedWithValue,

    /// <summary>No base URL was given.</summary>
    BaseUrlMissing,

    /// <summary>No token was available to test with.</summary>
    TokenMissing,

    /// <summary>HA answered, but not with success. <see cref="HaTestResult.Detail"/> carries the status.</summary>
    HttpError,

    /// <summary>Reachable, but the named entity has no numeric state (unavailable/unknown/non-numeric).</summary>
    NoNumericState,

    /// <summary>The request threw. <see cref="HaTestResult.Detail"/> carries the exception message.</summary>
    RequestFailed,
}

/// <summary>Outcome of a Home Assistant connectivity test.</summary>
/// <param name="Message">The English summary, kept for logs and non-UI callers.</param>
/// <param name="Outcome">The same verdict as a value, for a UI that has to phrase it in some language.</param>
/// <param name="EntityId">The entity that was sampled, when one was named.</param>
/// <param name="Detail">Diagnostic text (HTTP status, exception message). Not ours to translate.</param>
public sealed record HaTestResult(
    bool Ok,
    string Message,
    double? SampleValue = null,
    HaTestOutcome Outcome = HaTestOutcome.Precondition,
    string? EntityId = null,
    string? Detail = null);

/// <summary>
/// Verifies a Home Assistant connection from the admin UI: checks the base URL + token against
/// <c>GET /api/</c>, and optionally reads one entity's state. Confirms the app can actually read HA
/// before a source is relied upon (SDD §6.2).
/// </summary>
/// <remarks>
/// Takes the token already resolved rather than a reference to one. The admin UI must be able to
/// test a token that has been typed but not yet saved (so not yet encrypted), and keeping the two
/// storage forms out of here leaves one resolution path in <see cref="EndpointSecret"/>.
/// </remarks>
public sealed class HaConnectionTester(IHttpClientFactory httpClientFactory, ILogger<HaConnectionTester> logger)
{
    private readonly IHttpClientFactory _httpClientFactory = httpClientFactory;
    private readonly ILogger<HaConnectionTester> _logger = logger;

    public async Task<HaTestResult> TestAsync(
        string? baseUrl, string? token, string? entityId, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(baseUrl))
        {
            return new HaTestResult(false, "Base URL is required.", Outcome: HaTestOutcome.BaseUrlMissing);
        }

        if (string.IsNullOrWhiteSpace(token))
        {
            return new HaTestResult(false, "No token available to test.", Outcome: HaTestOutcome.TokenMissing);
        }

        var client = _httpClientFactory.CreateClient();
        client.Timeout = TimeSpan.FromSeconds(10);

        try
        {
            using var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl.TrimEnd('/')}/api/");
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
            using var response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);
            if (!response.IsSuccessStatusCode)
            {
                return new HaTestResult(false, $"HA returned {(int)response.StatusCode} {response.ReasonPhrase}.",
                    Outcome: HaTestOutcome.HttpError,
                    Detail: $"{(int)response.StatusCode} {response.ReasonPhrase}".Trim());
            }

            if (string.IsNullOrWhiteSpace(entityId))
            {
                return new HaTestResult(true, "Connected — Home Assistant API reachable and token accepted.",
                    Outcome: HaTestOutcome.Connected);
            }

            var state = await new HaStateClient(client).GetStateAsync(baseUrl, token, entityId, null, cancellationToken).ConfigureAwait(false);
            return state is { } value
                ? new HaTestResult(true, $"Connected — {entityId} = {value.Value}.", value.Value,
                    HaTestOutcome.ConnectedWithValue, entityId)
                : new HaTestResult(false, $"Connected, but '{entityId}' has no numeric state (unavailable/unknown or non-numeric).",
                    Outcome: HaTestOutcome.NoNumericState, EntityId: entityId);
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "Home Assistant connection test failed for {BaseUrl}", baseUrl);
            return new HaTestResult(false, $"Connection failed: {ex.Message}",
                Outcome: HaTestOutcome.RequestFailed, Detail: ex.Message);
        }
    }
}