using ZB.MOM.WW.ScadaBridge.Commons.Messages.Artifacts;
using ZB.MOM.WW.Secrets.Abstractions;

namespace ZB.MOM.WW.ScadaBridge.DeploymentManager.Tests;

/// <summary>
/// <see cref="SiteSecretsCollector"/> is the central half of design §3.1/§3.3: derive which
/// secrets a site's data connections reference, resolve each against the central
/// <see cref="ISecretStore"/>, and report the ones that could not be resolved. It never sees
/// or produces plaintext — everything here is ciphertext bytes.
/// </summary>
public class SiteSecretsCollectorTests
{
    private static DataConnectionArtifact Dc(string name, string? primary, string? backup = null)
        => new(name, "MxGateway", primary, backup, 3);

    private static StoredSecret Row(string name, long revision, bool deleted = false, string? description = null) => new()
    {
        Name = new SecretName(name),
        Description = description,
        ContentType = SecretContentType.Text,
        Ciphertext = [1, 2, 3],
        Nonce = [4, 5],
        Tag = [6, 7],
        WrappedDek = [8, 9],
        WrapNonce = [10, 11],
        WrapTag = [12, 13],
        KekId = "kek-1",
        Revision = revision,
        IsDeleted = deleted,
        CreatedUtc = DateTimeOffset.Parse("2026-01-01T00:00:00Z"),
        UpdatedUtc = DateTimeOffset.Parse("2026-01-02T00:00:00Z"),
    };

    /// <summary>Verifies that collect returns only referenced rows and names missing.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Collect_ReturnsOnlyReferencedRows_AndNamesMissing()
    {
        var store = new FakeSecretStore(Row("a", 3), Row("b", 1, deleted: true), Row("other", 1));

        var result = await new SiteSecretsCollector(store).CollectAsync(
            [Dc("GW1", """{"ApiKey":"secret:a"}"""), Dc("GW2", """{"ApiKey":"secret:b"}""")], default);

        // Only the referenced names come back — "other" is in the store but never referenced.
        Assert.Equal(["a"], result.Secrets.Select(s => s.Name));
        Assert.Equal(3, result.Secrets[0].Revision);
        // "b" is tombstoned (IsDeleted) — treated the same as absent.
        Assert.Equal(["b"], result.Missing.Select(m => m.Name));
        Assert.Equal(["GW2"], result.Missing[0].ReferencedBy);
    }

    /// <summary>Verifies that collect resolved row maps every field from the stored secret verbatim.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Collect_ResolvedRow_MapsEveryFieldFromTheStoredSecretVerbatim()
    {
        var row = Row("mxgw-key", revision: 7, description: "MxGateway API key");
        var store = new FakeSecretStore(row);

        var result = await new SiteSecretsCollector(store).CollectAsync(
            [Dc("GW1", """{"ApiKey":"secret:mxgw-key"}""")], default);

        var artifact = Assert.Single(result.Secrets);
        Assert.Empty(result.Missing);
        Assert.Equal(row.Name.Value, artifact.Name);
        Assert.Equal(row.ContentType.ToString(), artifact.ContentType);
        Assert.Equal(row.Ciphertext, artifact.Ciphertext);
        Assert.Equal(row.Nonce, artifact.Nonce);
        Assert.Equal(row.Tag, artifact.Tag);
        Assert.Equal(row.WrappedDek, artifact.WrappedDek);
        Assert.Equal(row.WrapNonce, artifact.WrapNonce);
        Assert.Equal(row.WrapTag, artifact.WrapTag);
        Assert.Equal(row.KekId, artifact.KekId);
        Assert.Equal(row.Revision, artifact.Revision);
        Assert.Equal(row.CreatedUtc, artifact.CreatedUtc);
        Assert.Equal(row.UpdatedUtc, artifact.UpdatedUtc);
        Assert.Equal(row.Description, artifact.Description);
    }

    /// <summary>Verifies that collect absent name is reported missing not thrown.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Collect_AbsentName_IsReportedMissing_NotThrown()
    {
        var store = new FakeSecretStore();

        var result = await new SiteSecretsCollector(store).CollectAsync(
            [Dc("GW1", """{"ApiKey":"secret:never-created"}""")], default);

        Assert.Empty(result.Secrets);
        var missing = Assert.Single(result.Missing);
        Assert.Equal("never-created", missing.Name);
        Assert.Equal(["GW1"], missing.ReferencedBy);
    }

    /// <summary>Verifies that collect no secret references returns empty without querying the store.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Collect_NoSecretReferences_ReturnsEmptyWithoutQueryingTheStore()
    {
        var store = new FakeSecretStore(Row("unused", 1));

        var result = await new SiteSecretsCollector(store).CollectAsync(
            [Dc("GW1", """{"Endpoint":"http://gw:5000"}""")], default);

        Assert.Empty(result.Secrets);
        Assert.Empty(result.Missing);
    }

    /// <summary>Verifies that collect store throws returns store error instead of throwing.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Collect_StoreThrows_ReturnsStoreError_InsteadOfThrowing()
    {
        // One site's store read failing must not abort a whole sweep.
        var store = new FakeSecretStore(Row("a", 1)) { Fault = new InvalidOperationException("db down") };

        var result = await new SiteSecretsCollector(store).CollectAsync(
            [Dc("GW1", """{"ApiKey":"secret:a"}""")], default);

        Assert.NotNull(result.StoreError);
        Assert.Contains("'a'", result.StoreError);
        Assert.Contains("InvalidOperationException: db down", result.StoreError);
    }

    /// <summary>Verifies that collect caller cancellation still propagates.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Collect_CallerCancellation_StillPropagates()
    {
        using var cts = new CancellationTokenSource();
        cts.Cancel();
        var store = new FakeSecretStore(Row("a", 1)) { Fault = new OperationCanceledException(cts.Token) };

        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => new SiteSecretsCollector(store).CollectAsync(
            [Dc("GW1", """{"ApiKey":"secret:a"}""")], cts.Token));
    }

    /// <summary>Verifies that collect success has no store error.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Collect_Success_HasNoStoreError()
    {
        var result = await new SiteSecretsCollector(new FakeSecretStore(Row("a", 1))).CollectAsync(
            [Dc("GW1", """{"ApiKey":"secret:a"}""")], default);

        Assert.Null(result.StoreError);
    }

    /// <summary>
    /// In-memory <see cref="ISecretStore"/> stand-in. Implements only <see cref="GetAsync"/> —
    /// the sole member <see cref="SiteSecretsCollector"/> calls; every other member throws so an
    /// accidental call (a write, a list, a replication apply) fails the test loudly instead of
    /// silently no-op'ing.
    /// </summary>
    private sealed class FakeSecretStore : ISecretStore
    {
        private readonly Dictionary<SecretName, StoredSecret> _rows;

        /// <summary>Initializes a new instance of <c>FakeSecretStore</c>.</summary>
        /// <param name="rows">The rows.</param>
        public FakeSecretStore(params StoredSecret[] rows) => _rows = rows.ToDictionary(r => r.Name);

        /// <summary>When set, <see cref="GetAsync"/> throws this instead of reading.</summary>
        public Exception? Fault { get; init; }

        /// <summary>Returns the canned secret row, or faults when a fault is configured.</summary>
        /// <param name="name">The secret name to look up.</param>
        /// <param name="ct">A token to cancel the operation.</param>
        /// <returns>A task that yields the stored secret, or null.</returns>
        public Task<StoredSecret?> GetAsync(SecretName name, CancellationToken ct) =>
            Fault is not null
                ? Task.FromException<StoredSecret?>(Fault)
                : Task.FromResult(_rows.TryGetValue(name, out var row) ? row : null);

        /// <summary>Not supported by this fake.</summary>
        /// <param name="row">The secret row, unused.</param>
        /// <param name="ct">A token to cancel the operation.</param>
        /// <returns>A task that represents the asynchronous operation.</returns>
        public Task UpsertAsync(StoredSecret row, CancellationToken ct) => throw new NotSupportedException();

        /// <summary>Not supported by this fake.</summary>
        /// <param name="name">The secret name, unused.</param>
        /// <param name="actor">The acting user, unused.</param>
        /// <param name="ct">A token to cancel the operation.</param>
        /// <returns>A task that yields whether a row was deleted.</returns>
        public Task<bool> DeleteAsync(SecretName name, string? actor, CancellationToken ct) =>
            throw new NotSupportedException();

        /// <summary>Not supported by this fake.</summary>
        /// <param name="includeDeleted">Whether tombstoned secrets are included.</param>
        /// <param name="ct">A token to cancel the operation.</param>
        /// <returns>A task that yields the secret metadata.</returns>
        public Task<IReadOnlyList<SecretMetadata>> ListAsync(bool includeDeleted, CancellationToken ct) =>
            throw new NotSupportedException();

        /// <summary>Not supported by this fake.</summary>
        /// <param name="ct">A token to cancel the operation.</param>
        /// <returns>A task that yields the secret manifest.</returns>
        public Task<IReadOnlyList<SecretManifestEntry>> GetManifestAsync(CancellationToken ct) =>
            throw new NotSupportedException();

        /// <summary>Not supported by this fake.</summary>
        /// <param name="row">The replicated secret row, unused.</param>
        /// <param name="ct">A token to cancel the operation.</param>
        /// <returns>A task that represents the asynchronous operation.</returns>
        public Task ApplyReplicatedAsync(StoredSecret row, CancellationToken ct) =>
            throw new NotSupportedException();

        /// <summary>Not supported by this fake.</summary>
        /// <param name="rewrappedRow">The rewrapped secret row, unused.</param>
        /// <param name="expectedCurrentWrappedDek">The wrapped data key expected to be current, unused.</param>
        /// <param name="ct">A token to cancel the operation.</param>
        /// <returns>A task that yields whether the rewrap was applied.</returns>
        public Task<bool> ApplyRewrapAsync(
            StoredSecret rewrappedRow, byte[] expectedCurrentWrappedDek, CancellationToken ct) =>
            throw new NotSupportedException();
    }
}